【备战春招】NC140 排序

描述

给定一个长度为 n 的数组，请你编写一个函数，返回该数组按升序排序后
的结果。

要求：时间复杂度 O(nlogn)，空间复杂度 O(n)

示例1 :

输入：
[5,2,3,1,4]
返回值：
[1,2,3,4,5]

示例2 :

输入：
[5,1,6,2,5]
返回值：
[1,2,5,5,6]

---

解题

1.用库函数（不建议使用）

private static void doSolution0(int[] arr){
    Arrays.sort(arr);
}

2.如果不看题目要求的时间复杂度的话，可以使用冒泡，插入，选择排序

• 记住方向，方便秒杀

//冒泡排序
private static void doSolution1(int[] arr) {
    int tmp = 0;
    //方向先⬅ 后➡
    for (int i = arr.length - 1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}
// 选择排序
private static void doSolution2(int[] arr) {
    int tmp = 0, index = 0;
    //方向先➡ 后➡
    for (int i = 0; i < arr.length; i++) {
        index = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        tmp = arr[i];
        arr[i] = arr[index];
        arr[index] = tmp;
    }
}
// 插入排序
private static void doSolution3(int[] arr) {
    int tmp = 0;
    //方向先➡ 后⬅
    for (int i = 1; i < arr.length; i++) {
        for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                tmp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = tmp;
            }
        }
    }
}

3.使用快排，满足时间复杂度nlogn

• 错了很多次的！一定要注意！
• 这个等于号，一定要放在end这，不然就会出错！原因画个图就能知道！
  

// 快排序
private static void doSolution4(int[] arr, int start, int end) {
    if (arr.length == 0 || start < 0 || end >= arr.length || start > end) {
        return;
    }
    int smallIndex = partition(arr, start, end);
    if (smallIndex > start) {
        doSolution4(arr, start, smallIndex - 1);
    }
    if (smallIndex < end) {
        doSolution4(arr, smallIndex + 1, end);
    }
}

private static int partition(int[] arr, int start, int end) {
    int p = arr[start];
    while (start < end) {
        while (start < end && arr[end] >= p) {
            end--;
        }
        swap(arr, start, end);
        while (start < end && arr[start] < p) {
            start++;
        }
        swap(arr, start, end);
    }
    return start;
}

private static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

要是将快排改成降序呢？

• 这个时候while的等于放在end和start都是可以的
• 只用交换一下两个while的条件即可

    private void quickSort(int[] arr, int start, int end) {
        if (arr.length == 0 || start < 0 || end >= arr.length || start > end) {
            return;
        }
        int small = partition(arr, start, end);
        if (start < small) {
            quickSort(arr, start, small - 1);
        }
        if (end > small) {
            quickSort(arr, small + 1, end);
        }


    }

    private int partition(int[] arr, int start, int end) {
        int p = arr[start];
        while (start < end) {
            while (start < end && arr[end] <= p) {
                end--;
            }
            swap(arr, start, end);
            while (start < end && arr[start] > p) {
                start++;
            }
            swap(arr, start, end);
        }
        return start;
    }

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }