七.排序算法

分类：毛选入耳块归队，计数，桶，基数

一.冒泡排序：BubbleSort

（1）普通版

　　i：1~n，j：0~n-i

    public void bubbleSort(int[] array) {
        for(int i=1;i<array.length;i++)
            for(int j=0;j<array.length-i;j++) 
                if(array[j]>array[j+1]) {
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
    }

（2）优化版

2.选择排序：SelectionSort

　　i：1~n；j：i~n　　开始时：minIndex=i-1

    public static void selectSort(int[] array) {        
        for(int i=1;i<array.length;i++) {
            int minIndex=i-1;
            for(int j=i;j<array.length;j++) {
                if(array[j]<array[minIndex]) {
                    minIndex=j;
                }        
            }
            if(minIndex!=i-1) {        //可有可无
                int temp=array[i-1];
                array[i-1]=array[minIndex];
                array[minIndex]=temp;
            }
        }
    }

3.插入排序：insertSort

（1）普通版

　　　　也是n-1轮循环。有几个小点需要注意

    public static void insertSort(int[] array) {
        for(int i=1;i<array.length;i++) {
            int insertVal=array[i];
            int prevIndex=i-1;
            while(prevIndex>=0 && array[prevIndex]>insertVal) {
                array[prevIndex+1]=array[prevIndex];
                prevIndex--;
            }
            array[prevIndex+1]=insertVal;    
        }
    }

4.希尔排序:shellSort

希尔排序是简单插入排序的改进版，又叫缩小增量排序，分组排序。

间隔序列:8个数：{4,2,1}

    //增量为几，就有几组
    public static void shellSort(int[] array) {
        int incre=array.length;
        while(incre>=1) {
            incre=incre/2;
            for(int gnum=0;gnum<incre;gnum++) {                            //控制第几组
                for(int i=gnum+incre;i<array.length;i=i+incre) {        //对一组元素排序
                    int insertValue=array[i];
                    int prevIndex=i-incre;
                    while(prevIndex>=0 && array[prevIndex]>insertValue) {
                        array[prevIndex+incre]=array[prevIndex];
                        prevIndex=prevIndex-incre;
                    }
                    array[prevIndex+incre]=insertValue;
                }
            }
        }
    }

5.快速排序：quickSort

步骤：先划分，再递归排序。划分操作是关键

    public static void quickSort(int[] arr,int startIndex,int endIndex) {
        if(startIndex>=endIndex)
            return;
        int pivotIndex=partition(arr, startIndex, endIndex);
        quickSort(arr, startIndex, pivotIndex-1);
        quickSort(arr, pivotIndex+1, endIndex);
    }
    
    //分区操作，返回基准元素最终的位置
    public static int partition(int[] arr,int startIndex,int endIndex) {
        int pivot=arr[startIndex];
        int left=startIndex;
        int right=endIndex;
        while(left != right) {
            while(left<right && arr[right]>=pivot)        //先从右边开始
                right--;
            while(left<right && arr[left]<=pivot)
                left++;
            if(left!=right) {
                int temp=arr[left];
                arr[left]=arr[right];
                arr[right]=temp;
            }
        }
        arr[startIndex]=arr[left];        //right先走，所以right先遇到left，left处的值<pivot
        arr[left]=pivot;
        
        return left;
    }

6.归并排序

    //利用了递归，比较经典
    public static void mergeSort(int[] array,int start,int end) {    //分割成两个有序数组，再把这两个有序数组合并
        if(start<end) {
            int mid=(start+end)/2;
            mergeSort(array, start, mid);
            mergeSort(array, mid+1, end);
            
            merge(array, start, mid, end);
        }
    }
    
    private static void merge(int[] array,int start,int mid,int end) {
        int[] tempArray=new int[end-start+1];
        int p1=start;
        int p2=mid+1;
        int p=0;
        while((p1<=mid) && (p2<=end)) {
            if(array[p1] <= array[p2]) 
                tempArray[p++]=array[p1++];            //先放，再自加
            else 
                tempArray[p++]=array[p2++];
        }
        
        while(p1<=mid)
            tempArray[p++]=array[p1++];
        while(p2<=end)
            tempArray[p++]=array[p2++];
        for(int i=0;i<tempArray.length;i++)
            array[i+start]=tempArray[i];            //i+sart
    }

7.堆排序：heapSort

步骤：构建堆。首尾元素交换，下沉。重复以上步骤

    public static void heapSort(int[] arr) {
        buildHeap(arr);

        for(int i=arr.length-1;i>0;i--) {
            int temp=arr[0];
            arr[0]=arr[i];
            arr[i]=temp;
            downAdjust(arr, 0,i);
        }    
    }
    
    //构建堆
    public static void buildHeap(int[] arr) {
        for(int i=(arr.length-2)/2;i>=0;i--)
            downAdjust(arr,i,arr.length);
    }
    
    public static void downAdjust(int[] arr,int parentIndex,int length) {
        int childIndex=2*parentIndex+1;
        int temp=arr[parentIndex];
        while(childIndex<length) {
            if(childIndex+1<length && arr[childIndex+1]>arr[childIndex])
                childIndex++;
            if(temp>=arr[childIndex])
                break;
            arr[parentIndex]=arr[childIndex];
            parentIndex=childIndex;
            childIndex=2*childIndex+1;
        }
        arr[parentIndex]=temp;
    }

8.计数排序

    public static void countSort(int[] array) {
        int max=array[0];
        for(int i=1;i<array.length;i++)
            if(array[i]>max)
                max=array[i];
        int[] countArray=new int[max+1];
        for(int i=0;i<array.length;i++) {
            countArray[array[i]]++;
        }
        int index=0;        //index很重要
        for(int i=0;i<countArray.length;i++) {
            for(int j=0;j<countArray[i];j++) {
                array[index++]=i;
            }        
        }
    }