算法基础-栈和队列（怎么利用数组和链表实现）

一、逻辑概念

栈：数据先进后出，犹如弹匣

队列：数据先进先出，好似排队

二、栈和队列的实现（自己实现）

1、双向链表实现

public static class Node<T> {
		public T value;
		public Node<T> last;
		public Node<T> next;

		public Node(T data) {
			value = data;
		}
	}
	//栈  队列 
	//双向链表的添加及弹出操作
	public static class DoubleEndsQueue<T> {
		public Node<T> head;
		public Node<T> tail;
		//头部进
		public void addFromHead(T value) {
			Node<T> cur = new Node<T>(value);
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				cur.next = head;
				head.last = cur;
				head = cur;
			}
		}
		//尾部进
		public void addFromBottom(T value) {
			Node<T> cur = new Node<T>(value);
			if (head == null) {
				head = cur;
				tail = cur;
			} else {
				cur.last = tail;
				tail.next = cur;
				tail = cur;
			}
		}
		//头部出
		public T popFromHead() {
			if (head == null) {
				return null;
			}
			Node<T> cur = head;
			if (head == tail) {
				head = null;
				tail = null;
			} else {
				head = head.next;
				cur.next = null;
				head.last = null;
			}
			return cur.value;
		}
		//尾部出
		public T popFromBottom() {
			if (head == null) {
				return null;
			}
			Node<T> cur = tail;
			if (head == tail) {
				head = null;
				tail = null;
			} else {
				tail = tail.last;
				tail.next = null;
				cur.last = null;
			}
			return cur.value;
		}

		public boolean isEmpty() {
			return head == null;
		}

	}
	//双向链表实现栈
	public static class MyStack<T> {
		private DoubleEndsQueue<T> queue;

		public MyStack() {
			queue = new DoubleEndsQueue<T>();
		}

		public void push(T value) {
			queue.addFromHead(value);
		}

		public T pop() {
			return queue.popFromHead();
		}

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

	}
	//双向链表实现队列
	public static class MyQueue<T> {
		private DoubleEndsQueue<T> queue;

		public MyQueue() {
			queue = new DoubleEndsQueue<T>();
		}

		public void push(T value) {
			queue.addFromHead(value);
		}

		public T poll() {
			return queue.popFromBottom();
		}

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

	}

	public static boolean isEqual(Integer o1, Integer o2) {
		if (o1 == null && o2 != null) {
			return false;
		}
		if (o1 != null && o2 == null) {
			return false;
		}
		if (o1 == null && o2 == null) {
			return true;
		}
		return o1.equals(o2);
	}

2、数组实现

// 数组实现栈和队列

	public static class MyQueue {
		private int[] arr; //
		private int pushi;// 放的位置
		private int polli;// 取的位置
		private int size; // 如果实现队列 需要判断数据是否达到最大值或者取的时候判断是否小于0
		private final int limit;// 数组的大小

		public MyQueue(int limit) {
			arr = new int[limit];
			pushi = 0;
			polli = 0;
			size = 0;
			this.limit = limit;
		}

		//
		public void push(int value) {
			if (size == limit) {
				throw new RuntimeException("满了，不能再加了");
			}
			size++;
			arr[pushi] = value;
			pushi = nextIndex(pushi);
		}

		public int pop() {
			if (size == 0) {
				throw new RuntimeException("空了，不能再拿了");
			}
			size--;
			int ans = arr[polli];
			polli = nextIndex(polli);
			return ans;
		}

		public boolean isEmpty() {
			return size == 0;
		}

		private int nextIndex(int i) {
			return i < limit - 1 ? i + 1 : 0;
		}

	}

	public static class MyStack {
		private int[] arr; // 队列
		private int pushi;//
		private final int limit;// 数组的大小

		public MyStack(int limit) {
			arr = new int[limit];
			pushi = 0;
			this.limit = limit;
		}

		public void push(int value) {
			if (arr.length > limit) {
				throw new RuntimeException("栈满了，不能再加了");
			}
			arr[pushi] = value;
			pushi++;
		}

		public int pop() {
			if (arr.length <= 0) {
				throw new RuntimeException("栈空了，不能再取了");
			}
			int value = arr[pushi];
			pushi--;
			return value;
		}
		
		public boolean isEmpty() {
			return arr.length == 0;
		}
	}

三、常见面试题

1、实现一个特殊的栈，在基本功能的基础上，再实现返回栈中最小元素的功能

1）pop、push、getMin操作的时间复杂度都是 O(1)。

2）设计的栈类型可以使用现成的栈结构。

            public static class MyStack {
		private Stack<Integer> stackData;
		private Stack<Integer> stackMin;

		public MyStack() {
		    this.stackData = new Stack<Integer>();
		    this.stackMin = new Stack<Integer>();
		}
                //放的时候比较大小 小于等于新放入的时 放自己
		public void push(int newNum) {
		    if (this.stackMin.isEmpty()) {
	                this.stackMin.push(newNum);
		} else if (newNum <= this.getmin()) {
	                this.stackMin.push(newNum);
		}
                    this.stackData.push(newNum);
		}
                //和data 同步操作
		public int pop() {
		if (this.stackData.isEmpty()) {
		    throw new RuntimeException("Your stack is empty.");
		}
	        int value = this.stackData.pop();
	        if (value == this.getmin()) {
	            this.stackMin.pop();
	        }
	        return value;
		}
                //最小 取栈顶
		public int getmin() {
		if (this.stackMin.isEmpty()) {
	            throw new RuntimeException("Your stack is empty.");
	        }
	        return this.stackMin.peek();
	        }
	}

2、队列和栈相互转换

1）如何用栈结构实现队列结构

public static class TwoStacksQueue {
		public Stack<Integer> stackPush;
		public Stack<Integer> stackPop;

		public TwoStacksQueue() {
			stackPush = new Stack<Integer>();
			stackPop = new Stack<Integer>();
		}

		// push栈向pop栈倒入数据
		private void pushToPop() {
			if (stackPop.empty()) {
				while (!stackPush.empty()) {
					stackPop.push(stackPush.pop());
				}
			}
		}
		//放入
		public void add(int pushInt) {
			stackPush.push(pushInt);
			pushToPop();
		}
		//弹出
		public int poll() {
			if (stackPop.empty() && stackPush.empty()) {
				throw new RuntimeException("Queue is empty!");
			}
			pushToPop();
			return stackPop.pop();
		}
		//取值
		public int peek() {
			if (stackPop.empty() && stackPush.empty()) {
				throw new RuntimeException("Queue is empty!");
			}
			pushToPop();
			return stackPop.peek();
		}
	}

2）如何用队列结构实现栈结构

//此题思路就是两个队列相互换数据并留最后一个值 作为栈的第一个弹出
	public static class TwoQueueStack<T> {
		public Queue<T> queue;
		public Queue<T> help;

		public TwoQueueStack() {
			queue = new LinkedList<>();
			help = new LinkedList<>();
		}

		public void push(T value) {
			queue.offer(value);
		}

		public T poll() {
			while (queue.size() > 1) {
				help.offer(queue.poll());
			}
			T ans = queue.poll();
			Queue<T> tmp = queue;
			queue = help;
			help = tmp;
			return ans;
		}

		public T peek() {
			while (queue.size() > 1) {
				help.offer(queue.poll());
			}
			T ans = queue.peek();
			Queue<T> tmp = queue;
			queue = help;
			help = tmp;
			help.offer(ans);
			return ans;
		}

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

	}

语言提供的api是有限的，当有新的功能是api不提供的，就需要改写，所以手撸底层还是需要的。