刷题02——排序

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 - 1) / 2; i >= 0; i--) {
            heapAdjust(nums, i, 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 s, int length) {
        int temp = nums[s];
        for(int j = 2 * s; j <= length; j = 2 * j) {
            if(j + 1 <= length && nums[j] <nums[j+1]) {
                j = j + 1;
            }
            if(nums[j] <= temp) break;
            nums[s] = nums[j];
            s = j;
        }
        nums[s] = 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;
                }
            }
        }
    }
}

归并排序：

private void msort(int nums[], int tr1[], int s, int t) {
        if(s == t) {
            tr1[s] = nums[s];
        } else {
            int[] tr2 = new int[nums.length];
            int middle = (s + t) / 2;
            msort(nums, tr2, s, middle);
            msort(nums, tr2, middle + 1, t);
            merge(tr2, tr1, s, middle, t);
        }
    }
    
    private void merge(int tr1[], int tr2[], int s, int middle, int t) {
        int j = middle + 1;
        int k = s;
        for(; s <= middle && j <= t; k++) {
            if(tr1[s] <= tr1[j]) {
                tr2[k] = tr1[s++];
            }else {
                tr2[k] = tr1[j++];
            }
        }
        while(s <= middle) {
            tr2[k++] = tr1[s++];
        }
        while(j <= t) {
            tr2[k++] = tr1[j++];
        }
    }

快速排序：

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;
    }
}