跟左神学算法3 基础数据结构(队列和栈)

内容：

1、数组实现队列和栈

2、返回栈中最小元素

3、对列与栈

4、猫狗队列问题

1、数组实现队列和栈

// 用数组实现基本的栈和队列 并在异常时抛出提示信息
public class Array_To_Stack_Queue {
    // 数组实现栈
    public static class ArrayStack {
        private Integer[] arr;
        private Integer index;
        
        public ArrayStack(int initSize){
            // 栈的构造    initSize指定栈大小
            if(initSize<0){
                throw new IllegalArgumentException("The init index is less than 0");
            }
            arr = new Integer[initSize];
            index = 0;
        }
        
        public Integer peek(){
            // 返回栈顶
            if(index==0){
                return null;
            }
            return arr[index-1];
        }
        
        public void push(int obj){
            // 压数入栈
            if(index==arr.length){
                throw new ArrayIndexOutOfBoundsException("The stack is full!");
            }
            arr[index++] = obj;
        }
        
        public Integer pop(){
            // 弹出栈顶
            if(index==0){
                throw new ArrayIndexOutOfBoundsException("The stack is empty!");
            }
            return arr[--index];
        }
        
    }
    
    // 数组实现队列
    public static class ArrayQueue{
        private Integer[] arr;
        private Integer size;
        private Integer start;
        private Integer end;
        
        public ArrayQueue(int initSize){
            if(initSize<0){
                throw new IllegalArgumentException("The init size is less than 0");
            }
            arr = new Integer[initSize];
            size = 0;
            start = 0;
            end = 0;
        }
        
        public Integer peek() {
            // 返回顶部元素
            if (size == 0) {
                return null;
            }
            return arr[start];
        }
        
        public void push(int obj) {
            // 向队列中加入元素
            if (size == arr.length) {
                throw new ArrayIndexOutOfBoundsException("The queue is full");
            }
            size++;
            arr[end] = obj;
            // end如果到最后一个位置就跳回到0 否则+1
            end = end == arr.length - 1 ? 0 : end + 1;
        }

        public Integer poll() {
            // 从队列出取出元素
            if (size == 0) {
                throw new ArrayIndexOutOfBoundsException("The queue is empty");
            }
            size--;
            int tmp = start;
            // start如果到最后一个位置就跳回到0 否则+1
            start = start == arr.length - 1 ? 0 : start + 1;
            return arr[tmp];
        }
        
    }
    
}

2、返回栈中最小元素

题目描述：

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

要求: pop push getMin 操作的时间复杂度都是O(1) 设计的栈类型可以使用现成的栈结构

思路：

使用两个栈，一个data栈用于存放数据，一个min栈用于存放当前压入栈中的数的最小值

每次压栈都把数据压入data栈，如果min栈为空或min栈栈顶大于当前数据就把当前数据压入min栈

代码：

public class GetMinStack {
    public static class MyStack1 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;
        
        public MyStack1() {
            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);
            } else {
                int newMin = this.stackMin.peek();
                this.stackMin.push(newMin);
            }
            this.stackData.push(newNum);
        }

        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            this.stackMin.pop();
            return this.stackData.pop();
        }

        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
    }
    
    public static void main(String[] args) {
        MyStack1 stack1 = new MyStack1();
        stack1.push(3);
        System.out.println(stack1.getmin());
        stack1.push(4);
        System.out.println(stack1.getmin());
        stack1.push(1);
        System.out.println(stack1.getmin());
        System.out.println(stack1.pop());
        System.out.println(stack1.getmin());
    }
    
}

3、对列与栈

Java内置队列和栈的使用：

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

// 使用Java中的内置栈结构和内置队列结构
public class useStackAndQueue {

    private static void useStack() {
        // 使用栈 -> 内容不可为基本数据类型
        // 内置栈方法如下:
        // push方法: 向栈中压入元素
        // peek方法: 返回栈顶元素
        // pop方法: 从栈顶取出栈顶元素并将其从栈中移除
        // isEmpty方法: 判断栈是否为空
        // search方法: 返回对象在栈中位置(-1表示不存在)
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(1);
        System.out.println(stack.isEmpty());
        System.out.println(stack.search(0) + " " + stack.search(1));
        System.out.println(stack.peek());
        System.out.println(stack.isEmpty());
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
    }

    private static void useQueue() {
        // 使用队列 -> 内容不可为基本数据类型
        // 内置队列方法如下:
        // offer方法: 向队列中插入新元素
        // poll方法: 弹出队列头元素
        // peek方法: 返回队列头元素
        // isEmpty方法: 判断队列是否为空
        // size方法: 计算队列大小
        Queue<Integer> queue = new LinkedList<Integer>();
        System.out.println("The first element is: " + queue.peek());
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        queue.poll();
        System.out.println("The first element is: " + queue.peek());
        System.out.println("The size is: " + queue.size());
    }

    public static void main(String[] args) {
        System.out.println("use stack: ");
        useStack();
        System.out.println("use queue: ");
        useQueue();
    }

}

用队列实现栈，用栈实现队列：

思路：两个队列来回倒就可以实现栈，两个栈来回倒也可以实现队列

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

// 用队列实现栈结构以及用栈结构实现队列结构
public class StackAndQueueConvert {
    public static class TwoStacksQueue{
        // 用栈实现队列
        private Stack<Integer> stackPush;       // 入队栈
        private Stack<Integer> stackPop;        // 出队栈
        
        public TwoStacksQueue(){
            stackPush = new Stack<Integer>();
            stackPop = new Stack<Integer>();
        }
        
        public void push(int pushInt){
            // 入队: 把数据压入入队栈(入队只把数据放进入队栈)
            stackPush.push(pushInt);
        }
        
        public void dao(){
            // 倒数据的方法 -> 入队栈倒到出队栈
            if(!stackPop.isEmpty()){
                // 出队栈不为空时不能倒数据
                return;
            } 
            while(!stackPush.isEmpty()){
                // 只要到数据就要依次倒完
                stackPop.push(stackPush.pop());
            }
        }
        
        public int pop(){
            // 出队: 取出出队栈栈顶元素(如果出队栈为空入队栈有数据就把入队栈数据压入出队栈)
            if(stackPop.empty() && stackPush.empty()){
                throw new RuntimeException("Queue is empty!");
            } 
            dao();
            
            return stackPop.pop();
        }
        
        public int peek(){
            // 获得顶部元素: 原理和上面的pop一样 只不过最后用的是栈的peek
            if(stackPop.empty() && stackPush.empty()){
                throw new RuntimeException("Queue is empty!");
            } 
            dao();
            
            return stackPop.peek();
        }
        
    }
    
    public static class TwoQueuesStack{
        // 用队列实现栈
        private Queue<Integer> data;
        private Queue<Integer> help;
        
        public TwoQueuesStack(){
            data = new LinkedList<Integer>();
            help = new LinkedList<Integer>();
        }
        
        public void push(int pushInt){
            // 入栈: 把数据放入data队列中(数只进data队列)
            data.add(pushInt);
        }
        
        public int pop(){
            // 出栈: 若data队列不为空把data队列中全部-1个数据出队放到help队列中 
            // 然后data队列中剩下的那个元素就是栈的顶部元素  poll弹出即可 然后交换data队列和help队列
            if(data.isEmpty()){
                throw new RuntimeException("Stack is empty!");
            }
            while(data.size() != 1){
                // 把data栈的东西全部拿出依次放入help栈
                help.add(data.poll());
            }
            int res = data.poll();
            swap();
            
            return res;
        }
        
        public int peek(){
            // 获得顶部元素: 若data队列不为空把data队列中全部-1个数据出队放到help队列中 
            // 然后data队列中剩下的那个元素就是栈的顶部元素  用peek取出即可 然后交换data队列和help队列
            if (data.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            while (data.size() != 1) {
                // 把data栈的东西全部拿出依次放入help栈
                help.add(data.poll());
            }
            int res = data.peek();
            swap();            
            
            return res;
        }
        
        private void swap(){
            Queue<Integer> tmp = help;
            help = data;
            data = tmp;
        }
        
    }
}

4、猫狗队列问题

问题描述：

代码结构:
    public class Pet{
        private String type;
        public Pet(String type){
            this.type = type;          
        }
        public String getPetType(){
            return this.type;
        }
    }
    public class Dog extends Pet {
        public Dog(){
            super("dog");
        }
    }
    public class Cat extends Pet{
        public Cat(){
            super("cat");
        }
    }
            
实现一种猫狗队列的结构，要求如下：             
    用户可以调用add方法将cat类或者dog类的实例放入队列中；
    用户可以调用pollAll方法，将队列中所有的实例按照队列的先后顺序依次弹出；
    用户可以调用pollDog方法，将队列中dog类的实例按照队列的先后顺序依次弹出；
    用户可以调用pollCat方法，将队列中cat类的实例按照队列的先后顺序依次弹出；
    用户可以调用isEmpty方法，检查队列中是否还有dog和cat的实例；
    用户可以调用isDogEmpty方法，检查队列中是否还有do的实例；
    用户可以调用isCatEmpty方法，检查队列中是否还有cat的实例。

代码：

import java.util.*;

public class DogCatQueue {
    public static class Pet {
        private String type;

        public Pet(String type) {
            this.type = type;
        }

        public String getPetType() {
            return this.type;
        }
    }

    public static class Dog extends Pet {
        public Dog() {
            super("dog");
        }
    }

    public static class Cat extends Pet {
        public Cat() {
            super("cat");
        }
    }

    public static class PetEnterQueue {
        // 队列中的猫或狗
        private Pet pet;
        private long count;

        public PetEnterQueue(Pet pet, long count) {
            this.pet = pet;
            this.count = count;
        }

        public Pet getPet() {
            return this.pet;
        }

        public long getCount() {
            return this.count;
        }

    }

    public static class dogCatQueue {
        private Queue<PetEnterQueue> dogQ;
        private Queue<PetEnterQueue> catQ;
        private long count;

        public dogCatQueue() {
            this.dogQ = new LinkedList<DogCatQueue.PetEnterQueue>();
            this.catQ = new LinkedList<DogCatQueue.PetEnterQueue>();
            this.count = 0;
        }

        public void add(Pet pet) {
            // 向队列中添加Cat和Dog的实例
            if (pet.getPetType().equals("dog")) {
                this.dogQ.add(new PetEnterQueue(pet, this.count++));
            } else if (pet.getPetType().equals("cat")) {
                this.catQ.add(new PetEnterQueue(pet, this.count++));
            } else {
                throw new RuntimeException("err, not dog or cat");
            }
        }

        public Pet pollAll() {
            // 猫狗队列中所有的实例按照队列的先后顺序依次弹出
            if (!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
                // count小的是先添加进队列的
                if (this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
                    return this.dogQ.poll().getPet();
                } else {
                    return this.catQ.poll().getPet();
                }
            } else if (!this.dogQ.isEmpty()) {
                return this.dogQ.poll().getPet();
            } else if (!this.catQ.isEmpty()) {
                return this.catQ.poll().getPet();
            } else {
                // 猫狗队列都为空
                throw new RuntimeException("err, queue is empty!");
            }
        }

        public Pet pollDog() {
            // 将队列中dog类的实例按照队列的先后顺序依次弹出
            if(this.isDogEmpty()){
                throw new RuntimeException("err, dog queue is empty");
            } else{
                return this.dogQ.poll().getPet();
            }
        }

        public Pet pollCat() {
            // 将队列中cat类的实例按照队列的先后顺序依次弹出
            if(this.isCatEmpty()){
                throw new RuntimeException("err, cat queue is empty");
            } else{
                return this.catQ.poll().getPet();
            }    
        }

        public boolean isEmpty() {
            // 检查队列中是否还有dog和cat的实例
            return this.dogQ.isEmpty() && this.catQ.isEmpty();
        }

        public boolean isDogEmpty() {
            // 检查队列中是否还有dog的实例
            return this.dogQ.isEmpty();
        }

        public boolean isCatEmpty() {
            // 检查队列中是否还有cat的实例
            return this.catQ.isEmpty();
        }

    }

    public static void main(String[] args) {
        dogCatQueue test = new dogCatQueue();

        Pet dog1 = new Dog();
        Pet cat1 = new Cat();
        Pet dog2 = new Dog();
        Pet cat2 = new Cat();
        Pet dog3 = new Dog();
        Pet cat3 = new Cat();

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);

        test.add(dog1);
        test.add(cat1);
        test.add(dog2);
        test.add(cat2);
        test.add(dog3);
        test.add(cat3);
        
        while (!test.isDogEmpty()) {
            // 弹出所有dog实例  并输出
            System.out.println(test.pollDog().getPetType());
        }
        
        while (!test.isEmpty()) {
            // 弹出所有cat实例  并输出
            System.out.println(test.pollAll().getPetType());
        }
        
        System.out.println(test.isEmpty());
    }

}