每日总结[9]20191019 数据结构复习-堆排序/优先级队列

一、把我能想到的写下来

1.堆排序 思路:

    先复习一下上一篇中构建堆的方法，一种是逐个 add ，每次加在末尾，并上浮到根节点；一种是（在已有数组的基础上）自下向上依次下沉。
&zui#160;   堆排序的过程，以结果降序为例，**其实就是不断取得最大值的过程。**如果问原地排序，要想到第二种方式，当构建好堆后，堆的根节点就是最大值，每次获取根节点，然后把它与末尾交换，新的节点到了根的位置，可能会破坏大顶堆的结构，对根节点再进行下沉即可恢复大顶堆结构。这就是方法一——原地排序。再有，联想到上一篇的 deleteMax 方法，也可以获取最大值，不断地调用，也是原地排序的，而且这个办法还简单。
;   2020复习，我发现其实这俩一个意思… …

方法一：原地堆排序。不占用额外空间。

    从最后一个非叶子节点开始，（因为叶子节点可以看作是天然的堆）siftDown,(这个siftDown不像之前的siftDown，是heap类中的，用的是该类的数组data，我们直接在传入的数组的基础上进行元素交换)直到根为止， 这样堆顶元素一定是最大值,然后每次将堆顶与数组最后一个元素交换，（这样就可以使最大的元素在最后）然后数组的Length-1，由于原来的数组已经是堆结构，因此只需要调整根和它的左右子树，即让根siftDown即可，就又能保证堆的性质。

方法二：

把数组先变成堆，(可以在heap类中写一个构造方法，传入数组)，每次调用extractMax方法，取出并删除堆顶元素，可以逆序存储（下标从大到小）到新的数组中。

优先级队列：
队列有入队enQueue操作、出队deQueue操作、取队头但不删除peek、取队头并删除？？？操作、判空isEmpty操作、取得长度getSize操作，队是先进先出的。

(2)写一遍代码:

//自己写一遍 堆排序
public class heapSort
{
    //方法一：先把数组变成堆.再调用extractMax方法，逆序存储堆顶元素，即从小到大排序

    public Object[] heapSort1(Object[] disorderly)
    { heap heap4=new heap(disorderly);
        Object[]orderly=new Object[disorderly.length];
        int length=heap4.getSize();
        for(int i=length-1;i>=0;i--)
        { orderly[i]=heap4.extractMax();}
        return orderly; }

        //方法二：原地堆排序。Okay
    //首先，将数组变成堆，不使用heap类中的data数组，在原数组基础上交换元素，
    // 先原地变成堆
    //然后每次将堆顶——即最大值和数组最后的元素交换
    //除堆顶外其他子树仍是堆结构
    //再将根siftDown
    //次数为数组的length
    //简便起见，不像heap的构造器中传入了比较器，这里的类型为int
    public int[] heapSort3(int[] disordly)
    {//最后一个非叶子节点
        int i=getFather(disordly.length-1);
        for(int j=i;j>=0;j--)
        {siftDown(disordly,j);}
return disordly;
    }

    private void siftDown(int[]data,int index) {
        while (getLeft(index) < data.length) {
            if(data[getMaxChild(data,index)]>data[index])
            { int change=getMaxChild(data,index);
                swap2(data,getMaxChild(data,index), index);
                index=change;}
            else break;
        }
    }

    private void swap2(int[]data,int index1,int index2)
    { int temp=data[index1];
        data[index1]=data[index2];
        data[index2]=temp; }

    private int getFather(int index)
    {return (index-1)/2;}

    private int getLeft(int index)
    {return index*2+1;}

    private int getRight(int index)
    {return index*2+2;}

    private int getMaxChild(int[]data,int index1)
    {if(getRight(index1)==data.length) return getLeft(index1);
        if(data[getLeft(index1)]>data[getRight(index1)])
            return getLeft(index1);
        else return getRight(index1);
    }

}

改良了siftDown(见上篇博客)，测试均通过。

(3)算法题练习：https://leetcode-cn.com/problems/top-k-frequent-elements/submissions/
LeetCode347 给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

思路：优先级队列-jdk1.5内置的-出队操作最先出的是值最小的。
新建一个Map，用来存储数组的元素值和其对应的频率。遍历数组，将值和频率存入。

优先级队列是优先级高的先出队，（那么在队中剩下的就是优先级低的，应当是频率的值大的）。队列中只放k个元素，（只放元素不放频率）进队的规则就是，当前元素的频率比队列中的最小的频率大时就入队。然后那个最小的会出队（验证了值越小的优先级越高，因此需要改写一下）遍历完Map，即可得到频率前k高的元素。

结合内置的优先级队列，（需要让队列放k+1个元素，最后的结果放在大小为k的List中）判断是否入队的规则是：遍历Map时，先将目前的元素入队，再根据频率，执行出队操作（这样就可以让最小频率出队）。获取结果，可以调用队列的toArray方法存储到数组，再通过List倒一下。
有一个问题，我们希望入队入的是元素值，而执行出队的依据（比较器）是频率，而优先队列的构造方法只能传入初始化优先队列长度和比较器，怎么实现入的是元素，而比较的是频率？？？ 可以创建一个类valueAndf，在该类中提供一个比较器，让频率去作比较。那么Map中放的key是元素的值，放的value是valueAndf。

我写的代码：

package BinaryTree.Heap.LeetCode347;


import java.util.*;

public class Solution {

class valueAndF implements Comparable
{
    @Override
    public String toString() {
        return "valueAndF{" +
                "value=" + value +
                ", frequecy=" + frequecy +
                '}';
    }

    public valueAndF(int value, int frequecy)
    {this.value=value;
    this.frequecy=frequecy;}
    private int value;
    private int frequecy;


    public int compareTo(Object o) {
if(this.frequecy>((valueAndF)o).frequecy) return 1;
if(this.frequecy==((valueAndF)o).frequecy) return 0;
else return -1;
    }

}

    public List<Integer> topKFrequent(int[] nums, int k) {
        PriorityQueue priorityQueue=new PriorityQueue(nums.length+1);
        Map<Integer,valueAndF>keyAndFreq=new HashMap();

        for(int i:nums)
        { if(keyAndFreq.get(i)==null)
            { valueAndF vandf=new valueAndF(i,1);
                keyAndFreq.put(i,vandf);}

                else{int frequecy=keyAndFreq.get(i).frequecy+1;
            valueAndF vandf=new valueAndF(i,frequecy);
            keyAndFreq.put(i,vandf); }}

for(valueAndF i:keyAndFreq.values())
            {if(priorityQueue.size()<k)
                {priorityQueue.add(i);}
               else { priorityQueue.add(i);
                priorityQueue.poll(); }

            }


        List result=new ArrayList<>();
        int[] save=new int[keyAndFreq.size()];
        valueAndF[]v=new valueAndF[keyAndFreq.size()];
        for(int i=0;i<k;i++)
        { v[i]=(valueAndF)priorityQueue.poll();
        save[i]=v[i].value;
        }
for(int i=k-1;i>=0;i--){result.add(save[i]);}
return result;}}

（这个好像是我第一次不参考任何人的代码，AC的中等题，嘻嘻~。）
通过这道算法题，我还发现JDK1,5内置的优先级队列Priority是这样的，我们可以让进队的类（能进队的一定是具有可比性的，需要覆写比较器的相应方法）以Comparable的compareTo方法为例：

public int compareTo(Object o) {
if(this.frequecy<((valueAndF)o).frequecy) return 1;
if(this.frequecy==((valueAndF)o).frequecy) return 0;
else return -1;
    }

当add()了新的元素时，当前这个元素就相当于this(this指代当前对象)，而优先级队列的队头元素就相当于o，如果当前元素的frequecy小于队头的frequecy，那么它不会成为队头，这样一来，就会是大的值先出队。
而本题是需要最小值先出队，因此我们需要写成

if(if(this.frequecy>((valueAndF)o).frequecy) return 1;)

(为方便记忆，总结为：想知道最神马值先出队，就看o)

(还要记住一点，优先级队列永远是优先级高的先出队（所以本题中值越小优先级越高。）（其实这个意义也不大，还是知道值大值小先出队来得实在。）)

2020重写代码，已通过：

public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> map=new HashMap();
        PriorityQueue<Integer> queue=new PriorityQueue(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return map.get((Integer) o1)-map.get((Integer) o2);
            }
        });
        ArrayList arrayList=new ArrayList();
      
for(int i=0;i<nums.length;i++)
{
   if(map.get(nums[i])==null)
   {
   map.put(nums[i],1);
   }


   else
   {   map.put(nums[i],map.get(nums[i])+1);
   }
}
for(Integer i:map.keySet())
{
    int frequecy=map.get(i);
    if(queue.size()<k)
    {
        queue.add(i);
    }
    
    else 
    {
        int currentMinQ=map.get(queue.peek());
      if(frequecy>currentMinQ)
      {
          queue.poll();
          queue.add(i);
      }
    }
    
}
while (!queue.isEmpty())
{
    arrayList.add(queue.poll());
}
return arrayList;
    }
}
 

    别整那么复杂的，用 一个 HashMap，存 值和频率 就好了，在新建优先队列时，构造方法中传入 Comparator ，比较规则是只比较频率，入队时入的是数值。这就是典型的 TOP k问题，如果求 前k大，比如这道题，就用小顶堆（即每次都让最小值出队，这样当前新的值与队中最小值比较，如果比最小值大，就要替换掉它。）覆写 compare 方法时，==返回 o1-o2 ==，即实现的是 小顶堆。

(有时间研究一下优先队列。)