排序算法

排序分类

冒泡排序

class BubbleSort{
    public void sort(int[] array){
        int temp = 0;
        boolean flag = false;// 标识变量， 表示是否进行过交换
        for (int i = 1; i <= array.length -1; i++) {
            for (int j = 0; j < array.length - i; j++) {
                if (array[j] > array[j+1]){
                    flag = true;
                    temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
            if (!flag){
                break;
            }else{
                flag = false;
            }
        }
    }
}

快速排序

class QuickSort {
    public void sort(int[] array,int left,int right) {
        if (left > right) {
            return;
        }else{
            int l = left;
            int r = right;
            int mid = array[l];// 将左边的数作为基数
            while (r > l){
                // 右边的找到小于基数的数就停下
                while (array[r] >= mid && l < r) {
                    r --;
                }
                if (l < r) {// 将两个数进行交换
                    int temp = array[l];
                    array[l] = array[r];
                    array[r] = temp;
                    l++; // 交换完成后没有必要再比较当前值
                }
                // 左边找到大于基数的数就停下
                while (array[l] <= mid && l < r) {
                    l ++;
                }
                if (l < r) {// 将两个数进行交换
                    int temp = array[l];
                    array[l] = array[r];
                    array[r] = temp;
                    r++;
                }
            }
            if (left<l) {
                sort(array, l, left - 1);
            }
            if (r<right) {
                sort(array, right + 1, r);
            }
        }
    }
}

简单选择排序

class SelectSort{
    public void sort(int[] array){
        int min;
        int minIndex;
        for (int i = 1; i < array.length ; i++) {
            min = array[i-1];
            minIndex = i-1;
            for (int j = i; j < array.length; j++) {
                if (min > array[j]){ // 找到最小元素后将min和minIndex重置
                    min = array[j];
                    minIndex = j;
                }
            }
            if (minIndex != i-1){
                array1[minIndex] = array[i-1];
                array[i-1] = min;
            }
        }
    }
}

堆排序

class HeapSort {
    /**
     * 将数组调整为大顶堆
     *
     * @param array  待调整的数组
     * @param i      非叶子节点在数组中的索引
     * @param length 数组长度
     */
    private void adjustHeap(int[] array, int i, int length) {
        int temp = array[i]; // 将待调整的值保存
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && array[k] < array[k + 1]) { // 先找到左子节点
                k++; // 发现右子节点的值比左子节点的大，则k立马标记到右子节点
            }
            if (array[k] > temp) { // 如果子节点的最大值比父结点大
                array[i] = array[k]; // 将最大值给父结点
                i = k; // array[k] 作为新的父结点，继续向下遍历
            } else {
                break;
            }
        }
        array[i] = temp; // 将最初父结点的值放到调整后的位置
    }

    // 堆排序方法
    public void heapSort(int[] array) {
        int temp = 0;
        for (int i = array.length / 2 - 1; i >= 0; i--) { // 构成大顶堆
            adjustHeap(array, i, array.length);
        }
        for (int i = array.length - 1; i > 0; i--) { // 反复交换和重构大顶堆
            temp = array[i];
            array[i] = array[0];
            array[0] = temp;
            adjustHeap(array, 0, i);
        }
    }
}

直接插入排序

class InsertSort {
    public void sort(int[] array) {
        int insertVal;
        int insertIndex;
        for (int i = 1; i < array.length; i++) {
            insertVal = array[i];
            insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < array[insertIndex]) {
                array[insertIndex + 1] = array[insertIndex];
                insertIndex--;
            }
            array[insertIndex + 1] = insertVal;
        }

    }
}

shell排序

class ShellSort {
    public void sort(int[] array) {
        int temp = 0;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
            // 遍历各组中所有的元素(共 gap 组， 每组有个元素), 步长 gap
                for (int j = i - gap; j >= 0; j -= gap) {
                    // 如果当前元素大于加上步长后的那个元素， 说明交换
                    if (array[j] > array[j + gap]) {
                        temp = array[j];
                        array[j] = array[j + gap];
                        array[j + gap] = temp;
                    }
                }
            }
        }
    }
}

归并排序

class MergeSort {
    public void sort(int[] array) {
        sort(array,0,array.length-1);
    }
    public void sort(int[] array,int left,int right) {
        int mid = (left +right )/2;
        if (left < right) {
            sort(array, left, mid);
            sort(array, mid + 1, right);
            merge(array, left, mid, right);
        }
    }
    public void merge(int[] a, int left, int mid, int right) {
        int[] temp = new int[right-left+1];
        int i= left;
        int j = mid+1;
        int k=0;
        // 把较小的数先移到新数组中
        while(i<=mid && j<=right){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else{
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while(i<=mid){
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while(j<=right){
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for(int x=0;x<temp.length;x++){
            a[x+left] = temp[x];
        }
    }
}

基数（桶）排序

class RadixSort {

    public void sort(int[] array) {
        // 得到最大数
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 计算最大数的位数
        int bits = (max + "").length();
        int[][] bucket = new int[10][array.length];// 建立二维数组，表示十个桶
        int[] num = new int[10]; // 记录每个桶中元素的个数

        for (int i = 0, n = 1; i < bits; i++, n *= 10) {
            for (int j = 0; j < array.length; j++) {
                // 得到一个元素应该存放的桶的序号
                int buckeetOrder = array[j] / n % 10;
                // 存放到对应的桶中
                bucket[buckeetOrder][num[buckeetOrder]] = array[j]; // 将编号为order，位置为num[order]的位置写入元素
                num[buckeetOrder]++; // 写入后，编号为order的桶中元素加一，进行记录
            }
            // 遍历每一个桶，将桶中元素再写入到原数组中
            int index = 0;
            for (int k = 0; k < num.length; k++) {
                if (num[k] != 0) {
                    for (int j = 0; j < num[k]; j++) {
                        array[index++] = bucket[k][j];
                    }
                }
                num[k] = 0;// 将第i号桶中元素的数量归零
            }
        }
    }
}

排序算法的时间复杂度