java实现快排和堆排序

快排的Java实现

直接以第一个元素为分界元素，下面是直接Java代码实现

 public class QuickSort {

        public static void main(String[] args) {
            int[] nums = {17, 8, 100, 120, 122, 6, 3, 9};
            quickSort(nums);
            for (int num : nums) {
                System.out.print(" " + num);
            }
        }

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

        public static void quickSort(int[] nums, int start, int end) {
            if (start >= end) {
                return;
            }
            int low = start;
            int high = end;
            int splitKey = nums[start];
            while (start < end) {
                while (start < end && nums[end] >= splitKey) {
                    end--;
                }
                nums[start] = nums[end];
                while (start < end && nums[start] <= splitKey) {
                    start++;
                }
                nums[end] = nums[start];
            }
            nums[end] = splitKey;
            quickSort(nums, low, end - 1);
            quickSort(nums, end + 1, high);
        }

    }

堆排序的Java实现

以从小到大排序为例，堆排主要包括两个过程：
1、构建最大堆（以数组为堆的数据结构）
2、替换当前堆顶元素和堆尾元素，忽略已经有序的堆尾，重新调整堆，不断重复（其实还是不断get&&remove堆顶最大或最小值放在有序队列中的过程）

堆排还是比较简单的,视频:https://www.bilibili.com/video/av55290486?from=search&seid=16303431171103441937
直接上Java实现代码：

    public class HeapSort {
        public static void main(String[] args) {
            int[] nums = {17, 8, 100, 120, 122, 6, 3, 9};
            heapSort(nums);
            for (int num : nums) {
                System.out.print(" " + num);
            }
        }

        public static void heapSort(int[] nums) {
            if (nums == null || nums.length <= 1) {
                return;
            }
            int len = nums.length;
            for (int i = len / 2 - 1; i >= 0; i--) {
                adjustHeap(nums, len, i);
            }
            for (int i = len - 1; i >= 0; i--) {
                swap(nums, i, 0);
                adjustHeap(nums, i, 0);
            }
        }

        public static void adjustHeap(int[] nums, int size, int index) {
            int largest = index;
            int left = index * 2 + 1;
            int right = index * 2 + 2;
            if (left < size && nums[left] > nums[largest]) {
                largest = left;
            }
            if (right < size && nums[right] > nums[largest]) {
                largest = right;
            }
            if (largest != index) {
                swap(nums, largest, index);
                adjustHeap(nums, size, largest);
            }
        }

        public static void swap(int[] a, int i, int j) {
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
        
    }