排序算法——数据结构

代码：

    public int[] sortArray(int[] nums) {
        if (nums.length == 0 || nums.length == 1)
            return nums;
        int n = nums.length;
        int i, j;
        for (i = 1; i < n; i++) {
            if (nums[i] < nums[i - 1]) {
                int curr = nums[i];
                for (j = i - 1; j >= 0 && curr < nums[j]; j--) {
                    nums[j + 1] = nums[j];
                }
                nums[j + 1] = curr;
            }
        }
        return nums;
    }

代码：

public int[] sortArray(int[] nums) {
        if (nums.length == 0 || nums.length == 1)
            return nums;
        int n = nums.length;
        int i, j;
        for (i = 1; i < n; i++) {
            int left = 0;
            int right = i;//右边界取不到
            int curr = nums[i];
            while (left < right) {
                int mid = (left + right) / 2;
                if (nums[mid] > curr) {
                    right = mid;
                } else {
                    left = mid + 1;
                }
            }
            for (j = i - 1; j >= right; j--) {
                nums[j + 1] = nums[j];
            }
            nums[j + 1] = curr;
        }
        return nums;
    }

 代码：（把插入排序的1变成dk）

    public int[] sortArray(int[] nums) {
        if (nums.length == 0 || nums.length == 1)
            return nums;
        int n = nums.length;
        int i, j, dk;
        for (dk = n / 2; dk >= 1; dk = dk / 2) {
            for (i = dk; i < n; i++) {
                if (nums[i] < nums[i - dk]) {
                    int curr = nums[i];
                    for (j = i - dk; j >= 0 && curr < nums[j]; j -= dk) {
                        nums[j + dk] = nums[j];
                    }
                    nums[j + dk] = curr;
                }
            }
        }
        return nums;
    }

 代码：（和图示不一样，代码是冒泡最小）

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        for (int i = 0; i < nums.length; i++) {
            boolean flag = false;
            for (int j = nums.length - 1; j > i; j--) {
                if (nums[j] < nums[j - 1]) {
                    flag = true;
                    int temp = nums[j];
                    nums[j] = nums[j - 1];
                    nums[j - 1] = temp;
                }
            }
            if (!flag)
                return nums;
        }
        return nums;
    }

 代码：

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        qsort(nums, 0, nums.length - 1);
        return nums;
    }

    private void qsort(int[] nums, int leftIndex, int rightIndex) {
        if (rightIndex < leftIndex)
            return;
        int flag = nums[leftIndex];
        int left = leftIndex, right = rightIndex;
        while (left < right) {
            while (right > left && nums[right] >= flag) {
                right--;
            }
            nums[left] = nums[right];
            while (left < right && nums[left] <= flag) {
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = flag;
        qsort(nums, leftIndex, left - 1);
        qsort(nums, right + 1, rightIndex);
    }

 代码：

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        for (int i = 0; i < nums.length; i++) {
            int minIndex = i;
            int min = nums[i];
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] < min) {
                    minIndex = j;
                    min = nums[j];
                }
            }
            if (minIndex != i) {
                nums[minIndex] = nums[i];
                nums[i] = min;
            }
        }
        return nums;
    }

 代码：

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int num : nums) {
            pq.add(num);
        }
        for (int i = 0; i < nums.length; i++) {
            nums[i] = pq.poll();
        }
        return nums;
    }

 代码：

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        mergeSort(nums, 0, nums.length - 1);
        return nums;
    }

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

    private void merge(int[] nums, int left, int mid, int right) {
        int[] temp = Arrays.copyOf(nums, nums.length);
        int p1 = left, p2 = mid + 1, k = left;
        while (p1 <= mid && p2 <= right) {
            if (nums[p1] <= nums[p2])
                temp[k++] = nums[p1++];
            else
                temp[k++] = nums[p2++];
        }
        while (p1 <= mid) {
            temp[k++] = nums[p1++];
        }
        while (p2 <= right) {
            temp[k++] = nums[p2++];
        }
        System.arraycopy(temp, 0, nums, 0, temp.length);
    }

 

代码：（只用于正数）

    public int[] sortArray(int[] nums) {
        if (nums.length <= 1)
            return nums;
        int max = Integer.MIN_VALUE;
        for (Integer n : nums) {
            max = Math.max(max, n);
        }
        int bit = 0;
        while (max >= Math.pow(10, bit)) {
            bit++;
        }
        for (int i = 0; i < bit; i++) {
            ArrayList<ArrayList<Integer>> bucket = new ArrayList<>();
            for (int j = 0; j < 10; j++) {
                bucket.add(new ArrayList<>());
            }
            for (Integer n : nums) {
                int a = (int) (n / Math.pow(10, i));
                int bitnum = a % 10;
                bucket.get(bitnum).add(n);
            }
            int k = 0;
            for (ArrayList<Integer> num : bucket) {
                for (Integer n : num) {
                    nums[k++] = n;
                }
            }
        }
        return nums;
    }