理解しやすい - ソートを選択

I.はじめに選択ソート

  1.定義:
    順序を選択し、要素で指定された規則に従って選択され、データをソートする、内部ソートに属し、その後交換後の所定位置の目的に従って分類
  :2の配列決定法
    [ARRから第1値が後者よりも大きい場合には、[1]の値に比べに0 ARR値配列]を取得し、レコードARR [1]と、インデックス値、最小値が検出されたサイクルの丸い端部、 ARR [0]と最小スイッチング位置、見つかった最小値を有している
    から2番目の[1] ARR [2]の値と比較し、値が後者よりも大きい場合、ARR ARRレコード配列の値[ 2]及び最小値が見つかったとき、インデックス値、サイクルの丸い端部は、次いで、ARR [0]と最小スイッチング位置、最小時間が発見された
    ...
    大、このような結果、小さな前方に配列決定しました後方に、大幅に発注サイクルを減らし
    、あなたはファインケミカルを見ます

II。コードの実装

  1 段階で達成

  2. 全体的に実現

III。時間計算

  選択ソート時間の複雑さはO(n)は、バブリングああよりも小規模な電力であるO(N-1)、です!

実装プロセス:

パッケージcom.zpb.selector。

輸入java.text.SimpleDateFormatの。
輸入java.util.Arrays。
輸入java.util.Date;


/ **
 * @Desセレクションソート                                  
 * @authorの
 5月29日の11時57分10秒* @date 2019インディアン10日の午後
 * 
 * / 
パブリック クラスSelectorSort {
    
    パブリック 静的 ボイドメイン(文字列[]引数){
        
        // 8万テストするランダムアレイを作成
        int型 ARR [] = 新しい新しい INT [80000 ;]
         のためにint型、I <80000は、I = 0 Iは++ ){
            ARR [I] =(INT)(Math.random()* 8000000 )。
        }
//       INT ARR [] = {} 101,34,119,1; "ソート前:"するSystem.out.println )。
        System.out.println(新しいてSimpleDateFormat( "YYYY-MM-DD HH:MM:SS")形式(。新しい日付()));
        selectorSort(ARR)。 
        System.out.println( "ソート後:" );
        System.out.println(新しいてSimpleDateFormat( "YYYY-MM-DD HH:MM:SS")形式(。新しい日付()));
//       するSystem.out.println(Arrays.toString(ARR));
        
    }
    
  
段階的に達成
  // ステップ実装ステップ
    プライベート 静的 ボイド selectorSortStep(INT ARR []){
        
        INT minIndex = 0; // 参照インデックス:最小インデックス
        INT分= ARR [0]; // 基準値:デフォルトARR [0]、すなわち、我々は基準として決定されることを、最も小さい値であります人は、基準値が誰であるか、最小の前記しました
        
        // ラウンド1並び替え:=========================================== ============== 
        ためINT J = 0 + 1、。J <arr.length; J ++){ // [101、34で、119 ,. 1] 
            IF(MIN> ARR [J ]){     // 後者の変化よりも大きい説明前回値、前方に戻っの値を作るために 
                分= ARR [J];     // 後者の値は、デフォルトの最小値に割り当てられ 
                minIndex = J;     // う後で参照インデックスに割り当てられた最小のインデックス
            }
        }
        // ソートが完了すると、minは最小値を見つけるだろう、minIndexは、最小インデックスです
         // [0]は、現在の最小値であるARRあれば、我々はまた、位置交換する必要がある 
        = [minIndex] ARRをARR [0];     // minIndexは最小屈折率であり、最小の位置である[minIndex] ARR、最小の位置を発見し、それが最小に[0]の位置をARRする必要があり、交換 
        ARRを[0] =分;             // 最小値はARRに割り当てられているので、1ラウンドの選別の完了後、minは最小値であり、基準値は、[0]
         // 1ラウンドソート見出さ1
 //         のSystem.out .println( "1ラウンドの順序は:" + Arrays.toStringの(ARR));     // [1、34は、119、101]
        
        
        // ラウンド2並び替え:=========================================== ==============
         // 選別の最初のラウンドで、我々が発見ARR [0]が最小の位置である、[1] ARR開始させ 
        minIndex = 1  =のARR [1 ]。
        INTの J = 1 + 1、J <arr.length; J ++){     // [1、34、119、101] 
            であれば(MIN> ARR [J]){     =のARR [J]。    
                minIndex = J;    
            }
        }
        ARR [minIndex] = ARRの[1];     // minIndex最小インデックス、ARR [minIndex】最小の位置は、最小の位置に[0] ARRすることが必要である、最小位置を発見されているです交換に 
        ARR [1] =分;             // 1ラウンドソートが完了した後、minは最小値であり、基準値は、従って、ARRする値minを割り当てられている[0]
         // の一種2、これ以上34以下以来大きなデータの背後にある、第一交換は2発生しないように
 //         するSystem.out.println( "第二ソートは2:" Arrays.toStringの+(ARR));     // [1、34、119、101です。]    
        
        // 最初の3並び替え:=========================================== ============== 
        minIndex = 2  = ARR [2 ;]
         のためのINT J = 2 + 1、。J <arr.length; J ++){ // [1、34、119、101である]     
            IF(MIN> ARR [J]){     // 前述の説明トランスデューサの前部に戻すの値を作るために、バックより大きい値 
                分= ARR [J];     // 後者の値は、デフォルトの最小に割り当てられ 
                minIndex = J;     // 後者最小限に割り当てられたインデックス参照インデックス
            }
        }
        ARR [minIndex] =のARR [2 ]。    
        ARR [ 2] = 分;            
 //       するSystem.out.println( "最初の三つの一種である" + Arrays.toString(ARR)の);     // [1、34であり、101119]    
        
    }
}

 全体的に実現

 // 全体の実現
 プライベート 静的 ボイド selectorSort(INT [] ARR){
        
        以下のためにint型 I = 0; I <-arr.length 1; I ++は){
             int型 minIndex = I;
             INT分= ARR [I]、
             のためにint型 J = I + 1、。J <arr.length; J ++ ){
                 IF(MIN> ARR [J]){     // バックより大きい説明前回値、トランスデューサの前面に背の値を作るために 
                    分= ARR [J];     // 後者の値は、デフォルトの最小に割り当てられ 
                    minIndex = J ;     // インデックスが最小参照インデックスの裏面に割り当てられています
                }
            }
            【minIndex] ARR =のARR [I]。
            ARR [I] = 分。
        }
    }

 

おすすめ

転載: www.cnblogs.com/MrRightZhao/p/11795059.html