ヒープ関連のトピックは-python

スタック＆ヒープキュー＆ハッシュテーブル＆-python https://blog.csdn.net/qq_19446965/article/details/102982047

1、醜いIIの数

n番目の醜い番号を検索するプログラムを書きます。

醜いは、素因数の数だけ2、3、5の正の整数で含有します。

例：

入力：N = 10
出力：12
説明：1、2、3、4、5、6、8、9、10、12はフロント数醜い10です。
説明：

図1は、醜いの数です。
n個以上1690以下ではありません。

出典：滞在ボタン（LeetCode）
リンクします。https：//leetcode-cn.com/problems/ugly-number-ii

まずリコール「醜い番号I」

与えられた数は醜いの数であるかどうかを判断するためのプログラムを書きます。

https://leetcode-cn.com/problems/ugly-number-ii/

クラスのソリューション（オブジェクト）：
    デフisUgly（自己、NUM）：
        "" " 
        ：タイプNUM：INT 
        ：RTYPE：ブール
        """ 
        もしNUM <= 0：
            リターン偽
        NUM == 1の場合：
            trueを返します   
          
        NUM中> = 2そしてNUM％2 == 0：
            NUM / = 2 
        一方NUM> = 3とNUM％3 == 0：
            NUM / = 3 
        一方NUM> = 5とNUM％5 == 0：
            NUM / = 5 
          
        戻りNUM == 1

少し醜いII反対数

クラス溶液（オブジェクト）：
    DEF nthUglyNumber（自己、N）：
        "" " 
        ：タイプN：INT 
        ：RTYPE：INT 
        """ 
        インポートheapq 
        ヒープ= [1] 
        訪問=セット（[1]）
        
        NUM =なし
        でiについてレンジ（N）：
            NUM = heapq.heappop（ヒープ）
            における因子[2、3、5]：
                もしNUM *要因ではない訪問中：
                    visited.add（NUM *因子）
                    heapq.heappush（ヒープ、NUM *因子）
            
        num戻り

2、トップkの最大数

例：最大数k（3 <K <N）を選択されたn番目の値が最小アルゴリズムの複雑さ（O（N））であります

1.最も簡単な方法： Kの前にソートされたN個の順序付けられた数は、数kの最大数であり、このアルゴリズムの複雑さはO（nlogn）

2.O（N）方法：

溶液1：使用patitionがランダム要素Xを見つけるために、配列Sから高速行を考え、アレイを2つの部分SaとSbの分割されています。SAは、以上の元素、XはSbの要素は、以下X.よりそして、2つのケースがあります。

サ| |要素の1 Saの数は、最初のK-SbのK未満である多数のk番目の要素です。

エレメント以上kの2 Saの数は、SAのk番目の多数が返されます。おおよその時間複雑性O（n）が、しかし、最悪の場合のOの複雑さ（N ^ 2）。

溶液2：配列番号格納されたハッシュSiの使用は、大きな数字と比較して、線形走査プロセス、K-K-1の前の数を降順でソート思っ計数によって表示時間平均的なケースの複雑さO （N）

3.O（nlogk）方法：最小スタック要素よりヒープの最上部の数が大きい場合は、次に、kのヒープのために、我々は、入力整数nは番号を読み取るたびに最小サイズを作成しますその後、ヒープのトップを交換し、最小の調整を積み重ねます。

二つの方法の長所と短所：

ヒープソートは、大量のデータに適した、それはすべてのデータがメモリにロードされる必要がないことを、あなただけがその大きな利点の一つであるヒープメートルの頂上の小さなサイズを維持する必要があります。

高速放電方法は高速ですが、彼は、アレイ全体を維持する必要があるため、大量のデータの顔は、無力になります。

4..O（n）は第K少数BFPRTアルゴリズムを見つけ - warm3snow -ブログhttps://www.cnblogs.com/informatics/p/5092741.htmlパーク

主なアイデアは、迅速な選択アルゴリズムのためのユニットの選択方法を変更し、最悪の場合には、アルゴリズムの時間複雑性を改善することです。主な手順は次のとおりです。

まず、アレイグループとして数5に従って分類、最後の5未満では無視します。各グループ番号をソートする（例えば、挿入ソート）ビット数が取得されます。
中央値は、すべての最後のステップは、これらの再帰呼び出しBFPRTアルゴリズムの中央値は、その中央値を得るために、アレイの前面に移動しました。
一次分割素子が配列全体を分割するように、前のステップの中央値を用いました。
左、右、またはそれ自体が起こる結果と分割結果の数kの決意は、リターンキーを導く最初の二つの再帰的処理を分割することができます。

その予算法は、これだけの懸念は、実現されませんヒープ

クラスソリューション：
    DEF get_top_k（K、NUMS）：
        heapqインポート
        ヒープ= [] 
        ：NUMSにnumの
            heapq.heappush（ヒープ、NUM）
            lenの場合（ヒープ）> K：
                heapq.heappop（ヒープ）

        リターンソート（ヒープ、逆=真）

3、k個のマージソートリスト

Kマージソートリスト、およびリストを組み合わせソート戻ります。分析し、その複雑さを記述するようにしてください。

クラスListNode（オブジェクト）：

    デフ__init __（自己、ヴァル、次=なし）：
        self.val = valの
        self.next =次

方法の一つ：アルゴリズムのマージ

クラスソリューション：
    「」「
    @paramリスト：ListNodeのリスト
    @return：1つのソートされたリストの先頭
    『』」
    DEF mergeKLists（自己、リスト）：
        そうでない場合はリスト：
            戻りなし
        
        戻りself.merge_range_lists（リスト、0、 lenは（リスト） - 1）
        
    デフmerge_range_lists（自己、リスト、開始、終了）：
        スタート==終了の場合：
            戻りリスト[スタート] 
        
        半ば=（//）+エンドを開始2 
        =左self.merge_range_lists（リスト、開始、半ば）
        右=のself.merge_range_lists（リスト、ミッド+ 1、終了）
        リターンself.merge_two_lists（左、右）
        
    デフmerge_two_lists（自己、HEAD1、HEAD2）：
        テール=ダミー= ListNode（0）
        HEAD1とHEAD2しばらく：
            ：head1.val <head2.val場合
                tail.next = HEAD1 
                HEAD1 = head1.next 
            ：他に
                tail.next = HEAD2 
                HEAD2 = head2.next 
            尾= tail.next 
            
        場合HEAD1：
            tail.next = HEAD1 
        場合HEAD2：
            tail.next = HEAD2 
        
        戻りdummy.next

方法2：使用ヒープ

図1に示すように、全ての要素がスタックに追加され
、2、トラバーサル、削除最小接続します

heapqインポート
ListNode .__ lt__ラムダ= X、Y：（x.val <y.val）

クラスソリューション：
    "" " 
    @paramリスト：ListNodeのA一覧
    @return :.リストをソートするヘッドの一
    " "" 
    DEF mergeKLists（自己、リスト）：
        IFないリスト：
            戻りなし
        
        ダミー= ListNode（0）
        尾ダミー= 
        ヒープ= [] 
        リストでヘッド用：＃1、へのすべてのスタック要素。
            IFヘッド：
                heapq.heappush（ヒープ、ヘッド）
                
        ながら、ヒープ：＃2、トラバース、リムーブ接続最小
            ヘッド= heapq.heappop（ヒープ）
            tail.next =ヘッドを 
            尾=ヘッド
            もしhead.next：
                heapq.heappush（ヒープ、head.next）
                    
        リターンdummy.next

-------------------

参考：IXアルゴリズムは説明 https://www.jiuzhang.com/solution/