算法13-16队列和栈-链表、数组实现

算法13-16队列和栈-链表、数组实现

622. 设计循环队列

数组实现循环队列

class MyCircularQueue {

    int quene[];
    int l,r,size,limit;

    public MyCircularQueue(int k) {
        quene=new int[k];
        l=r=size=0;
        limit=k;
    }
    
    public boolean enQueue(int value) {
        if(size==limit){
            return false;
        }else{
            quene[r]=value;
            r=(r+1)%limit;
            size++;
            return true;
        }

    }
    
    public boolean deQueue() {
        if(size==0){
            return false;
        }else{
            l=(l+1)%limit;
            size--;
            return true;
        }
    }
    
    public int Front() {
        if(size==0){
            return -1;
        }else{
            return quene[l];
        }
    }
    
    public int Rear() {
        if(size==0){
            return -1;
        }else{
            return quene[r==0?limit-1:r-1];
        }
    }
    
    public boolean isEmpty() {
        return size==0?true:false;
    }
    
    public boolean isFull() {
        return size==limit?true:false;
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */

用栈实现队列

232. 用栈实现队列

	// 测试链接 : https://leetcode.cn/problems/implement-queue-using-stacks/
	class MyQueue {

		public Stack<Integer> in;

		public Stack<Integer> out;

		public MyQueue() {
			in = new Stack<Integer>();
			out = new Stack<Integer>();
		}

		// 倒数据
		// 从in栈，把数据倒入out栈
		// 1) out空了，才能倒数据
		// 2) 如果倒数据，in必须倒完
		private void inToOut() {
			if (out.empty()) {
				while (!in.empty()) {
					out.push(in.pop());
				}
			}
		}

		public void push(int x) {
			in.push(x);
			inToOut();
		}

		public int pop() {
			inToOut();
			return out.pop();
		}

		public int peek() {
			inToOut();
			return out.peek();
		}

		public boolean empty() {
			return in.isEmpty() && out.isEmpty();
		}

	}

用对列实现栈

225. 用队列实现栈

两个队列实现

class MyStack {

	Queue<Integer> queue1;
	Queue<Integer> queue2;
	public MyStack() {
		queue1 = new LinkedList<Integer>();
    queue2 = new LinkedList<Integer>();
	}
    
    public void push(int x) {
      queue2.offer(x);
      while(!queue1.isEmpty()){
        queue2.offer(queue1.poll());
      }
      Queue<Integer> temp=queue1;
      queue1=queue2;
      queue2=temp;
    }
    
		public int pop() {
			return queue1.poll();
		}

    
    public int top() {
      return queue1.peek();
    }
    
    public boolean empty() {
			return queue1.isEmpty();
    }
}

一个队列实现

	class MyStack {

		Queue<Integer> queue;

		public MyStack() {
			queue = new LinkedList<Integer>();
		}

		// O(n)
		public void push(int x) {
			int n = queue.size();
			queue.offer(x);
			for (int i = 0; i < n; i++) {
				queue.offer(queue.poll());
			}
		}

		public int pop() {
			return queue.poll();
		}

		public int top() {
			return queue.peek();
		}

		public boolean empty() {
			return queue.isEmpty();
		}

	}

最小栈

155. 最小栈

答案的解法好巧妙呀

	class MinStack1 {
		public Stack<Integer> data;
		public Stack<Integer> min;

		public MinStack1() {
			data = new Stack<Integer>();
			min = new Stack<Integer>();
		}

		public void push(int val) {
			data.push(val);
			if (min.isEmpty() || val <= min.peek()) {
				min.push(val);
			} else { // !min.isEmpty() && val > min.peek()
				min.push(min.peek());
			}
		}

		public void pop() {
			data.pop();
			min.pop();
		}

		public int top() {
			return data.peek();
		}

		public int getMin() {
			return min.peek();
		}
	}

双端队列

641. 设计循环双端队列

class MyCircularDeque {
    public int[] deque;
    int limit,size,l,r;
    public MyCircularDeque(int k) {
        deque=new int[k];
        limit=k;
        size=0;
    }
    
    public boolean insertFront(int value) {
        if(isFull()){
            return false;
        }else{
            l= l==0?limit-1:l-1;
            deque[l]=value;
            size++;
            return true;
        }
    }
    
    public boolean insertLast(int value) {
        if(isFull()){
            return false;
        }else{
            deque[r]=value;
            size++;
            r=(r+1)%limit;
            return true;
        }
    }
    
    public boolean deleteFront() {
        if(isEmpty()){
            return false;
        }else{
            size--;
            l=(l+1)%limit;
            return true;
        }
        
    }
    
    public boolean deleteLast() {
        if(isEmpty()){
            return false;
        }else{
            size--;
            r= r==0?limit-1:r-1;
            return true;
        }

    }
    
    public int getFront() {
        if(isEmpty()){
            return -1;
        }else{
            return deque[l];
        }
    }
    
    public int getRear() {
        if(isEmpty()){
            return -1;
        }else{
            int t= r==0?limit-1:r-1;
            return deque[t];
        }
    }
    
    public boolean isEmpty() {
        return size==0;
    }
    
    public boolean isFull() {
        return size==limit;
    }
}