剑指offer——最小的K个数和数组中第K大的元素

 

 

解题思路：

乘着做这个题，顺便复习下堆排序。

先说堆排序是一个什么东西：https://blog.csdn.net/u013384984/article/details/79496052

大顶堆升序，小顶堆降序。

随便定义的一个堆。

 

第一步：

此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

此处必须注意，我们把6和9比较交换之后，必须考量9这个节点对于其子节点会不会产生任何影响？因为其是叶子节点，所以不加考虑；但是，一定要熟练这种思维，写代码的时候就比较容易理解为什么会出现一次非常重要的交换了。

 

 

 注意：第一步已经把9弄上去了，所以只需要看9 5 6这三个数字是不是符合大顶堆，一看符合的，然后回到4.找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

牢记上面说的规则，每次交换都要把改变了的那个节点所在的树重新判定一下，这里就用上了，4和9交换了，变动了的那棵子树就必须重新调整，一直调整到符合大根堆的规则为截。

此时，我们就将一个无序序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

a.将堆顶元素9和末尾元素4进行交换

这里，必须说明一下，所谓的交换，实际上就是把最大值从树里面拿掉了，剩下参与到排序的树，其实只有总结点的个数减去拿掉的节点个数了。所以图中用的是虚线。

 

注意：这里和root交换后的东西，后面已经不放在堆里面进行排了。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        
        ArrayList<Integer> res = new ArrayList<>();
        
        if(k>input.length || input==null)
            return res;
        // 按照完全二叉树的特点，从最后一个非叶子节点开始，对于整棵树进行大根堆的调整
        // 也就是说，是按照自下而上，每一层都是自右向左来进行调整的
        // 注意，这里元素的索引是从0开始的
        // 另一件需要注意的事情，这里的建堆，是用堆调整的方式来做的
        // 堆调整的逻辑在建堆和后续排序过程中复用的
        for(int i=k/2-1;i>=0;i--)
        {
            Adjust(input,i,k-1);//从最后一个非叶子节点开始
        }
        
        for(int j=k;j<input.length;j++)
        {
            // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
            // 而这里，实质上是自上而下，自左向右进行调整的
            if(input[j]<input[0])
            {
                int temp = input[0];
                
                input[0] = input[j];
                
                input[j] = temp;
                
                Adjust(input,0,k-1);
            }
        }
        
        for(int i=0;i<k;i++)
        {
            res.add(input[i]);
        }
        return res;
    }
    public void Adjust(int [] input,int k,int length)
    {
        int temp = input[k];
        
        for(int i=2*k+1;i<=length;i=2*i+1)//i是子节点
        {
            if(i<length && input[i]<input[i+1])
                i++;
            
            if(temp>input[i])
            {
                break;
            }
            else
            {
                swap(input, i, k);
                // 下面就是非常关键的一步了
                // 如果子节点更换了，那么，以子节点为根的子树会不会受到影响呢？
                // 所以，循环对子节点所在的树继续进行判断
                k = i;
            }
        }
    }
    
    public void swap(int []input,int a,int b)
    {
        int temp = input[a];
        input[a]=input[b];
        input[b] = temp;
    }
    
    
}

 

class Solution {
    public int findKthLargest(int[] input, int k) {

        if(input.length==1)
            return input[0];
        int length = input.length;
        for(int i=k/2-1;i>=0;i--)
        {
            Adjust(input,i,length-1);
        }
        
        for(int j = length - 1; j >=k; j--)
        {
            if(input[j]>input[0])
            {
                int temp = input[0];
                input[0] = input[j];
                input[j] = temp;
                Adjust(input,0,k-1);
            }
        }

        return input[0];
        
            
    }
    
    public void Adjust(int []input,int k,int length)
    {
        int temp = input[k];
        for(int i=2*k+1;i<=length;i=2*i+1)
        {
            if(i<length && input[i]>input[i+1])
            {
                i++;
            }
            if(temp<input[i])
            {
                break;
            }
            else
            {
                swap(input,i,k);
                k=i;
            }
            
        }
    }
    
    public void swap(int []input,int a,int b)
    {
        int temp = input[a];
        input[a]=input[b];
        input[b] = temp;
    }
    
}