常用排序算法--总结

排序的复杂度和稳定性分析

复杂度 冒泡、选择、插入排序 n的平方
稳定性 稳定 不稳定 稳定
复杂度 基数 shell 快速排序 归并排序
稳定性 （基数和归并稳定，其他都不稳定）

1冒泡排序

    //冒泡排序
    public static void sort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

1 思路
1）要经过arr.length-1轮排序，每轮找出最大或者最小的值
2）每轮经过比较的次数是arr.length-1-j次

2 选择排序

    //选择排序
    public static void sort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {//大循环，排序几轮
            int minIndex=i;
            int min=arr[i];
            //一轮中找到最小值
            for (int j = i+1; j < arr.length; j++) {
                if(arr[j]<min){//假定错误
                    //重新设置最小值和索引
                    min=arr[j];
                    minIndex=j;
                }
            }

            //交换
            if(minIndex!=i){
                arr[minIndex]=arr[i];
                arr[i]=min;
            }
        }
    }

1 思路
1）排序就是在指定的位置上放指定的值
2）索引0，应该放置最小的数；索引1，应该放次小的数
3）如何找到索引0指定的数，就遍历索引1-arr.length;，找出比索引0上位置更小的数字，进行交换
依次类推

3 插入排序

    public static void sort(int[] arr){
        for (int i = 1; i < arr.length ; i++) {
            int insertVal=arr[i];  //定义待插入的数和索引
            int insertIndex=i-1;

            //退出循环，找到插入的位置
            while(insertIndex>=0 && insertVal<=arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            //插入的位置是insertIndex+1

            if((insertIndex+1)!=i){  //加上判断，是否需要重新设置（花费时间）。
                arr[insertIndex+1]=insertVal;
            }
        }
    }

1 思路
1）将数组看成一个有序数组和无序数组
2）将无序数组的数组顺序插入到有序数组中
3）下标从1到arr.length-1 ，插入元素为arr[i] 插入索引为 insetIndex=i-1;
4)如可以插入当前的位置，就进行后移动 arr[insertIndex+1]=arr[insertIndex]
5)比较插入元素的当前位置是否是之前的位置 InserIndex+1 !=i,如不是，则进行交换 arr[inserIndex+1]=insertValue

4 希尔排序（缩小增量排序）

    public static void sort(int[] arr){
        //增量gap，并逐渐缩小增量
        for (int gap = arr.length/2; gap>0 ; gap/=2) {//分组
            int temp=0;
            //分成了几组
            for (int i = gap; i < arr.length ; i++) {
                for (int j = i-gap; j>=0 ; j-=gap) {
                    if(arr[j]>arr[j+gap]){
                        temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
        }
    }

1 思路
1）将数组分成多个组 arr.length/2 ,每次都是在上一次分组的基础上对半分
（一轮）（一组中的每个数进行比较）
2) 起始点从分组到arr.length
3) 每次点都和起始点+分组数对比，比大小

5快速排序（用到了递归）

public static void sort(int[] arr,int left,int right){
        int l=left;
        int r=right;
        int pivot=arr[(left+right)/2];
        int temp=0;

        //while 循环
        while(l<r) {
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            if (arr[l] == pivot) {
                l++;
            }
            if (arr[r] == pivot) {
                r--;
            }

        }

        if(r==l){
            r--;
            l++;
        }

        if(left<r){
            sort(arr,left,r);
        }
        if(right<l){
            sort(arr,l,right);
        }
    }

1 思路
1）找到左右指针和base值
2）（一轮之后）比基准值小的值放在base值的左边，比基准值大的值放在base右边
3）递归（左右）先右边后左边

6归并排序

 public static void sort(int[] arr,int left,int right,int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;  //要传输的中间的索引      //左递归分解
            sort(arr, left, mid, temp);
            //右递归分解
            sort(arr, mid + 1, right, temp);
            //每分解一次就合并一次
            //合并
            merge(arr, left, mid, right, temp);
        }
    }
    
  public static void merge ( int[] arr, int left, int mid, int right, int[] temp){
            //三个数组的起始索引
            int i = left;  
            int j = mid + 1; 
            int t = 0;  //指向temp数组的当前索引
            while (i <= mid && j <= right) {
                if (arr[i] <= arr[j]) {
                    temp[t] = arr[i];
                    t++;
                    i++;
                } else {//否则
                    temp[t] = arr[j];
                    t++;
                    j++;
                }
            }
                while (i <= mid) {
                    temp[t] = arr[i];
                    t++;
                    i++;
                }
                while (j <= right) {
                    temp[t] = arr[j];
                    t++;
                    j++;
                }
                t = 0;
                int templeft = left;  //临时的left,从左边开始拷贝
                //共有7次合并和拷贝
                //1. 0 1   2.  2 3  3. 0  3 最后一次合并0  7
                //System.out.println("合并的索引范围是：templeft="+templeft+" right="+right);
                while (templeft <= right) {
                    arr[templeft] = temp[t];
                    t++;
                    templeft++;
                }
        }

1 思路
分治思想
1）两个函数，分和和函数
2）和函数 （int[] arr,int left,int mid ,int right,int[] temp）
分函数（int[] arr,int left,int right,int[] temp）

7基数排序（桶排序）

   //桶子排序
    public static void sort(int[] arr){
        int max=arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max<arr[i]){
                max=arr[i];
            }
        }
        int length=(max+"").length();
        int[] count=new int[10];
        int[][] bucket=new int[10][arr.length];
        for (int i = 0,n=1; i < length; i++,n=n*10) {
            for (int j = 0; j < arr.length; j++) {
                int a=arr[j]/n%10;
                bucket[a][count[a]]=arr[j];
                count[a]++;
            }
            //将桶中的数移出来
            int index=0;
            for (int j = 0; j < 10; j++) {
                if(count[j]!=0){
                    for (int k = 0; k < count[j]; k++) {
                    	//一定要index++
                        arr[index++]=bucket[j][k];
                    }
                }
            }
        }
    }

1 思路
1）找到数组的最大数的长度，也就是遍历几轮
2）个位数依次放入桶中，十位，百位**
2）每轮依次取出即可