堆排序 和冒泡排序

1.堆排序是nlogN级别的排序:

  public static void heapSort(int[] arr){
        //1.先将arr进行heapify调整为最大堆
        //从最后一个非叶子结点开始进行shiftDown操作
        for (int i = (arr.length -1 -1)>>1; i >= 0; i--) {
            shiftDown(arr, i, arr.length);
        }
            //此时arr调整为最大堆
        for (int i = arr.length -1; i >0 ; i--) {
            //arr[0]就是堆顶元素,就是当前堆的最大值
            swap(arr,0,i);
            shiftDown(arr,0,i);
        }
    }

    //元素下沉操作
    private static void shiftDown(int[] arr, int i, int length) {
        while(2* i +1 <length){
            int j = (i<<1) +1;
            if(j + 1<length && arr[j +1] >arr[j]){
                j = j+1;
            }
            //j就是左右子树的最大值
            if(arr[i] >arr[j]){
                //下沉结束
                break;
            }else{
                swap(arr,i,j);
                i = j;
            }
        }
    }

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

    public static void main(String[] args) {
        int[] arr = {7,5,4,3,1,2,10,9,8};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

2.冒泡排序o(n^2)

  public static void bubbleSort(int[] arr){
        for (int i = 0; i <arr.length -1; i++) {
            boolean isSwaped = false;
            for (int j = 0; j <arr.length -1 -i; j++) {
                if(arr[j] >arr[j +1]){
                    swap(arr,j,j+1);
                    isSwaped = true;
                }
            }
            if(!isSwaped){
                break;//已经彻底有序了
            }
        }

堆和优先级队列:

1.最大堆、最小堆实现

2.堆排序

3.TopK问题

17.14 -- 343--373

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
堆排序代码: ```java public class HeapSort { public static void heapSort(int[] arr) { int n = arr.length; // Build heap (rearrange array) for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i); // One by one extract an element from heap for (int i = n - 1; i > 0; i--) { // Move current root to end int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; // call max heapify on the reduced heap heapify(arr, i, 0); } } // To heapify a subtree rooted with node i which is // an index in arr[]. n is size of heap static void heapify(int[] arr, int n, int i) { int largest = i; // Initialize largest as root int l = 2 * i + 1; // left = 2*i + 1 int r = 2 * i + 2; // right = 2*i + 2 // If left child is larger than root if (l < n && arr[l] > arr[largest]) largest = l; // If right child is larger than largest so far if (r < n && arr[r] > arr[largest]) largest = r; // If largest is not root if (largest != i) { int swap = arr[i]; arr[i] = arr[largest]; arr[largest] = swap; // Recursively heapify the affected sub-tree heapify(arr, n, largest); } } public static void main(String[] args) { int[] arr = {12, 11, 13, 5, 6, 7}; heapSort(arr); System.out.println(Arrays.toString(arr)); } } ``` 冒泡排序代码: ```java public class BubbleSort { public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // swap arr[j] and arr[j+1] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } public static void main(String[] args) { int[] arr = {64, 34, 25, 12, 22, 11, 90}; bubbleSort(arr); System.out.println(Arrays.toString(arr)); } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值