【数据结构与算法】排序算法

排序算法

冒泡排序

每次找到最大或最小的数,查到最后面;

/**
     * 冒泡排序
     * @param a 要排序的数组
     * @return 排序完成的数组
     */
    int[] bubbleSort(int [] a){
        for(int i = 0;i<a.length-1;i++){
            for(int j =0;j<a.length-1-i;j++){
                if (a[j]>a[j+1]){
                    int choose = a[j];
                    a[j] = a[j+1];
                    a[j+1] = choose;
                }
            }
        }
        return a;
    }

插入排序

1.每次都默认前n个数已经排序,
2.每次遍历的数向前面排序过的数列中插入,从后向前遍历,找到比他小的数,插入到他后面;
3.遍历所有数

/**
     * 插入排序
     * @param a 要排序的数组
     * @return 排序完成的数组
     */
    int[] insertionSort(int [] a){
        int choose;
        for(int i =0;i<a.length-1;i++){
            choose = a[i+1];
            int compareNum = i;
            while (compareNum>=0 && choose < a[compareNum]){
                a[compareNum+1]=a[compareNum];
                compareNum--;
            }
            a[i+1] = choose;
        }
        return a;
    }

选择排序

每次选择最小的数,插入到数列的前面,

    /**
     * 选择排序
     * @param a 要排序的数组
     * @return 排序完成的数组
     */
    int[] selectionSort(int [] a){
        for(int i = 0;i<a.length;i++){
            int minindex = i;
            for(int j = i;j<a.length;j++){
                if (a[j]<a[minindex]){
                    minindex = j;
                }
            }
            int temp = a[i];
            a[i] = a[minindex];
            a[minindex]=temp;
        }
        return a;
    }

归并排序

1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列。

归并排序核心思想就是分治法: 递归展开把全部的数组元素分解成最小单位,然后再按照从小到大的归并组合

/**
     * 归并排序
     * @param a 要排序的数组
     * @return 排序好的数组
     */
    int[] MergeSort(int[] a){
        if(a.length<2)return a;
        int mid = a.length/2;
        int[] left = Arrays.copyOfRange(a,0,mid);
        int[] right = Arrays.copyOfRange(a,mid,a.length);
        return merge(left,right);
    }

    /**
     * 归并排序所用的递归算法
     * @param left 左数组
     * @param right 右数组
     * @return 排好序的暂时的数组
     */
    static int[] merge(int[] left,int[] right){
        int[] res = new int[left.length+right.length];
        for(int index=0,i=0,j=0;index<res.length;index++){
            if(left.length<=i){
                res[index] = right[j++];
            }else if(right.length<=j){
                res[index] = left[i++];
            }else if(left[i]<right[j]){
                res[index] = left[i++];
            }else{
                res[index] = right[j++];
            }
        }
        return res;
    }

快速排序

1.选取一个标记值(一般为第一个数)
2.遍历剩余数组
3.把小于标记值的放在标记值左边,大于的放在右边
4.递归分别对标记值左右两边的两个数组进行1~3操作

/**
     * 快速排序
     * @param a 要排序的数组
     * @return 排序好的数组
     */
    int[] QuickSort(int[] a){
        quick(a,0,a.length-1);
        return a;
    }

    /**
     * 递归快速排序
     * @param a 排序的数组
     * @param l 左端点
     * @param r 右端点
     */
    static void quick(int[] a,int l,int r){
        int i = l;
        int j = r;
        if (i>j){
            return ;
        }
        int zhou = a[i];
        while(i<j){
            while(i<j && a[j]>=zhou){
                j--;
            }
            a[i] = a[j];
            while(i<j && a[i]<=zhou){
                i++;
            }
            a[j] = a[i];
        }
        a[i] = zhou;
        quick(a,l,i-1);
        quick(a,i+1,r);
    }