Java数据结构之栈和队列

1 栈(Stack)

---

1.1 概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈
顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。

1.2 栈的使用

方法	功能
Stack()	构造一个空的栈
E push(E e)	将e入栈，并返回e
E pop()	将栈顶元素出栈并返回
E peek()	获取栈顶元素
int size()	获取栈中有效元素个数
boolean empty()	检测栈是否为空

public static void main(String[] args) {
	Stack<Integer> s = new Stack();
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);
	System.out.println(s.size()); // 获取栈中有效元素个数---> 4
	System.out.println(s.peek()); // 获取栈顶元素---> 4
	s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
	System.out.println(s.pop()); // 3出栈，栈中剩余1 2 栈顶元素为3
	if(s.empty()){
		System.out.println("栈空");
	}else{
		System.out.println(s.size());
	}
}

1.3 栈的应用场景

1. 改变元素的序列
2. 将递归转化为循环
   逆序打印链表

// 递归方式
void printList(Node head){
	if(null != head){
		printList(head.next);
		System.out.print(head.val + " ");
	}
} 

// 循环方式
void printList(Node head){
	if(null == head){
		return;
	} 
	Stack<Node> s = new Stack<>();
	// 将链表中的结点保存在栈中
	Node cur = head;
	while(null != cur){
		s.push(cur);
		cur = cur.next;
	} 
	// 将栈中的元素出栈
	while(!s.empty()){
		System.out.print(s.pop().val + " ");
	}
}

1.4 栈的模拟实现

从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。

public class MyStack {
    public int[] elem;
    //不仅可以记录 你当前的元素的个数
    // 还可以当做当前可以存放元素的下标
    public int usedSize;

    public MyStack() {
        this.elem = new int[10];
    }

    /**
     * 入栈操作
     * @param val
     */
    public void push(int val) {
        if(isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[usedSize] = val;
        usedSize++;
    }
    /**
     * 判断是不是满了
     * @return
     */
    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }

    /**
     * 出栈 删除
     * @return
     */
    public int pop() {
        if(empty()) {
            throw new RuntimeException("栈为空！");
        }
       /* int val = this.elem[usedSize-1];
        this.usedSize--;
        return val;*/
        this.usedSize--;
        return this.elem[usedSize];
    }

    /**
     * 获取栈顶元素 不删除
     * @return
     */
    public int peek() {
        if(empty()) {
            throw new RuntimeException("栈为空！");
        }
        return this.elem[usedSize-1];
    }

    /**
     * 判断是不是空的
     * @return
     */
    public boolean empty() {
        return this.usedSize == 0;
    }

    /**
     * 返回栈的大小
     * @return
     */
    public int size() {
        return this.usedSize;
    }
}

1.5 栈、虚拟机栈、栈帧的区别

栈：后进先出的一种数据结构——在java的集合中有对应的实现—Stack，Stack在实现时继承了Vector。
虚拟机栈： jvm为了对数据进行更好的管理，将内存按照不同的需求划分出来的一种结构。栈区：线程私有的，栈区中存放的是函数调用相关的一些信息，主要是栈帧。 当栈区中内存空间不足时，会抛出StackOverflowException。当中的元素（栈帧）是按照数据结构中的栈的特性来实现的
栈帧：一种结构，这种结构与函数调用相关的，内部：局部变量表、操作数栈等。每个方法在运行时，jvm都会创建一个栈帧，然后将栈帧压入到虚拟机栈中，当方法调用结束时，该方法对应的栈帧会从虚拟机栈中出栈

2 队列(Queue)

---

2.1 概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First
In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头（Head/Front）

2.2 队列的使用

在Java中，Queue是个接口，底层是通过链表实现的。

方法	功能
boolean offer(E e)	入队列
E poll()	出队列
peek()	获取队头元素
int size()	获取队列中有效元素个数
boolean isEmpty()	检测队列是否为空

注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

public static void main(String[] args) {
	Queue<Integer> q = new LinkedList<>();
	q.offer(1);
	q.offer(2);
	q.offer(3);
	q.offer(4);
	q.offer(5); // 从队尾入队列
	System.out.println(q.size());
	System.out.println(q.peek()); // 获取队头元素
	q.poll();
	System.out.println(q.poll()); // 从队头出队列，并将删除的元素返回
	if(q.isEmpty()){
		System.out.println("队列空");
	}else{
		System.out.println(q.size());
	}
}

2.3 队列模拟实现

class Node {
    public int val;
    public Node next;

    /**
     * 构造方法
     * @param val
     */
    public Node(int val){
        this.val = val;
    }
}
public class MyQueue {

    public Node front;//队头
    public Node rear;//队尾

    /**
     * 入队-》尾插法
     * @param val
     */
    public void offer(int val) {
        Node node = new Node(val);
        if(this.front == null) {
            this.front = node;
            this.rear = node;
        }else {
            this.rear.next = node;
            this.rear = node;
        }
    }

    /**
     * 返回队头元素
     * @return
     */
    public int peek() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        return this.front.val;
    }

    /**
     * 出队
     * @return
     */
    public int poll() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        int old = this.front.val;
        this.front = this.front.next;
        return old;
    }

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty() {
        return this.front == null;
    }

}

3 双端队列

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
Deque是一个接口，使用时必须创建LinkedList的对象。