查找前K大之O(N)算法，千万中找前1000数据不到300毫秒。

 随便写的，速度可能不是最优，但是已经是O(n)了。实际使用时候可能受其他设备和程序输出速度限制，这里是模拟的数据。

思路是保持前K大有序，然后插入时候判断，非大不插，并且插入的时候是二分查找位置，弹出最后一个。

以后有空再研究下最大堆的插入和维持，这个先放这里放着吧。因为N*(LogK+C)还是常数*N，所以认为复杂度依然是O(N).

  
    

   
     using
   
      System;

   
     using
   
      System.Collections.Generic;

   
     using
   
      System.Linq;

   
     using
   
      System.Text;

   
     using
   
      System.Diagnostics;

   
     namespace
   
      ConsoleApplication5
{
 
   
     class
   
      Program
 {

 
   
     static
   
      
   
     void
   
      Main(
   
     string
   
     [] args)
 {
 MaxHeap
   
     <
   
     KV
   
     >
   
      myKV 
   
     =
   
      
   
     new
   
      MaxHeap
   
     <
   
     KV
   
     >
   
     (
   
     1000
   
     );
 Random Rand 
   
     =
   
      
   
     new
   
      Random();
 Stopwatch sw 
   
     =
   
      
   
     new
   
      Stopwatch();
 sw.Start();
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      
   
     1000
   
     *
   
     1000
   
     ; i
   
     ++
   
     )
 {
 KV iterm 
   
     =
   
      
   
     new
   
      KV(i.ToString(), Rand.Next(
   
     1000
   
     ));
 
   
     //
   
     Console.WriteLine("第" + (i + 1) + "次插入：“" + iterm.Key + "”," + iterm.Value);
   
     

   
      myKV.Insert(iterm); 
 }
 sw.Stop();
 
   
     //
   
     Show(myKV);
   
     

   
      Console.WriteLine(sw.ElapsedMilliseconds);
 Console.Read();
 }
 
   
     static
   
      
   
     void
   
      Show(MaxHeap
   
     <
   
     KV
   
     >
   
      heap)
 {
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      
   
     0
   
     ; i 
   
     <
   
      heap.Heap.Length; i
   
     ++
   
     )
 {
 KV iterm 
   
     =
   
      heap.Heap[i];
 
   
     string
   
      result 
   
     =
   
      (iterm 
   
     ==
   
      
   
     null
   
     ) 
   
     ?
   
      
   
     "
   
     Null
   
     "
   
      : 
   
     "
   
     \"
   
     "
   
      
   
     +
   
      iterm.Key 
   
     +
   
      
   
     "
   
     \",
   
     "
   
      
   
     +
   
      iterm.Value;
 Console.WriteLine(result);
 }
 Console.WriteLine(
   
     "
   
     长度：
   
     "
   
      
   
     +
   
      heap.Count 
   
     +
   
      
   
     "
   
     -------------------------------
   
     "
   
     );
 }

 
   
     public
   
      
   
     class
   
      KV : IComparable
   
     <
   
     KV
   
     >
   
     
 {
 
   
     public
   
      
   
     string
   
      Key;
 
   
     public
   
      
   
     int
   
      Value;
 
   
     public
   
      KV(
   
     string
   
      key, 
   
     int
   
      value)
 {
 Key 
   
     =
   
      key;
 Value 
   
     =
   
      value;
 }
 
   
     public
   
      
   
     int
   
      CompareTo(KV x)
 {
 
   
     if
   
      (x 
   
     ==
   
      
   
     null
   
     )
 {
 
   
     return
   
      
   
     1
   
     ;
 }
 
   
     if
   
      (
   
     this
   
     .Value 
   
     ==
   
      x.Value)
 {
 
   
     return
   
      
   
     this
   
     .Key.CompareTo(x.Key);
 }
 
   
     else
   
     
 {
 
   
     return
   
      
   
     this
   
     .Value.CompareTo(x.Value);
 }
 }
 }
 
   
     public
   
      
   
     class
   
      MaxHeap
   
     <
   
     T
   
     >
   
      
   
     where
   
      T : IComparable
   
     <
   
     T
   
     >
   
     
 {
 
   
     private
   
      
   
     int
   
      heapSize 
   
     =
   
      
   
     0
   
     ;
 
   
     public
   
      T[] Heap;
 
   
     public
   
      
   
     int
   
      Count 
   
     =
   
      
   
     0
   
     ;
 
   
     public
   
      MaxHeap(
   
     int
   
      size)
 {
 heapSize 
   
     =
   
      size;
 Heap 
   
     =
   
      
   
     new
   
      T[size];
 }
 
   
     public
   
      
   
     void
   
      Insert(T iterm)
 {
 
   
     if
   
      (iterm.CompareTo(Heap[heapSize 
   
     -
   
      
   
     1
   
     ]) 
   
     >
   
      
   
     0
   
     )
 {
 Insert(iterm, 
   
     0
   
     , (Heap.Length 
   
     -
   
      
   
     1
   
     ) 
   
     /
   
      
   
     2
   
     , Heap.Length 
   
     -
   
      
   
     1
   
     );
 }
 Count
   
     ++
   
     ;
 }

 
   
     private
   
      
   
     void
   
      Insert(T iterm, 
   
     int
   
      min, 
   
     int
   
      pos, 
   
     int
   
      max)
 {
 
   
     if
   
      ((iterm.CompareTo(Heap[pos]) 
   
     <=
   
      
   
     0
   
      
   
     &&
   
      iterm.CompareTo(Heap[pos 
   
     +
   
      
   
     1
   
     ]) 
   
     >=
   
      
   
     0
   
     ) 
   
     ||
   
      pos 
   
     ==
   
      
   
     0
   
     )
 {
 
   
     for
   
      (
   
     int
   
      i 
   
     =
   
      heapSize 
   
     -
   
      
   
     1
   
     ; i 
   
     >
   
      pos; i
   
     --
   
     )
 {
 Heap[i] 
   
     =
   
      Heap[i 
   
     -
   
      
   
     1
   
     ];
 }
 
   
     if
   
      (pos 
   
     ==
   
      
   
     0
   
     )
 {
 Heap[pos] 
   
     =
   
      iterm;
 }
 
   
     else
   
     
 {
 Heap[pos 
   
     +
   
      
   
     1
   
     ] 
   
     =
   
      iterm;
 }
 }
 
   
     else
   
     
 {
 
   
     if
   
      (iterm.CompareTo(Heap[pos]) 
   
     >
   
      
   
     0
   
     )
 {
 max 
   
     =
   
      pos;
 }
 
   
     else
   
     
 {
 min 
   
     =
   
      pos;
 }
 pos 
   
     =
   
      Convert.ToInt32((max 
   
     +
   
      min) 
   
     /
   
      
   
     2
   
     );
 Insert(iterm, min, pos, max);

 }
 }


 }

 }

}