排序算法

冒泡排序

public static void solution(int[] nums) {
        if (nums == null || nums.length == 0) {
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            for (int j = i; j < nums.length; j++) {
                if (nums[j] < nums[i]) {
                    int temp = nums[j];
                    nums[j] = nums[i];
                    nums[i] = temp;
                }
            }
        }
    }

插入排序

public void solution(int[] nums) {
        if (nums == null){
            return;
        }
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] < nums[i]){
                    swap(nums, j, i);
                }else {
                    continue;
                }
            }
        }
    }

public void swap(int[] nums, int n, int m) {
        int temp = nums[n];
        nums[n] = nums[m];
        nums[m] = temp;
    }

选择排序

public static void solution(int[] nums) {
        if (nums == null || nums.length == 0) {
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            int minIndex = i;
            for (int j = i; j < nums.length; j++) {
                if (nums[j] < nums[minIn##dex]) {
                    minIndex = j;
                }
            }
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
        }
    }

希尔排序

public void solution(int[] array,int length) {
        int temp = 0;
        int incre = length;

        while(true){
            incre = incre/2;

            for(int k = 0;k<incre;k++){    //根据增量分为若干子序列

                for(int i=k+incre;i<length;i+=incre){

                    for(int j=i;j>k;j-=incre){
                        if(array[j]<array[j-incre]){
                            temp = array[j-incre];
                            array[j-incre] = array[j];
                            array[j] = temp;
                        }else{
                            break;
                        }
                    }
                }
            }
            if(incre == 1){
                break;
            }
        }
    }

归并排序

public void merge(int[] nums, int left, int mid, int right) {
        int[] helper = new int[right-left+1];
        int leftPoint = left;
        int rightPoint = mid + 1;
        int k = 0;
        while (leftPoint <= mid && rightPoint <= right) {
            if (nums[leftPoint] <= nums[rightPoint]) {
                helper[k] = nums[leftPoint];
                k++;
                leftPoint++;
            }else {
                helper[k] = nums[rightPoint];
                k++;
                rightPoint++;
            }
        }
        while (leftPoint <= mid) {
            helper[k] = nums[leftPoint];
            k++;
            leftPoint++;
        }
        while (rightPoint <= mid) {
            helper[k] = nums[rightPoint];
            k++;
            rightPoint++;
        }
        for (int i = 0; i < helper.length; i++) {
            nums[left+i] = helper[i];
        }
    }

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

快速排序

public void quickSort(int[] nums, int left, int right) {
        if (left >   right) return;
        //确定基准数
        int benchmark = nums[left];
        int i = left;
        int j = right;
        while (i != j) {
            while (nums[j] >= benchmark && j > i) {
                j--;
            }
            while (nums[i] <= benchmark && i < j) {
                i++;
            }
            if (j > i) {
                Utils.swap(nums, i, j);
            }
        }
        //将基准数和左侧最大数交换
        Utils.swap(nums, left, i);
        quickSort(nums, left, i - 1);
        quickSort(nums, j+1, right);
    }

堆排序

public void sort(int arr[]) {
        int n = arr.length;
        heapify(arr, n, n-1);
        printArray(arr);
        for (int i=n-1; i>=0; i--)
        {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
            printArray(arr);
        }
    }


    void heapify(int arr[], int n, int i) {
        int largest = i;
        int l = 2*i + 1;
        int r = 2*i + 2;

        if (l < n && arr[l] > arr[largest])
            largest = l;
        if (r < n && arr[r] > arr[largest])
            largest = r;
        if (largest != i)
        {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }

桶排序

public void bucketSort(int[] nums, int start, int end) {
        int[] bucket = new int[end - start + 1];
        for (int t : nums) {
            int index = t - start;
            bucket[index] = bucket[index] + 1;
        }
        int index = 0;
        for (int i = 0; i < bucket.length; i++) {
            if (bucket[i] == 0) {
                continue;
            }else {
                for (int t = 0; t < bucket[i]; t++) {
                    nums[index] = i;
                    index++;
                }
            }
        }
    }