1. Chain stack (implement stack with linked list)
>1, initialize the stack
class Entry{ int data; Entry next; public Entry(){ this.data = -1; this.next = null; } public Entry(int val){ this.data = val; this.next = null; } } public Entry head = null; public LinkStack(){ this.head = new Entry(); }
>2, push the stack
public void push(int val){ Entry entry = new Entry(val); entry.next = head.next; head.next = entry; }
>3, judge the stack empty
public boolean isEmpty(){ if(head.next == null) return true; return false; }
>4, pop the stack
public boolean pop(){ if(isEmpty()){ return false; } head.next = head.next.next; return true; }
>5, get the top element of the stack
public int gettop(){ if(isEmpty()){ return -1; } return head.next.data; }
2. Queue
Queue: A linear table that can only perform insertion operations at one end of the table and delete operations at the other end of the table (head-delete-tail insertion)
(Two stacks implement queues)
1, initialize two stacks
Stack s1 = new Stack(); Stack s2 = new Stack();
2. Join the team
Put data into the stack of s1
// enqueue public void pushQ(int val){ if(s1.isFull()){ return; } s1.push(val); }
3. Departure
Pop the data in the S1 stack to S2, (pay attention to keep the low number of the s1 stack) and then pour s2 into s1, overwriting the element at the low level of the s1 stack. Departure
------》
//dequeue public void popQ(){ if(s1.isEmpty()){ return; } while(s1.top > 1){ s2.push(s1.gettop()); s1.top--; } s1.top = 0; while(!s2.isEmpty()){ s1.push(s2.gettop()); s2.top--; } }3. Get the top element of the team
// get the top element public int gettop(){ return s1.elem[0]; }
3, circular queue
Sequential team "deletion and insertion" is prone to " false overflow "
When the tail pointer has reached the upper bound of the array, there can be no more enqueue operations, but there are still empty positions in the array, which is called "false overflow".
So we will use --- circular queue --- to solve the false overflow
In the circular queue, the empty queue is characterized by front=rear; when the queue is full, there will also be front=rear;
the solution:
One unit is wasted artificially, and the full feature of the team is front=(rear+1)%N;
Empty condition: front = rear
Full condition: front = (rear+1) % N (N=allsize)
Queue length: L=(N+rear-front) % N
Circular queue operations -------
1. Initialize
int [] element; int front; // team head int rear;//The end of the queue int usedSize = 0;//Number of valid data in the current circular queue int allSize = 10; public QueueLink(){ this(10); } public QueueLink(int size){ this.elem = new int[size]; this.front = 0; this.rear = 0; }2, the team is full
// method to determine whether it is full public boolean isFull(){ if((this.rear+1) % this.allSize == this.front) return true; return false; }
3. Join the team
public void push(int val){ if(isFull()){ return; } this.elem[this.rear] = val; this.rear = (this.rear+1) % this.allSize; this.usedSize++; }
4, the team is empty
public boolean isEmpty(){ return this.front == this.rear; }
5. Departure
//dequeue public void pop(){ if(isEmpty()){ return; } this.elem[this.front] = -1; this.front = (this.front+1) % this.allSize; this.usedSize--; }
6. Get the head element
// get the head element public int gettop(){ if(isEmpty()){ return -1; } return this.elem[this.front]; }
7, print queue elements
public void show(){ for(int i = this.front;i != this.rear;i = (i+1) % this.allSize){ System.out.print(this.elem[i]+" "); } System.err.println(); }