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

队列

队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(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);
    }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值