经典排序算法Java实现和思路分析

 1.选择排序

public static void selectionSort(int[] arrays){
        if(arrays == null || arrays.length < 2){
            return;
        }
        //arr.length个数，前面arr.length-1数排好序后，整个数组就排好序了
        for (int i = 0; i < arrays.length-1; i++) {
            //i位置作为交换位置，假设i位置为全局最小值
            int min = i;
            //从i+1~最后一个值中选择最小值
            for (int j = i+1; j < arrays.length; j++) {
                min = arrays[j] < arrays[min] ? j : min;
            }
            //将i+1 ~ 最后一个值中的最小值和i位置交换,i位置排好序
            swap(arrays,min,i);
        }
    }

2.插入排序

public static void insertSort(int[] arrays){
        if (arrays == null || arrays.length < 2){
            return;
        }
        //插排是一个逐渐有序的过程，0位置一个数肯定有序
        //1到arr.length-1逐渐有序
        for (int i=1;i<arrays.length; i++){
            //来到i位置，i-1个数是已经有序的,在i-1个有序的数中加入位置i的数使i个数有序
            //往前看，但不能越界，同时如果前面的数比我大，则交换
            for (int j=i-1;j>=0 && arrays[j] > arrays[j+1];j--){
                swap(arrays,j,j+1);
            }
        }
    }

3.冒泡排序

public static void bubbleSort_review(int[] arrays){
        if (arrays == null || arrays.length < 2){
            return;
        }
        //每冒泡一轮，一个数排好位置，那么总共需要冒泡arr.length-1轮
        for (int i=0;i<arrays.length-1; i++){
            //从后往前冒，和自己前一个比较，最后比较到i位置，i位置排好序
            for (int j=arrays.length - 1; j > i; j--){
                if (arrays[j-1] > arrays[j]){
                    swap(arrays,j,j-1);
                }
            }
        }
    }

public static void bubbleSort_review(int[] arrays){
        if (arrays == null || arrays.length < 2){
            return;
        }
        //1~arr.length-1位置排好序，则整个数组排好序
        for (int i = arrays.length - 1; i > 0; i--){
            //0位置和后一个数比，依次比较到i位置，当前数比后一个数大则交换
            for (int j = 0;j<i;j++){
                if (arrays[j] > arrays[j+1]){
                    swap(arrays,j,j+1);
                }
            }
        }
    }

4.归并排序

 待排序数组[8,22,3,4,11,7],调用process函数进行递归，递归到底后往上merge

public static void mergeSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        process(arr,0,arr.length-1);
    }
    public static void process(int[] arr,int L,int R){
        if (L == R){
            return;
        }
        int mid = L + ((R - L)>>1);
        //左边排好序
        process(arr,L,mid);
        //右边排好序
        process(arr,mid+1,R);
        //归并，左右整体有序
        merger(arr,L,mid,R);
    }
    public static void merger(int[] arr,int L,int M,int R){
        //辅助数组，用来装整体排序数组
        int[] help = new int[R - L + 1];
        //辅助数组开始下标
        int i=0;
        //左部分开始下标
        int p1=L;
        //右部分开始下标
        int p2=M+1;
        //左右部分都未越界
        while (p1 <= M && p2 <= R){
            //较小者进入辅助数组，该处保证了算法的稳定性
            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }
        //右边结束后左部有剩余，则左部剩余依次进入辅助数组
        while (p1 <= M){
            help[i++] = arr[p1++];
        }
        //左部结束右部有剩余，则右部依次进入辅助数组
        while(p2 <= R){
            help[i++] = arr[p2++];
        }
        //将辅助数组排序结果拷贝回原部分数组
        for ( i=0; i<help.length;i++){
            arr[L+i] = help[i];
        }
    }

5.快排

public static void quickSort(int[] arr,int l,int r){
        if (arr == null || arr.length == 0){
            return;
        }
        if (l < r){
            //每次以r位置的数作为pivot,将l到r部分分为小于pivot区，等于pivot区和大于pivot区
            //为了防止pivot打太偏，所以随机选择一个位置的值和r位置的值做交换
            //这样每次pivot都是随机的
            swap(arr,l+(int)(Math.random()*(r-l+1)),r);
            //返回值是一个数组，res[0]表示等于区的左边界，res[1]表示等于区的右边界
            int[] res = partition_r(arr, l, r);
            //小于区进行重复操作
            quickSort_r(arr,l,res[0]-1);
            //大于区进行重复操作
            quickSort_r(arr,res[1]+1,r);
        }
    }
    public static int[] partition_r(int[] arr,int l,int r){
        //小于区的右边界，初始位于值的左边一个位置
        int less = l-1;
        //大于区的左边界，初始位于pivot位置
        int more = r;
        //l表示当前元素位置，当前元素未和大于区的左边界相遇
        while(l < more){
            //当前元素的值小于pivot，小于区的右边界的下一个值和当前元素互换
            //小于区右扩，当前元素位置++
            if (arr[l] < arr[r]){
                swap(arr,++less,l++);
                //当前元素的值大于pivot，大于区左边界左边的值和当前元素交换
                //大于区左扩，当前元素位置不动
                //因为交换到大于区的值是确定大于pivot的，交换过来的值是不确定的还需要继续比较
                //所以当前位置不变
            }else if (arr[l]> arr[r]) {
                swap(arr,--more,l);
                //当前元素等于pivot，当前元素位置++
            }else{
                l++;
            }
            //整个流程就是小于pivot的交换到小于区，小于区推着等于区和大于区往右
        }
        //最后交换pivot和大于区最左元素
        swap(arr,more,r);
        //less一开始是值的左边，最后less位置刚好是小于区最右边那个值的位置
        //less+1是等于区的左边界
        //more最后和pivot交换了，more位置刚好是等于区的右边界
        return new int[] {less+1, more};
    }

6.堆排序

堆关键的两个操作：heapInser()和heapify()

其中heapInsert()是放进来一个值，若比父大，与父交换，不断的往上换，直到自己为父，或者父不再大于自己。

private static void heapInsert(int[] arr,int index){
        //index位置比父大
        while (arr[index] > arr[(index-1)/2]){
            //和父交换值
            swap(arr,index,(index - 1)/2);
            //index来到父的下标，继续往上比
            index = (index-1)/2;
        }
    }

heapify()是某个在index位置的数，能否往下移动，比较index，左右孩子(如果有的话)中的最大值,大的上去，index往下。

private static void heapify_r(int[] arr,int index,int heapSize){
        //index位置左孩子下标
        int left = index * 2 +1;
        //heapSize是数组中元素个数,存在左孩子
        while (left < heapSize){
            //有右孩子同时右孩子比左孩子值大
            int largest = (left + 1) < heapSize && arr[left+1] > arr[left] ?
                    left+1:left;
            //左右中最大值和index比
            largest = arr[largest] > arr[index] ? largest:index;
            //最大值是index自己，没变换
            if (largest == index){
                break;
            }
            //最大值不是index自己，则交换index和最大值
            swap(arr,index,largest);
            //index来到最大值的位置，继续往下比
            index = largest;
            //新位置的左孩子
            left = index * 2 +1;
        }
    }

堆排序首先将数组变成大根堆，堆顶即全局最大值，将堆顶和堆最末元素换位置，最大值排好序，heapSize--，即待排序元素--，交换上来的元素进行堆化操作，使整体结构重新变成大根堆，堆顶即全局第二大元素，重复上述过程，直到heapSize = 1，待排序元素剩下一个，其他元素都是有序的，此时整体数组有序。

public static void heapSort_r(int[] arr){
        if (arr == null || arr.length < 2) {
            return;
        }
        //排序需要确定的位置，arr.length个数，其中arr.length-1位置确定了，剩下一个自然确定
        int heapSize = arr.length;
        //数组中的元素，从右往左，从下往上依次堆化，整体变成大根堆
        for (int i=arr.length-1;i>=0;i--){
            heapify_r(arr,i,heapSize);
        }
        //堆顶和数组最后一个位置的元素交换位置,最大值固定,heapSize--,需要排序的位置少一个
        swap(arr,0,--heapSize);
        //还有1个以上位置没有确定，其他位置都排好序，整个数组排好序
        while (heapSize > 1){
            //使整体结构重新变成大根堆
            heapify_r(arr,0,heapSize);
            //堆顶元素排序位置固定，待排序元素--
            swap(arr,0,--heapSize);
        }

    }