刷题——排序

75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

进阶：

• 一个直观的解决方案是使用计数排序的两趟扫描算法。
  首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
• 你能想出一个仅使用常数空间的一趟扫描算法吗？

冒泡排序：

private void bubbleSort(int[] nums) {
    for(int i = nums.length - 1; i > 0; i--) {
        for(int j = 0; j < i; j++) {
            if(nums[j] > nums[j+1]) {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
}

选择排序：

private void selectSort(int[] nums) {
        int min;
        for(int i = 0; i < nums.length - 1; i++) {
            min = i;
            for(int j = i + 1; j < nums.length; j++) {
                if(nums[min] > nums[j]) {
                    min = j;
                }
            }
            if(i != min) {
                int temp = nums[i];
                nums[i] = nums[min];
                nums[min] = temp;
            }
        }
    }

插入排序：

private void insertSort(int[] nums) {
    int i, j;
    for(i = 1; i < nums.length; i++) {
        if(nums[i-1] > nums[i]) {
            int temp = nums[i];
            for(j = i - 1; j >= 0 && nums[j] > temp; j--) {
                nums[j+1] = nums[j];
            }
            nums[j+1] = temp;
        }
    }
}

堆排序：

class Solution {
    public void sortColors(int[] nums) {
        int i, temp;
        for(i = nums.length / 2; i > 0; i--) {
            heapAdjust(nums, i - 1, nums.length - 1);
        }
        for(i = nums.length - 1; i > 0; i--) {
            temp = nums[0];
            nums[0] = nums[i];
            nums[i] = temp;
            heapAdjust(nums, 0, i - 1);
        }
    }
    private void heapAdjust(int[] nums, int index, int length) {
        int temp = nums[index];
        for(int j = 2 * index + 1; j <= length; j = 2 * j + 1) {
            if(j + 1 <= length && nums[j] <nums[j+1]) {
                j = j + 1;
            }
            if(nums[j] <= temp) break;
            nums[index] = nums[j];
            index = j;
        }
        nums[index] = temp;
    }
}

希尔排序：

class Solution {
    public void sortColors(int[] nums) {
        shellSort(nums);
    }
    private void shellSort(int nums[]) {
        int increment = nums.length;
        int i,j;
        while(increment > 1) {
            increment = increment / 3 + 1;
            for(i = 0; i + increment < nums.length; i++) {
                if(nums[i] > nums[i + increment]) {
                    int temp = nums[i + increment];
                    for(j = i; j >= 0 && nums[j] > temp; j = j - increment) {
                        nums[j + increment] = nums[j];
                    }
                    nums[j + increment] = temp;
                }
            }
        }
    }
}

归并排序：

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

快速排序：

class Solution {
    public void sortColors(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
    }
    private void quickSort(int[] nums, int low, int high) {
        if(low < high) {
            int pivot = partition(nums, low, high);
            quickSort(nums, low, pivot - 1);
            quickSort(nums, pivot + 1, high);
        }
    }
    private int partition(int[] nums, int low, int high) {
        int key = nums[low];
        while(low < high) {
            while(low < high && nums[high] >= key) {
                high--;
            }
            swap(nums, low, high);
            while(low < high && nums[low] <= key) {
                low++;
            }
            swap(nums, low, high);
        }
        return low;
    }
    private void swap(int[] nums, int low, int high) {
        int temp = nums[low];
        nums[low] = nums[high];
        nums[high] = temp;
    }
}