队列，栈，以及排序算法代码实现

队列

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

---

代码实现：

public class Queue{
    private Object[] objects;
    private int size;
    private int head;
    private int end;

    public Queue(int size){
        this.objects = new Object[size];
        this.head = 0;
        this.end = 0;
        this.size = 0;
    }
    //插入操作
    public void push(Object object) throw Exception{
        if(this.size >objects.length)
            throw new Exception("Queue is Full");
        objects[end++] = object;
        size++;
    }
    //删除操作
    public Object pop() throws Exception{
        if(this.size == 0)
            throw new Exception("Queue is empty!")  
        if(head == Objects.length)
            this.head = 0;
        size--;
        return objects[head++];
    }
    //查看对头
    public Object peek() throws Exception{
        if(this.size == 0)
            throw new Exception("Queue is empty");
        return objects[head];
    }

    public boolean isEmpty(){
        return size == 0;
    }
    public boolean isFull(){
        return size == objects.length;
    }
    public int getSize() {
        return size;
    }
}

---

栈

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

代码实现：

public class Stack(){
    private Object[] objects;
    private int head;
    private int size;
    public Stack(int size){
        objects = new Object[size];
        this.head = 0;
        this.size = 0;
    }
    //入栈操作
    public void push(Object object) throw Exception{
        if(this.size == objects.length)
            throw new Exception("this stack is full");
        objects[head++] = object;
        size++;
    }
    //出栈操作
    public Object pop() throws Exception{
        if(size == 0)
            throw new Exception("this stack is empty");
        size--;
        return objects[--head];
    }
}

---

冒泡排序

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。

• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

  代码实现：

public class BubbleSort {

    public static void main(String[] args) {
        //举个栗子
        int[] a ={1,4,7,8,2,6};
        //从第一个循环到倒数第二个数，都进行内循环的操作
        for (int i=0;i<a.length-1;i++) {
            //从第一个循环到倒数第二个依次跟后一位比较，每次循环都将最小的元素放到最后面，由于最后的是最小的，所以下次循环不予考虑，故依次循环减少
            for(int j=0;j<a.length-i-1;j++){
                if(a[j]<a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }

        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+" ");
        }
    }
}

快速排序

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码实现：

public class QuickSort {
    public static int middle(int[] array, int left, int right) {
        int temp = array[left];
        while (left != right) {
            while (right > left && array[right] > temp)
                right--;
            array[left] = array[right];
            while (right > left && array[left] < temp)
                left++;
            array[right] = array[left];
        }
        array[right] = temp;
        return right;
    }

    public static int[] sort(int[] a, int left, int right) {
        if (left < right) {
            int i = middle(a, left, right);
            sort(a, left, i);
            sort(a, i + 1, right);
        }
        return a;
    }
    //测试
    public static void main(String[] args) {
        int[] a = {11, 81, 27, 53, 42, 45, 6, 77, 178, 9, 70};
        sort(a, 0, a.length - 1);
        for (int i : a) {
            System.out.print(i+" ");
        }
    }
}

斐波那契数列

非递归方法：

public class Feibonaqie {

    public static int feibo(int n){
        int p=1,q=1;
        if(n==1||n==2)
            return 1;
        for(int i=3;i<=n;i++){
            int tmp =p;
            p=q;
            q=tmp+q;
        }
        return q;
    }
}

递归方法：

public static int f(int n){
        if(n <= 0)
            return 0;
        if(n ==1||n== 2)
            return 1;

        return f(n-1)+f(n-2);
    }