快速排序、归并排序、希尔排序（Java）

快排

class QuikSort {
    public void sort(int[] array){
        int len = array.length;
        if (len < 1)
            return;
        quikSort(array,0,len - 1);
    }

    private void quikSort(int[] array, int left, int right) {
        if (left > right)
            return;
        int i = left;
        int j =right;
        //array[left]为基准
        int pivot = array[left];
        while (i < j){
        	//从后面找比pivot小的，一定要从后面开始找
            while (i < j && array[j] >= pivot){
            	//后面的数大于 pivot 则 j--，说明不是要找的数
                j--;
            }
            //从前面开始找，找到比pivot 大的数
            while (i < j && array[i] <= pivot){
                i++;
            }
            //到了这里说明遍历完了
            if (i < j ){
            	//如果 i 仍然 小与 j，则说明找到了这两个数，交换位置即可
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
		//因为pivot 要 是比前面的数大，比后面的数小，因此把 pivot 放到 i 的位置
        array[left] = array[i];
        array[i] = pivot;
        //继续递归 ,i 的位置就是 前面的数比它小 后面的数比它大
        //0 ~ i ~ right , i就不用动了
        quikcSort(array, 0, i - 1);
        quikcSort(array, i + 1, right);
    }
}

归并

public class mergeSort {
	//用来复制数组
    public int[] copyOfRange(int[] array, int left, int right){
        int len = right - left;
        int[] newArray = new int[len];
        int j = 0;
        for (int i = left; i < right; i++){
            newArray[j] = array[i];
            j++;
        }
        return newArray;
    }
    //用来排序
    public int[] mergeSort(int[] array){
        int len = array.length;
        if (len < 2)
            return array;
        int midIndex = len / 2;
        //把array分成两份
        int[] left = copyOfRange(array, 0, midIndex);
        int[] right = copyOfRange(array, midIndex, len);
        //合并这两份
        return merge(mergeSort(left),mergeSort(right));
    }
    //用来归并两个数组
    public int[] merge(int[] a1, int[] a2){
    	//新生成的数组a3
        int[] a3 = new int[a1.length + a2.length];
        //a1的下标
        int i = 0;
        //a2的下标
        int j = 0;
        //用来表示a3的下标
        int index = 0;
        //while用于把a1 和 a2 的数有比较的放到 a3上
        while (i < a1.length && j < a2.length){
        	//a1 和 a2 数组中的数小的先放到a3
            if (a1[i] > a2[j]){
                a3[index] = a2[j];
                index++;
                j++;
            } else {
                a3[index] = a1[i];
                index++;
                i++;
            }
        }
        //两个while用于判断是否还有剩余的数
        while (i < a1.length){
        	//如果a1长度大于a2，则会进入这个循环，把a1后面的元素全部复制到a3上即可
            a3[index] = a1[i];
            index++;
            i++;
        }
        while (j < a2.length){
            a3[index] = a2[j];
            index++;
            j++;
        }
        return a3;
    }
}

希尔排序

public class ShellSort {
    public static int[] shellSort(int[] array){
        int len = array.length;
        if (len < 2){
            return array;
        }
        //表示间隔大小
        int gap = len / 2;
        //例如len = 10，gap = 5、gap = 2、gap = 1、gap = 0(结束)
        //当gap = 1时就是插入排序
        while (gap >0){
            for (int i = gap; i < len; i++){
                //固定i，然后 j 往回走
                for (int j = i; j >= 0; j -= gap){
                    int preIndex = j - gap;
                    //交换
                    if (preIndex >= 0 && array[preIndex] > array[j]) {
                        int temp = array[preIndex];
                        array[preIndex] = array[j];
                        array[j] = temp;
                    }
                }
            }
            //减小间隙
            gap /= 2;
        }
        return array;
    }
}