经典的排序算法

排序算法

1、冒泡排序

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

2、选择排序

public void sortColors(int[] nums) {
    int len = nums.length;
    int j = 0;
    for(int i = 0; i < len; i++) {
        int min = nums[i];
        int index = i;
        for(j = i; j < len; j++) {
            if(min > nums[j]) {
                min = nums[j];
                index = j;
            }
        }
        nums[index] = nums[i];
        nums[i] = min;
    }
}

3、插入排序

public void sortColors(int[] nums) {
   int len = nums.length;
   
   for(int i = 1; i < len; i++) {
       int temp = nums[i];
       int j = i - 1;
       while(j >= 0 && nums[j] > temp) {
           nums[j + 1] = nums[j];
           j--;
       }
       nums[j + 1] = temp;
   }
}

4、快速排序

	public void sortColors(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
    }

    public void quickSort(int[] nums, int start, int end) {
        int pivot = nums[start];
        int i = start, j = end;

        while(i < j) {
            while(i < j && nums[j] >= pivot) {
                j--;
            }
            nums[i] = nums[j];
            while(i < j && nums[i] <= pivot) {
                i++;
            }
            nums[j] = nums[i];
        }
        nums[i] = pivot;

        if(i - 1 > start) {
            quickSort(nums, start, i - 1);
        }
        if(j + 1 < end) {
            quickSort(nums, j + 1, end);
        }
    }

5、归并排序

	public void sortColors(int[] nums) {
        int[] temp = new int[nums.length];
        sort(nums, 0, nums.length - 1, temp);
    }

    public void sort(int[] nums, int left, int right, int[] temp) {
        if(left < right) {
            int mid = (left + right) / 2;
            sort(nums, left, mid, temp);
            sort(nums, mid + 1, right, temp);
            merge(nums, left, mid, right, temp);
        }
    }

    public void merge(int[] nums, int low, int mid, int high,int[] temp) {
        int i = low;
        int j = mid + 1;//右序列指针
        int t = 0;//临时数组指针
        while (i <= mid && j <= high){
            if(nums[i] <= nums[j]){
                temp[t++] = nums[i++];
            }else {
                temp[t++] = nums[j++];
            }
        }
        while(i <= mid){//将左边剩余元素填充进temp中
            temp[t++] = nums[i++];
        }
        while(j <= high){//将右序列剩余元素填充进temp中
            temp[t++] = nums[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(low <= high){
            nums[low++] = temp[t++];
        }
    }

6、堆排序

	public void sortColors(int[] nums) {
        HeapSort(nums, nums.length);
    }

    public void HeapAdjust(int arr[], int i, int length) {
        // 调整i位置的结点
        // 先保存当前结点的下标
        int max = i;
        // 当前结点左右孩子结点的下标
        int lchild = i * 2 + 1;
        int rchild = i * 2 + 2;
        if (lchild < length && arr[lchild] > arr[max]) {
            max = lchild;
        }
        if (rchild < length && arr[rchild] > arr[max]) {
            max = rchild;
        }
        // 若i处的值比其左右孩子结点的值小，就将其和最大值进行交换
        if (max != i) {
            int temp;
            temp = arr[i];
            arr[i] = arr[max];
            arr[max] = temp;
            // 递归
            HeapAdjust(arr, max, length);
        }
    }
    
    // 堆排序
    public void HeapSort(int arr[], int length) {
        // 初始化堆
        // length / 2 - 1是二叉树中最后一个非叶子结点的序号
        for (int i = length / 2 - 1; i >= 0; i--) {
            HeapAdjust(arr, i, length);
        }
        // 交换堆顶元素和最后一个元素
        for (int i = length - 1; i >= 0; i--) {
            int temp;
            temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            HeapAdjust(arr, 0, i);
        }
    }