leetcode-215 - 配列K番目の最大の要素*

件名の説明：

方法の一つ：ヒープソート*

クラスソリューション：
     DEF findKthLargest（自己、NUMS：リスト[整数]、K：INT） - > INT：
         DEF adjust_heap（IDX、MAX_LEN）：
            左 = 2 * IDX + 1 
            右 = 2 * IDX + 2 
            max_loc = IDX
             場合に左<MAX_LEN と NUMS [max_loc] < NUMS [左]：
                max_loc = 左
             であれば右の<MAX_LEN と NUMS [max_loc] < NUMS [右]：
                max_loc = 右
             であれば！max_loc = IDX：
                NUMS [IDX]、NUMS [max_loc] =のNUMS [max_loc]、NUMS [IDX] 
                adjust_heap（max_loc、MAX_LEN）
        
        ＃1 建堆 
        N = LEN（NUMS）
         用 I における範囲（N //が2 - 1、-1、 - 1 ）：
            adjust_heap（I、N）
        ＃1 プリント（NUMS） 
        RES = なし
         用 I における範囲（1、K + 1 ）：
             ＃1 プリント（NUMS） 
            のRES =のNUMS [0] 
            NUMS [0]、NUMS [ -i] = NUMS [ - i]は、NUMS [0] 
            adjust_heap（0、N - I）
        リターン RES

 

方法2：クイックソート

クラスソリューション：
     DEF findKthLargest（自己、NUMS：リスト[整数]、K：INT） - > INT：
         デフパーティション（左、右）：
            ピボット = NUMS [左] 
            L =左+ 1 
            、R = 右
             一方、L <= R ：
                 もし NUMS [L] <ピボットと NUMS [R]> ピボット：
                    NUMS [L]、NUMS [R] = NUMS [R]、NUMS [L]
                 なら NUMS [L]> = ピボット：
                    L + = 1
                 であれば NUMS [R] <=ピボット：
                    R - = 1 
            NUMS [R]、NUMS [左] = NUMS [左]、NUMS [R]
             戻りR 
        左 = 0 
        、右 = LEN（NUMS） - 1
         ながら 1 ：
            IDX = パーティション（左、右）
             場合 IDX == K - 1 ：
                 戻りNUMS [IDX]
             場合は、 IDX <K - 1 ：
                左 = IDX + 1
             場合は、 IDX> K - 1 ：
                右 = IDX - 1

 

方法3：bfprtアルゴリズム*

クラスソリューション：
     DEF findKthLargest（セルフ、NUMS、K）：
        インデックス = self.BFPRT（NUMS、0、LEN（NUMS） - 1、LEN（NUMS） - K + 1。。 ）
         を返すNUMS [インデックス] 

    DEF BFPRT（セルフ、NUMSを、Lは、R、K）：
         IF L == R＆LT：
             リターンLの
        pivot_index = self.getPivotIndex（NUMS、L、R＆LT）
        divide_index = self.partion（NUMS、L、R＆LT、pivot_index）
        NUM = divide_index - 1 + Lの   ＃ピボットは、現在、いくつかの小さな電流範囲内にランクされて
        IF K == ：NUM
             戻りdivide_index
        ELIF NUM> K：
             戻り self.BFPRT（NUMS、L、divide_index - 1 、k）の
         他の：
             返す - self.BFPRT（NUMS、divide_index + 1、R、K NUM）を

    defでgetPivotIndex（自己、NUMS、L、R） ：
         もし（R - L <5 ）：
             戻りself.insertSort（NUMS、L、R）
        TMP = L
         のための I における範囲（L、R、5 ）：
             もし I + 4> R：
                 ブレーク・
            インデックス = self.insertSort（ NUMS、I、I + 4）  ＃各群の中央値索引取得 
            NUMS [TMP]、NUMS [索引する] NUMS [インデックス]は、NUMSは[TMP] =   ＃各グループの中央値は、アレイの左端に配置されている 
            TMP = TMP +。1つの戻り自己。 BFPRT（。。。NUMS、L、TMP - 1、（TMP - - 1 L）2 + // 1）  ＃は、これらの中央値の中央値取得DEF：insertSort（セルフ、NUMS、L、R＆LT）  ＃の挿入ソートを用 I における範囲（。。L + 1は、R + 1 ）：
            TMPは = NUMS [I] 
            J = I - 1。
             一方 J> = L と NUMS [J]> TMP：
                [J NUMS。+ 1] = NUMSを[J] 
                Jを - = 1
        

    
        
            NUMS [J + 1] = tmpに
         戻り（R + L）// 2    ＃返回的是索引

    DEF ：partion（自己、NUMS、L、R、pivot_index）
        NUMS [L]、NUMS [pivot_index] =のNUMS [pivot_index]を、NUMS [L]  ＃交换至左侧最 
        ピボット= NUMS [L] 
        I、J = L、R
         ながら iが< J：
             ながら、私はR < や NUMSを[i]を<= ピボット：
                I + = 1
             一方、 L <J そして NUMS [J]> = ピボット：
                J - = 1
            場合 iは< J：
                NUMS [i]は、NUMS [J] = NUMS [J]、NUMSを[I]は
        NUMS [J]、NUMS [L] = NUMS [L]、NUMS [J]
         戻り J