publicinterfaceStack<E>{
intgetSize();booleanisEmpty();voidpush(E e);
E pop();
E peek();}
publicclassArray<E>{
private E[] data;privateint size;// 构造函数,传入数组的容量capacity构造ArraypublicArray(int capacity){
data =(E[])newObject[capacity];
size =0;}// 无参数的构造函数,默认数组的容量capacity=10publicArray(){
this(10);}// 获取数组的容量publicintgetCapacity(){
return data.length;}// 获取数组中的元素个数publicintgetSize(){
return size;}// 返回数组是否为空publicbooleanisEmpty(){
return size ==0;}// 在index索引的位置插入一个新元素epublicvoidadd(int index, E e){
if(index <0|| index > size)thrownewIllegalArgumentException("Add failed. Require index >= 0 and index <= size.");if(size == data.length)resize(2* data.length);for(int i = size -1; i >= index ; i --)
data[i +1]= data[i];
data[index]= e;
size ++;}// 向所有元素后添加一个新元素publicvoidaddLast(E e){
add(size, e);}// 在所有元素前添加一个新元素publicvoidaddFirst(E e){
add(0, e);}// 获取index索引位置的元素public E get(int index){
if(index <0|| index >= size)thrownewIllegalArgumentException("Get failed. Index is illegal.");return data[index];}public E getLast(){
returnget(size -1);}public E getFirst(){
returnget(0);}// 修改index索引位置的元素为epublicvoidset(int index, E e){
if(index <0|| index >= size)thrownewIllegalArgumentException("Set failed. Index is illegal.");
data[index]= e;}// 查找数组中是否有元素epublicbooleancontains(E e){
for(int i =0; i < size ; i ++){
if(data[i].equals(e))returntrue;}returnfalse;}// 查找数组中元素e所在的索引,如果不存在元素e,则返回-1publicintfind(E e){
for(int i =0; i < size ; i ++){
if(data[i].equals(e))return i;}return-1;}// 从数组中删除index位置的元素, 返回删除的元素public E remove(int index){
if(index <0|| index >= size)thrownewIllegalArgumentException("Remove failed. Index is illegal.");
E ret = data[index];for(int i = index +1; i < size ; i ++)
data[i -1]= data[i];
size --;
data[size]= null;// loitering objects != memory leakif(size == data.length /4&& data.length /2!=0)resize(data.length /2);return ret;}// 从数组中删除第一个元素, 返回删除的元素public E removeFirst(){
returnremove(0);}// 从数组中删除最后一个元素, 返回删除的元素public E removeLast(){
returnremove(size -1);}// 从数组中删除元素epublicvoidremoveElement(E e){
int index =find(e);if(index !=-1)remove(index);}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
res.append('[');for(int i =0; i < size ; i ++){
res.append(data[i]);if(i != size -1)
res.append(", ");}
res.append(']');return res.toString();}// 将数组空间的容量变成newCapacity大小privatevoidresize(int newCapacity){
E[] newData =(E[])newObject[newCapacity];for(int i =0; i < size ; i ++)
newData[i]= data[i];
data = newData;}}
publicclassArrayStack<E>implementsStack<E>{
private Array<E> array;publicArrayStack(int capacity){
array =newArray<>(capacity);}publicArrayStack(){
array =newArray<>();}@OverridepublicintgetSize(){
return array.getSize();}@OverridepublicbooleanisEmpty(){
return array.isEmpty();}publicintgetCapacity(){
return array.getCapacity();}@Overridepublicvoidpush(E e){
array.addLast(e);}@Overridepublic E pop(){
return array.removeLast();}@Overridepublic E peek(){
return array.getLast();}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
res.append("Stack: ");
res.append('[');for(int i =0; i < array.getSize(); i ++){
res.append(array.get(i));if(i != array.getSize()-1)
res.append(", ");}
res.append("] top");return res.toString();}}
publicclassMain{
publicstaticvoidmain(String[] args){
ArrayStack<Integer> stack =newArrayStack<>();for(int i =0; i <5; i ++){
stack.push(i);
System.out.println(stack);}
stack.pop();
System.out.println(stack);}}
import java.util.Stack;classSolution{
publicbooleanisValid(String s){
Stack<Character> stack =newStack<>();for(int i =0; i < s.length(); i ++){
char c = s.charAt(i);if(c =='('|| c =='['|| c =='{')
stack.push(c);else{
if(stack.isEmpty())returnfalse;char topChar = stack.pop();if(c ==')'&& topChar !='(')returnfalse;if(c ==']'&& topChar !='[')returnfalse;if(c =='}'&& topChar !='{')returnfalse;}}return stack.isEmpty();}publicstaticvoidmain(String[] args){
System.out.println((newSolution()).isValid("()[]{}"));//true
System.out.println((newSolution()).isValid("([)]"));//false
System.out.println((newSolution()).isValid("{[{[{}]}]}"));//true}}
queue
publicinterfaceQueue<E>{
intgetSize();booleanisEmpty();voidenqueue(E e);
E dequeue();
E getFront();}
publicclassArrayQueue<E>implementsQueue<E>{
private Array<E> array;publicArrayQueue(int capacity){
array =newArray<>(capacity);}publicArrayQueue(){
array =newArray<>();}@OverridepublicintgetSize(){
return array.getSize();}@OverridepublicbooleanisEmpty(){
return array.isEmpty();}publicintgetCapacity(){
return array.getCapacity();}@Overridepublicvoidenqueue(E e){
array.addLast(e);}@Overridepublic E dequeue(){
return array.removeFirst();}@Overridepublic E getFront(){
return array.getFirst();}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
res.append("Queue: ");
res.append("front [");for(int i =0; i < array.getSize(); i ++){
res.append(array.get(i));if(i != array.getSize()-1)
res.append(", ");}
res.append("] tail");return res.toString();}publicstaticvoidmain(String[] args){
ArrayQueue<Integer> queue =newArrayQueue<>();for(int i =0; i <10; i ++){
queue.enqueue(i);
System.out.println(queue);if(i %3==2){
queue.dequeue();
System.out.println(queue);}}}}
// 二叉树的层序遍历是一个典型的可以借助队列解决的问题
publicclassLoopQueue<E>implementsQueue<E>{
private E[] data;privateint front, tail;privateint size;// 有兴趣的同学,在完成这一章后,可以思考一下:// LoopQueue中不声明size,如何完成所有的逻辑?// 这个问题可能会比大家想象的要难一点点:)publicLoopQueue(int capacity){
data =(E[])newObject[capacity +1];
front =0;
tail =0;
size =0;}publicLoopQueue(){
this(10);}publicintgetCapacity(){
return data.length -1;}@OverridepublicbooleanisEmpty(){
return front == tail;}@OverridepublicintgetSize(){
return size;}@Overridepublicvoidenqueue(E e){
if((tail +1)% data.length == front)resize(getCapacity()*2);
data[tail]= e;
tail =(tail +1)% data.length;
size ++;}@Overridepublic E dequeue(){
if(isEmpty())thrownewIllegalArgumentException("Cannot dequeue from an empty queue.");
E ret = data[front];
data[front]= null;
front =(front +1)% data.length;
size --;if(size ==getCapacity()/4&&getCapacity()/2!=0)resize(getCapacity()/2);return ret;}@Overridepublic E getFront(){
if(isEmpty())thrownewIllegalArgumentException("Queue is empty.");return data[front];}privatevoidresize(int newCapacity){
E[] newData =(E[])newObject[newCapacity +1];for(int i =0; i < size ; i ++)
newData[i]= data[(i + front)% data.length];
data = newData;
front =0;
tail = size;}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
res.append(String.format("Queue: size = %d , capacity = %d\n", size,getCapacity()));
res.append("front [");for(int i = front ; i != tail ; i =(i +1)% data.length){
res.append(data[i]);if((i +1)% data.length != tail)
res.append(", ");}
res.append("] tail");return res.toString();}publicstaticvoidmain(String[] args){
LoopQueue<Integer> queue =newLoopQueue<>();for(int i =0; i <10; i ++){
queue.enqueue(i);
System.out.println(queue);if(i %3==2){
queue.dequeue();
System.out.println(queue);}}}}
import java.util.Random;publicclassMain{
// 测试使用q运行opCount个enqueueu和dequeue操作所需要的时间,单位:秒privatestaticdoubletestQueue(Queue<Integer> q,int opCount){
long startTime = System.nanoTime();
Random random =newRandom();for(int i =0; i < opCount ; i ++)
q.enqueue(random.nextInt(Integer.MAX_VALUE));for(int i =0; i < opCount ; i ++)
q.dequeue();long endTime = System.nanoTime();return(endTime - startTime)/1000000000.0;}publicstaticvoidmain(String[] args){
int opCount =100000;
ArrayQueue<Integer> arrayQueue =newArrayQueue<>();double time1 =testQueue(arrayQueue, opCount);
System.out.println("ArrayQueue, time: "+ time1 +" s");
LoopQueue<Integer> loopQueue =newLoopQueue<>();double time2 =testQueue(loopQueue, opCount);
System.out.println("LoopQueue, time: "+ time2 +" s");}}//result:/********************************************************************************
ArrayQueue, time: 52.236474331 s
LoopQueue, time: 0.016045354 s
********************************************************************************/
LinkedList
publicclassLinkedList<E>{
privateclassNode{
public E e;public Node next;publicNode(E e, Node next){
this.e = e;this.next = next;}publicNode(E e){
this(e, null);}publicNode(){
this(null, null);}@Overridepublic String toString(){
return e.toString();}}private Node dummyHead;privateint size;publicLinkedList(){
dummyHead =newNode();
size =0;}// 获取链表中的元素个数publicintgetSize(){
return size;}// 返回链表是否为空publicbooleanisEmpty(){
return size ==0;}// 在链表的index(0-based)位置添加新的元素e// 在链表中不是一个常用的操作,练习用:)publicvoidadd(int index, E e){
if(index <0|| index > size)thrownewIllegalArgumentException("Add failed. Illegal index.");
Node prev = dummyHead;for(int i =0; i < index ; i ++)
prev = prev.next;
prev.next =newNode(e, prev.next);
size ++;}// 在链表头添加新的元素epublicvoidaddFirst(E e){
add(0, e);}// 在链表末尾添加新的元素epublicvoidaddLast(E e){
add(size, e);}// 获得链表的第index(0-based)个位置的元素// 在链表中不是一个常用的操作,练习用:)public E get(int index){
if(index <0|| index >= size)thrownewIllegalArgumentException("Get failed. Illegal index.");
Node cur = dummyHead.next;for(int i =0; i < index ; i ++)
cur = cur.next;return cur.e;}// 获得链表的第一个元素public E getFirst(){
returnget(0);}// 获得链表的最后一个元素public E getLast(){
returnget(size -1);}// 修改链表的第index(0-based)个位置的元素为e// 在链表中不是一个常用的操作,练习用:)publicvoidset(int index, E e){
if(index <0|| index >= size)thrownewIllegalArgumentException("Update failed. Illegal index.");
Node cur = dummyHead.next;for(int i =0; i < index ; i ++)
cur = cur.next;
cur.e = e;}// 查找链表中是否有元素epublicbooleancontains(E e){
Node cur = dummyHead.next;while(cur != null){
if(cur.e.equals(e))returntrue;
cur = cur.next;}returnfalse;}// 从链表中删除index(0-based)位置的元素, 返回删除的元素// 在链表中不是一个常用的操作,练习用:)public E remove(int index){
if(index <0|| index >= size)thrownewIllegalArgumentException("Remove failed. Index is illegal.");// E ret = findNode(index).e; // 两次遍历
Node prev = dummyHead;for(int i =0; i < index ; i ++)
prev = prev.next;
Node retNode = prev.next;
prev.next = retNode.next;
retNode.next = null;
size --;return retNode.e;}// 从链表中删除第一个元素, 返回删除的元素public E removeFirst(){
returnremove(0);}// 从链表中删除最后一个元素, 返回删除的元素public E removeLast(){
returnremove(size -1);}// 从链表中删除元素epublicvoidremoveElement(E e){
Node prev = dummyHead;while(prev.next != null){
if(prev.next.e.equals(e))break;
prev = prev.next;}if(prev.next != null){
Node delNode = prev.next;
prev.next = delNode.next;
delNode.next = null;
size --;}}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
Node cur = dummyHead.next;while(cur != null){
res.append(cur +"->");
cur = cur.next;}
res.append("NULL");return res.toString();}}
publicclassLinkedListStack<E>implementsStack<E>{
private LinkedList<E> list;publicLinkedListStack(){
list =newLinkedList<>();}@OverridepublicintgetSize(){
return list.getSize();}@OverridepublicbooleanisEmpty(){
return list.isEmpty();}@Overridepublicvoidpush(E e){
list.addFirst(e);}@Overridepublic E pop(){
return list.removeFirst();}@Overridepublic E peek(){
return list.getFirst();}@Overridepublic String toString(){
StringBuilder res =newStringBuilder();
res.append("Stack: top ");
res.append(list);return res.toString();}publicstaticvoidmain(String[] args){
LinkedListStack<Integer> stack =newLinkedListStack<>();for(int i =0; i <5; i ++){
stack.push(i);
System.out.println(stack);}
stack.pop();
System.out.println(stack);}}
// 删除链表中等于给定值 val 的所有节点。//输入: 1->2->6->3->4->5->6, val = 6//输出: 1->2->3->4->5//Definition for singly-linked list.publicclassListNode{
publicint val;public ListNode next;publicListNode(int x){
val = x;}}