java数据结构——栈和队列的简单实现

一、自己实现栈和队列

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

1、栈

public class Stack {
    private int[] arr;
    private int flag = 0;
    public Stack(int size){
        arr = new int[size];
    }
    public void add(int val){
        if(flag == arr.length){
            System.out.println("栈满");
            //扩容机制
            int[] brr = new int[arr.length*2];
            for(int i = 0;i < arr.length;i++){
                brr[i] = arr[i];
            }
            arr = brr;
        }
        arr[flag] = val;
        flag++;
    }
    public void get(){
        if(flag == 0){
            System.out.println("栈空");
            return;
        }
        flag--;
        System.out.println(arr[flag]);
    }
}

2、队列
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

public class Queue {
    private int[] arr;
    private int front;
    private int rear;
    public Queue(int size){
        arr = new int[size];
    }
    public void add(int val){
        if(front - rear == arr.length){
        //扩容机制
            int[] brr = new int[arr.length*2];
            for(int i = rear;i < front;i++){
                brr[i] = arr[i%arr.length];
            }
            arr = brr;
        }
        arr[front % arr.length] = val;
        front++;
    }
    public void get(){
        if(front == rear){
            System.out.println("队列空");
            return;
        }
        System.out.println(arr[rear % arr.length]);
        rear++;
    }
}

3、测试类

public class Test {
    public static void main(String[] args) {
        Stack stack = new Stack(10);
        stack.add(5);
        stack.add(6);
        stack.add(7);
        stack.get();
        stack.get();
        stack.get();
        stack.get();
        stack.get();
        stack.get();
        Queue queue = new Queue(10);
        queue.add(10);
        queue.add(10);
        queue.add(10);
        queue.add(10);
        queue.get();
        queue.get();
        queue.get();
        queue.get();
        queue.get();
        queue.get();
        queue.get();
        queue.get();
        queue.get();
    }
}

测试结果

二、使用java中的类测试栈和队列

1、首先是栈

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        //1、empty() 判空
        //2、peek()  查看栈顶元素，不弹栈
        //3、pop()   弹栈
        //4、push()  压栈
        //5、search()返回对象在栈中的位置
        Stack<Integer> stack = new Stack<>();
        System.out.println("判断栈是否为空："+stack.empty());
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        System.out.println("判断栈是否为空："+stack.empty());
        System.out.println(stack.peek());
        System.out.println(stack.peek());
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.search(1));
    }
}

输出结果：

2、接下来是队列

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static void main(String[] args) {
        //LinkedList    ---链表   ---实现了Queue接口
        Queue<String> queue = new LinkedList<>();
        //offer()、add()     
        //---向队列中添加数据，
        //add()在存储失败时抛出异常，
        //offer()在存储失败时会返回flase;
        //poll()、remove()   
        //---删除数据，
        //remove()在删除失败时抛出异常，
        //poll()在删除失败时返回null;
        //peek()、element()  
        //---查看队列的头部元素，
        //element()在查找失败时会抛出异常，
		//peek()在查找失败时会返回null;
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        //注意这里的for-each遍历只是顺序输出元素，和出队无关
        for(String str : queue){
            System.out.println(str);
        }
        System.out.println("--------------");
        queue.poll();
        for(String str : queue){
            System.out.println(str);
        }
        System.out.println("--------------");
        System.out.println(queue.peek());
        for(String str : queue){
            System.out.println(str);
        }
    }
}

查看结果：

三、栈和队列的经典例题

1、找到栈中最小值

import java.util.Stack;

public class MinStack {
    Stack<Integer> num = new Stack<>();
    Stack<Integer> min = new Stack<>();
    //入栈
    public void push(Integer data){
        //数据入栈
        num.push(data);
        //判断min栈中有没有值，如果没有就写入，有就比较栈顶大小
        if(min.empty() || data <= min.peek()){
            //当小于栈顶元素的时候入栈
            min.push(data);
        }
    }
    //出栈
    public int pop(){
        if(num.peek() == min.peek()){
            min.pop();
        }
        return num.pop();
    }
    //返回最小值
    public void min(){
        if(!min.empty()){
            System.out.println(min.peek());
        }
    }
}

2、判断出栈顺序是否正确

import java.util.Stack;

public class RightStack {
    public boolean right(int[] pushed,int[] poped){
        Stack<Integer> stack = new Stack<>();
        int i = 0;
        for(int num : pushed){
            stack.push(num);
            //栈不为空，且栈顶元素与弹栈序列相等，弹栈，并指向下一位
            while(!stack.isEmpty() && stack.peek() == poped[i]){
                stack.pop();
                i++;
            }
        }
        //根据弹栈序列弹栈后，若栈空则证明弹栈顺序正确
        return stack.isEmpty();
    }
}

3、两个栈实现一个队列

import java.util.Stack;

public class StackToQueue {
    Stack<Integer> stack1 = new Stack<>();
    Stack<Integer> stack2 = new Stack<>();

    //入栈
    public void push(Integer data){
        stack1.push(data);
    }
    //出栈
    public int pop(){
        Integer re = null;
        if(!stack2.empty()){
            re = stack2.pop();
        }else{
            while(!stack1.empty()){
                re = stack1.pop();
                stack2.push(re);
            }
            if(!stack2.empty()){
                re = stack2.pop();
            }
        }
        return re;
    }
}

4、两个队列实现一个栈

import java.util.LinkedList;
import java.util.Queue;

public class QueueToStack {
    Queue<Integer> queue1 = new LinkedList<>();
    Queue<Integer> queue2 = new LinkedList<>();
    //入栈
    public void push(Integer data){
        queue1.offer(data);
    }
    //弹栈
    public int pop(){
        Integer data = null;
        while(!queue1.isEmpty()){
            data = queue1.poll();
            //最后一个数据弹栈
            if(queue1.isEmpty()){
                break;
            }
            queue2.offer(data);
        }
        while(!queue2.isEmpty()){
            queue1.offer(queue2.poll());
        }
        return data;
    }
}