数据结构（二）--队列

数据结构（二）–队列

介绍

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

**特点：**先进先出

代码实现

数组方式实现

普通队列

front代表队列队头元素的前一个位置，rear为队尾元素当前位置

初始化：front=-1，rear=-1

当队列空：front==rear

对满了：rear ==maxsize-1

queue类

public class queue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;
    public queue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[maxSize];
        //初始化队列为空，所以为-1
        //front指向队列第一个元素的前一个位置
        front = -1;
        //rear指向队列最后一个元素位置
        rear = -1;
    }

    public boolean isFull(){
        return rear==maxSize-1;
    }
    public boolean isEmpty(){
        return front==rear;
    }

    public void addQueue(int n){
        if(isFull()) System.out.println("队列满了");
        else arr[++rear] = n;
    }
    public int outQueue(){
        if (isEmpty()) throw new RuntimeException("队列为空");
        else return arr[++front];
    }

    public void showQueue(){
        if (isEmpty()) {
            System.out.println("队列为空");
            return;
        }
        for(int i = front+1;i<=rear;i++){
            System.out.printf("arr[%d]=%d\t",i,arr[i]);
        }
        System.out.println();
    }

}

主函数

public static void main(String[] args) {
        queue q = new queue(6);
        q.addQueue(5);
        q.addQueue(8);
        q.addQueue(10);
        q.addQueue(7);
        q.showQueue();
        System.out.println("出队元素:"+q.outQueue());
        System.out.println("出队元素:"+q.outQueue());
        q.showQueue();
    }

结果

arr[0]=5	arr[1]=8	arr[2]=10	arr[3]=7	
出队元素:5
出队元素:8
arr[2]=10	arr[3]=7	

环形队列

front代表队列队头元素的前一个位置，rear为队尾元素当前位置，并且约定留一个空位区分队列空和队列满的情况。

初始化：front=0，rear=0

当队列空：front==rear

对满了：(rear+1)%maxSize==front

出队和入队时，front和rear变化：rear=(++rear)%maxSize，front=(++front)%maxSize

public class Cirqueue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] arr;
    public Cirqueue(int maxSize){
        this.maxSize = maxSize;
        arr = new int[maxSize];
        //初始化队列为空，所以为-1
        //front指向队列第一个元素的前一个位置
        front = 0;
        //rear指向队列最后一个元素位置
        rear = 0;
    }

    public boolean isFull(){
        return (rear+1)%maxSize==front;
    }
    public boolean isEmpty(){
        return front==rear;
    }

    public void addQueue(int n){
        if(isFull()) {
            System.out.println("队列满了");
            return;
        }
        rear = (++rear)%maxSize;
        arr[rear] = n;
    }
    public int outQueue(){
        if (isEmpty()) throw new RuntimeException("队列为空");
        front = (++front)%maxSize;
        return arr[front];

    }

    public void showQueue(){
        if (isEmpty()) {
            System.out.println("队列为空");
            return;
        }
        int i ;
        for(i = front+1;i!=rear;i=(i+1)%maxSize){
            System.out.printf("arr[%d]=%d\t",i,arr[i]);
        }
        System.out.printf("arr[%d]=%d\t",i,arr[i]);
        System.out.println();
    }
}

mian函数

public static void main(String[] args) {
        Cirqueue q = new Cirqueue(6);
        q.addQueue(5);
        q.addQueue(8);
        q.addQueue(10);
        q.addQueue(7);
        q.addQueue(8);
        q.showQueue();
        System.out.println("出队元素:"+q.outQueue());
        System.out.println("出队元素:"+q.outQueue());
        System.out.println("出队元素:"+q.outQueue());
        q.addQueue(4);
        q.addQueue(1);
        q.showQueue();
    }

结果

arr[1]=5	arr[2]=8	arr[3]=10	arr[4]=7	arr[5]=8	
出队元素:5
出队元素:8
出队元素:10
arr[4]=7	arr[5]=8	arr[0]=4	arr[1]=1	

链式实现

单向队列

先实现节点

根据需要可以将数据域data的类型改为泛型**< T >**

public class Node {
    private String data;
    private Node next;
    public Node(){}
    public Node(String data,Node next){
        this.data = data;
        this.next = next;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data='" + data + '\''+"}";
    }
}

单链表

头节点不存储数据，所有操作临时引用指向head；

删除/插入节点：先判断当前节点是否满足删除或插入条件，然后判断是否可以移动，最后移动（反复）

遍历节点：判断是否可以移动，移动，打印

打印某一节点：判断是否可以移动，移动，判断当前节点是否可以打印（反复）

public class Linelist {
    private Node head ;
    public Linelist(){
        head = new Node(null,null);
    }

    //打印所有节点
    public  void printNodes(){
        Node tepm = head;
        while (true){
            if (tepm.getNext()==null) break;
            tepm = tepm.getNext();
            System.out.println(tepm);
        }
    }

    //尾部添加数据
    public void addNode(String data){
        Node node = new Node(data,null);
        Node temp = head;
        while (true){
            if (temp.getNext()==null){
                temp.setNext(node);
                break;
            }
            temp = temp.getNext();
        }
    }

    //插入数据
    public void insertNode(int index,String data){
        //判断越界
        if (index<=0) throw new RuntimeException("越界");

        Node node = new Node(data,null);
        Node temp = head;
        int i=0;
        while (true){
            //添加节点
            if (i==index-1){
                node.setNext(temp.getNext());
                temp.setNext(node);
                break;
            }

            //判断越界
            if (temp.getNext()==null) throw new RuntimeException("越界！！！");

            //移动
            temp = temp.getNext();
            i++;
        }
    }

    //删除节点
    public Node deleteNode(int index) {
        //判断越界
        if (index <=0 )
            new RuntimeException("越界!!!");



        Node temp = head;
        int i = 0;
        while (true) {
            //删除节点
            if (i == index - 1 && temp.getNext() != null) {
                Node temp2 = temp.getNext();
                temp.setNext(temp2.getNext());
                temp2.setNext(null);
                return temp2;

            }

            //判断越界
            if (temp.getNext()==null)
                throw new RuntimeException("越界!!!");

            //移动
            temp = temp.getNext();
            i++;
        }


    }

    //打印某一节点
    public void printNode(int index){
        //判断越界
        if (index<=0) new RuntimeException("越界!!!");

        Node temp = head;
        int i=0;
        while (true){
            //判断越界
            if (temp.getNext()==null) {
                new RuntimeException("越界!!!");
            }

            //移动
            i++;
            temp = temp.getNext();

            //打印
            if (i==index){
                System.out.println(temp);
                break;
            }

        }
    }

   
}

单链队列

public class Linequeue {
    private Linelist linelist ;
    public Linequeue(){
        linelist =new Linelist();
    }

    public void addQueue(String data){
        linelist.addNode(data);
    }

    public String outQueue(){
         Node node =  linelist.deleteNode(1);
        return node.getData();
    }

    public void printQueue(){
        linelist.printNodes();
    }

    public static void main(String[] args) {
        Linequeue q = new Linequeue();
        q.addQueue("第一人");
        q.addQueue("第二人");
        q.addQueue("第三人");
        q.printQueue();
        System.out.println("--------------------");
        q.outQueue();
        q.addQueue("第四人");
        q.addQueue("第五人");
        q.printQueue();


    }
}

结果

Node{data='第一人'}
Node{data='第二人'}
Node{data='第三人'}
--------------------
Node{data='第二人'}
Node{data='第三人'}
Node{data='第四人'}
Node{data='第五人'}