七.排序算法

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

一.冒泡排序：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[] nums,int startIndex,int endIndex) {
         if(startIndex>=endIndex)     return;
         
         int pivotIndex=partition(nums, startIndex, endIndex);
         quicksort(nums, startIndex, pivotIndex-1);
         quicksort(nums, pivotIndex+1, endIndex);
    }
    
    //while，while while if
    static int partition(int[] nums,int startIndex,int endIndex) {
        int pivot=nums[startIndex];
        int left=startIndex;
        int right=endIndex;
        
        while(left<right) {
            while(left<right && nums[right]>=pivot)     right--;
            while(left<right && nums[left]<=pivot)         left++;
            if(left<right) {
                int temp=nums[left];
                nums[left]=nums[right];
                nums[right]=temp;
            }
        }
        
        nums[startIndex]=nums[left];
        nums[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;
            }        
        }
    }