C#：TopK：1万个数取前最大的100，堆排序

1. 把1万个数字的前100个 首先放入数组，构成最小堆
2. 再循环100到一万之间的。 每次循环判断当前数字是否大于ary[0]
3. 当大于时，首先把头节点remove，再把当前数字放入ary[0]， 在那100个数之内进行最小堆排序
4. 当循环完循环100到一万后。 最大的前100个数字就出来了。

时间复杂度

第一次构建最小堆时，可以不堆排序，而是把最小值放入到头节点
例如：k为头100，n为1万
时间复杂度：O（k+n*logk） 空间复杂度：O（n）

堆排序

using System;
using System.Collections.Generic;
using System.Text;

namespace DataStructure
{
    
    
    public enum HeapType
    {
    
    
        MinHeap,
        MaxHeap
    }

    public class BinaryHeap<T> where T : IComparable<T>
    {
    
    
        public List<T> items;

        public HeapType HType {
    
     get; private set; }

        public T Root
        {
    
    
            get {
    
     return items[0]; }
        }

        public BinaryHeap(HeapType type)
        {
    
    
            items = new List<T>();
            this.HType = type;
        }

        public bool Contains(T data)
        {
    
    
            return items.Contains(data);
        }

        
        /// <summary>
        /// 插入尾部，再跟父节点冒泡排序
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
    
    
            items.Add(item); //先插入list的末尾

            int i = items.Count - 1;

            bool flag = HType == HeapType.MinHeap;

            while (i > 0)  //一直冒泡到头节点，当前节点的父节点idx为(i - 1) / 2
            {
    
    
                if ((items[i].CompareTo(items[(i - 1) / 2]) > 0) ^ flag) //异或，相同取0，相异取1；如果是子>父 异或 最小堆（true） == 0，不发生交换
                {
    
    
                    T temp = items[i];
                    items[i] = items[(i - 1) / 2];
                    items[(i - 1) / 2] = temp;
                    i = (i - 1) / 2;
                }
                else
                    break;
            }
        }

        /// <summary>
        /// 删除头节点
        /// </summary>
        private void DeleteRoot()
        {
    
    
            int i = items.Count - 1;

            items[0] = items[i]; //先把队尾部放入头节点
            items.RemoveAt(i);  //移除队尾

            i = 0;

            bool flag = HType == HeapType.MinHeap;

            while (true)
            {
    
    
                int leftInd = 2 * i + 1; //左节点
                int rightInd = 2 * i + 2;//右节点
                int largest = i;

                if (leftInd < items.Count)
                {
    
    
                    if ((items[leftInd].CompareTo(items[largest]) > 0) ^ flag) //（左 > 父） 异或（是否最小堆）
                        largest = leftInd;
                }

                if (rightInd < items.Count)
                {
    
    
                    if ((items[rightInd].CompareTo(items[largest]) > 0) ^ flag)
                        largest = rightInd;
                }

                if (largest != i) //发生交换，父与左或者右的一个
                {
    
    
                    T temp = items[largest];
                    items[largest] = items[i];
                    items[i] = temp;
                    i = largest;
                }
                else //未发生交换，说明排序OK
                    break;
            }
        }

        //弹出头节点
        public T PopRoot()
        {
    
    
            T result = items[0];

            DeleteRoot();

            return result;
        }

        public T GetRoot()
        {
    
    
            T result = items[0];
            return result;
        }
    }

}

TopK

public class TestTopK : MonoBehaviour
{
    
    
    const int m_count = 10;
    const int m_top = 5;
    List<int> m_listOri = new List<int>(m_count);
    // Start is called before the first frame update
    void Start()
    {
    
    
        DataInit();

        BinaryHeap<Node> minHeap = new BinaryHeap<Node>(HeapType.MinHeap);
        
        for (int i = 0; i < m_top; i++)
        {
    
    
            minHeap.Push(new Node(m_listOri[i]));
        }

        for (int i = m_top; i < m_count; i++)
        {
    
    
            int topNum = minHeap.GetRoot().value;

            if (m_listOri[i] > topNum) //这里不能>=，因为是最小堆，只有大于头节点才插入，除头节点外，子节点都是比头节点大
            {
    
    
                minHeap.PopRoot();
                minHeap.Push(new Node(m_listOri[i]));
            }
        }
       
        for (int i = m_top-1; i >= 0 ; i--)
        {
    
    
            Debug.Log(minHeap.items[i].value);
        }
    }

    void DataInit()
    {
    
    

        //for (int i = 0; i < m_count; i++)
        //{
    
    
        //    int num = UnityEngine.Random.Range(0, m_count);
        //    m_listOri.Add(num);
        //}

        int[] buf = new int[m_count] {
    
     5, 5, 1, 1, 9, 9, 2, 2, 3, 3 };
        m_listOri.AddRange(buf);
        
    }
}

测试输出

源码

https://github.com/luoyikun/UnityForTest
TestTopK场景