标签：index arr int 堆排序 算法 节点 lagest left

堆排序

• 先让整个数组都变成大根堆结构，建立堆的过程
  • 从上到下的方法，时间复杂度为O(logN*N)
  • 从下到上的方法，时间复杂度为O(N)
• 把堆的最大值和堆末尾的值进行交换，然后减少堆的大小之后，再去调整堆，一直周而复始，时间复杂度为O(N)
• 堆的大小减成0之后，排序完成

图示

代码

其实你会将数据调整为 小根堆或者大根堆，你就会堆排序了

从上到下构建堆

    /**
     * 
     * 从上之下
     * @param heap
     * @param index
     */
    public void heapInsert(int[] heap, int index) {
        
        // 父节点(index - 1) / 2小于当前节点
        while (heap[(index - 1) / 2] < heap[index]) {
            // 交换
            swap(heap,(index - 1) / 2,index);
            index = (index - 1) / 2;
        }
    }

从下到上构建堆

private void heapfiy(int[] arr, int index, int heapSize) {
        // 获取当前index 的左孩子
        int left = index * 2 + 1;

        // 左孩子节点小于堆大小
        while (left < heapSize) {

            // 孩子节点的最大 值的位置值
            int lagest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;

            // 判断index 和孩子节点的值大小
            lagest = arr[index] > arr[lagest] ? index : lagest;

            // 如果当前节点就是最大的不需要继续下沉，跳出
            if (lagest == index) {
                break;
            }
            // 交换
            swap(arr, index, lagest);

            index = lagest;

            // 获取最大的节点的左孩子节点
            left = index * 2 + 1;
        }

    }

整个堆排序代码

public class HeapSort {

    private void heapfiy(int[] arr, int index, int heapSize) {
        // 获取当前index 的左孩子
        int left = index * 2 + 1;

        // 左孩子节点小于堆大小
        while (left < heapSize) {

            // 孩子节点的最大 值的位置值
            int lagest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;

            // 判断index 和孩子节点的值大小
            lagest = arr[index] > arr[lagest] ? index : lagest;

            // 如果当前节点就是最大的不需要继续下沉，跳出
            if (lagest == index) {
                break;
            }
            // 交换
            swap(arr, index, lagest);

            index = lagest;

            // 获取最大的节点的左孩子节点
            left = index * 2 + 1;
        }

    }


    /**
     * 数组两个位置交换
     * @param arr
     * @param i
     * @param j
     */
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    @Test
    public void testHeapSort() {
        int[] arr = {1, 20,18, 6, 9, 2, 10, 11, 7};

        // 构建最大根堆
        for (int i = 0; i < arr.length; i++) {
            heapfiy(arr, arr.length - 1 - i, arr.length);
        }

        System.out.println("----------------------");
        for (int i : arr) {
            System.out.print (i+" ");
        }
        System.out.println();
        System.out.println("----------------------");

        /*
         * 最大跟交换
         * heapSize --
         * heapFiy调用
         */
        int len = arr.length;
        for (int i = 0; i < arr.length - 1; i++) {
            swap(arr, 0, len - 1);
            heapfiy(arr, 0, --len);
        }
        
        System.out.println("++++++++++++++++++");
        for (int i : arr) {
            System.out.print (i+" ");
        }
        System.out.println();
        System.out.println("++++++++++++++++++");
    }
}

标签：index,arr,int,堆排序,算法,节点,lagest,left
来源： https://www.cnblogs.com/wuzhixuan/p/15098717.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。