《数据结构》-Chapter3-2-队列算法

循环队列

class Quene{
    private int rear;
    private int front;
    private int size;
    private int[] data;
    public Quene(int n){
        size=n;
        rear=0;
        front=0;
    }
    public bool isEmpty(){
        if(rear==front) return true;
        return false;
    }
    public bool isFull(){
        if((rear+1)%size==front) return true;
        return false;
    }
    public bool enQuene(int n){
        if(isFull()) return false;
        data[rear]=n;
        rear=(rear+1)%size;
        return true;
    }
    public int deQuene(int n){
        if(isEmpty()) throw new Exception("Stack is Empty");
        int r=data[front];
        front=(front+1)%size;
        return r;
    }
}

***优先队列的两种实现

class BSTNode {
    private Integer data = null;
    private BSTNode lchild = null;
    private BSTNode rchild = null;
}

class PropertityQueue{
    private BSTNode node;
    
    public PropertityQueue(){
        this.node=Init();
    }
    
    public void enQueue(int a){
        BSTNode t=this.node;
        while(t!=NULL){
            if(a<t.data) t=t.lchild;
            else if(a>t.data) t=t.rchild;
        }
        t=new BSTNode();
        t.data=a;
    }
    
    public int deQueue(){
        BSTNode t=this.node;
        while(t.rchild!=NULL){
            t=t.rchild;
        }
        int result=t.data;
        if(t.lchild==NULL) t=NULL;
        else t=t.lchild;
        return result;
    }
    
    private void Init(){
        
    }
}

***优先队列堆的实现

public class PropertityQueue {
    private int[] array;
    private int size;
    public PropertityQueue() {
        array = new int[32];
    }

    private void enQueue(int key) {
        if (size >= array.length) {
            resize();
        }
        array[size++] = key;
        upAdjust();
    }

    private int deQueue() throws Exception {
        if (size <= 0) {
            throw new Exception("队列为空");
        }
        //获取堆顶的元素
        int head = array[0];
        //最后一个元素移动到堆顶
        array[0] = array[--size];
        downAdjust();
        return head;
    }

    private void downAdjust() {
        // TODO Auto-generated method stub
        int parentIndex = 0;
        int temp = array[parentIndex];
        int childIndex = 1;
        while (childIndex < size) {
            if (childIndex + 1 < size && array[childIndex + 1] > array[childIndex]) {
                childIndex++;
            }
            if (temp >= array[childIndex]) {
                break;
            }
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }
        array[parentIndex] = temp;
    }

    public void resize() {
        int newSize = this.size * 2;
        this.array = Arrays.copyOf(this.array, newSize);
    }

    private void upAdjust() {
        // TODO Auto-generated method stub
        int childIndex = size - 1;
        int parentIndex = childIndex / 2;
        int temp = array[childIndex];
        while (childIndex > 0 && temp > array[parentIndex]) {
            array[childIndex] = array[parentIndex];
            childIndex = parentIndex;
            parentIndex = parentIndex / 2;
        }
        array[childIndex] = temp;


    }
}