[Javaの] 9とソートアルゴリズムの概要を実装

1.直接挿入ソート

考え：各パスが重要な要素として、ローになり、そのキーに挿入される大きさに応じされた部分配列のソート挿入が完了するまでに行わ。

実装：

     静的ボイドinsertSort公衆（ARR INT []）{ 
		ため（INT I = 1; Iは<arr.length; Iは++）{//第二の補間値から始まる
			整数値=のARR [i]は、 // 要素が挿入されます
			POST =私はint型、
			一方（POST> 0 && ARR [-POST 1]>値）{ 
				ARR [POST]は= ARR [-POST 1。]; 
				POST - ; 
			} 
			ARR [POST] =値; //挿入見つけます位置
		} 
	}

2.バブルソート

アイデア：交換を完了するための一連のアクション。

最初のパス：後者よりも前者の第2の比較との最初の要素、Ruoguo、二つのスイッチング位置、ペアワイズ比較、最終要素に対する最大位置まで。

第二のパス：第二要素との最初の比較は、N-1と比較されています

実装：

基本バブルソート// 
	パブリック静的ボイドbubbleSort1（[] ARR、INT nのINT）{ 
		Iは、J int型、
		ため（I = N-1、I> 0; I - ）{//外部ループコンパレータN -1回：第二の位置への最後の決定された値の最後の位置に値を決定する
			（; J <J = 0に対して I、J ++）{// 内部ループ
				IF（ARR [J] > ARR [J + 1]）{ 
					int型ARRのTEMP = [J + 1]; 
					ARR [J + 1] = ARR [J]; 
					ARR [J] = TEMP; 
				} 
			} 
		} 
	}

  //バージョン改善バブルソート
	パブリック静的ボイドbubbleSort2（INT [] ARR、N-INT）{ 
		、JをI int型; 
		ための（I = N - 1; I> 0; I - ）{ 
			フラグ= 0のint; 
			のため（ J = 0; J <I、J ++）{ 
				IF（ARR [J]> ARR [J + 1]）{ 
					int型のTEMP = ARR [J + 1]; 
					ARR [J + 1] = ARR [J]; 
					ARR [ J] = TEMP; 
					フラグに= 1;交換が発生した場合//、次いで標識をさせる1。
				  } 
				} 
		      IF（フラグに== 0）     
		       {リターン;}   
		} 
	}

3.ソート

考えました：

選択もソート交換一種であり、バブルソート、特定の類似性が改善バブリング考えることができました。
    最大値または最小値に見出される1ソートされていない配列、開始位置に照合順序
    2.カラムの終わりに分類未分類の残りの要素から最大値（より小さい）素子、を探し続けます。
    すべての要素がソートされるまで、3を繰り返しステップ。

実装：

SelectSortクラス{パブリック
        //増分配列ので、
	パブリック静的ボイドSelectSort（INT [] ARR、N-INT）{   
		int型のTEMP、分= 0; 
		IF（（ARR == NULL）||（arr.length == 0））
	        リターン; 
	    のための（INT I = 0、I <N - 、I ++）{ 
	        分= I; //最小データアレイ添字不規則領域
	                            //最小サイクル検索
	        （int型J = I + 1 、J <N; jは++ ）{//最小ランダム領域に格納されたデータとその配列のインデックスを見つける
	            IF（ARR [分]> ARR [J]）{ 
	                分= J; 
	            } 
	        } 
	        ！IF（MIN = I）{ 
	            TEMPのARR = [I ]; 
	            ARR [I] = ARR [分]; 
	            ARR [分] = TEMP; 
	        } 
	    } 
	}	 
}

4.クイックソート

考えました：

1.最初の要素と、配列の最後の要素への2つのポインタのポイントを定義します。

それが基準を超えるに遭遇するまで、後方正面からトランスデューサの走査方向と、それが基準値を、二つのポインタの交換値未満に遭遇するまで、第1、往走査から第1基準要素を渡す2.値、二つのポインタの交換価値。
頭部および尾部は、2つの一致し、基準値へのポインタをポインタするとき、その値と参照点は交換可能にします。

3.前部および後部、それぞれ、再帰的な高速放電の。

実装：

パブリッククラスクイックソート{ 
	パブリック静的ボイドquickSort3（INT [] ARR、INT低い、INT高い）{ 
		IF（低い>ハイ）{ 
		   リターン。
		} 
		int型I、J、一時; 
		I =低いです。
		J =高いです。
		一時=のARR [低]。
		一方、{（I = J！）
			（iは<jの&&温度<= ARR [J]）しながら{j--;} 
			  もし（I <jの）{ 
			  ARR [I] =のARR [J]。
			   I ++; 
			  } 
			
		    （iは<jで&& TEMP> = ARR [i]）としながら、{iは++;} 
			（iは<jの）場合{ 
			 [J] =のARR ARR [I]。
			 j--; 
			} 
		 } 
		[I] = TEMP ARR。
		クイックソート（ARR、低、I-1）。
		クイックソート（ARR、iは高く、1 +）。
	} 
}

5.マージソート

長さ1の配列に分割統治、再帰的配列、次いで順序付けられた配列に結合、順序付けられたアレイに2つの順序付けられた配列を：思いました。

実装：

パブリッククラスMerge_Sort { 
	パブリック静的ボイドソート{（INT [] Aは、左INT、右INT）
        ; MID =（左+右）/ 2 int型   
        IF（左<右）{ 
            ソート（A、MID左）、
            ソート（ 、ミッド+ 1、右） ; 
            について//マージ
            マージ（左、MID、右）; 
        } 
    } 
	//注文注文した二つのうちの一つに入れ
	パブリック静的ボイドマージ（INT [] ARRを、 Lはint、int型のMは、Rはint）{ 
		INT []新しい新しいTEMP = [L-R＆LT + 1] int型、
		int型I = L; 
		int型M = J + 1; 
		INTはK = 0; 
		// 2つの小さな置きます新しいアレイに添加
		しながら（I <= M && J <= R＆LT）{ 
			IF（ARR [I] <ARR [J]）
				TEMP [K ++] = ARR [I ++]; 
			他の
				TEMP [K ++] = ARR [J ++]。
		} 
		//新しい配列の残りの部分の左側に番号を追加
		一方、（I <= M）{ 
			TEMP [K ++] = ARR [I ++]; 
		} 
		にアレイの残りの右側の番号を追加// 
		一方（J <= R＆LT）{ 
			TEMP [K ++] = ARR [J ++]; 
		} 
		//元の配列に新しいアレイに割り当てられた番号
		のための（INT X = 0; X <temp.length; X ++）{ 
			ARR [L + X] = TEMP [X]; 
			//System.out.print(arr [L + X] + ""）; 
		}     
	} 
}

6.ヒープソート

例えば、ヒープのトップに:(素晴らしいアイデア）

ヒープ調整（heapify） ：親ノードの最大値、Ruoguoない、交換、及び再帰ノード交換調整後。ヒープ要素保証最大のトップへ。

内蔵ヒープ：最後の非リーフノードから上方調整を行います。

ヒープ（降順）：最大位置を確保する大きなトップスタックのルートと最後のスイッチングノード、最後のノード。交換は、ヒープを行っていなかったので、それを行う必要性が再びルートノードからheapifyので。

第二のパス、各ノード現在のノードと最後の交換の現在位置、.....逐次

実装：

Heap_Bigクラス{パブリック
	//バイトおよび大型のスタックの各最上位ノードの左右の点にそれ自身を確立する
	パブリック静的ボイドheapify {（INT []ツリー、N-INT、IをINT）
		IF（I> = N-）
			のリターン; 
		INT C1 = 2 * I + 1; 
		INT C2 = 2 * I + 2、
		INT最大= I; 
		IF（C1 <N - &&ツリー[最大] <ツリー[C1]）
			最大= C1;	 
		IF（N C2 < - &&ツリー[マックス<ツリー[C2]）
			最大= C2; 
		IF（MAX = I）{！
			スワップ（木、MAX、I）; 
			heapify（木、N-、MAX）; //再帰大きなスイッチングノード終了後のトップペアを確立しますヒープ
		} 
	} 

	プライベート静的ボイドスワップ（INT []ツリー、IはINT、INT J）{ 
		int型ツリーTEMP = [I]は、
		ツリー[I] =ツリー[J]; 
		ツリー[J] = TEMP; 
	} 
	
	//のグループヒープ上の多数の確立 
	パブリック静的ボイドbuild_heap （INT []木、int型N ）{ 
		INT 1-N-last_nodeを=; 
		int型の親=（-last_node 1）/ 2; 
		（; I> = 0; I =親int型I - ）のために{ 
			heapify （木、N-、I）; 
		} 
	} 
	
	//ヒープソート：ルートとトップの大きなヒープ最後のスイッチングノード、最大位置を確保する最後のノードは、
	//交換ので、完全なスタックではないのでルートノードから再び我々は、スイッチングノードと最後電流,.の現在位置上の各ノード、第二の通過heapifyを行う必要があり
	、パブリック静的ボイドheap_sort（INT []ツリー、N-INT）{ 
		; build_heap（木、N-）
		（INT用= 1-N-I; I> = 0; I - ）{ 
			スワップ（木、I、0）; 
			heapify（木、I、0）; 
		} 
	} 
        パブリック静的無効メイン（文字列[] args）{ 
		INT [] } = {4,10,5,3,1,2配列; 
		intは= Array.lengthとn型である; 
		heapify（アレイ、N-、0）; 
		のSystem.out.println（ "heapifyプロセス："）。
		以下のために（; iがn <; I = 0 int型私は++）{ 
			System.out.print（配列[I] +」「）。 
		}

		System.out.println（）; 
		build_heap（アレイ、N）。
		System.out.println（ "建堆的过程："）; 
		以下のために（; iがn <; I = 0 int型私は++）{ 
			System.out.print（配列[I] +」「）。
		} 
		
		のSystem.out.println（）; 
		heap_sort（アレイ、N）。
		System.out.println（ "堆排序的结果"）; 
		以下のために（; iがn <; I = 0 int型私は++）{ 
			System.out.print（配列[I] +」「）。
		} 
	} 
}

//小顶堆
パブリッククラスHeap_Small { 
        //小顶堆调整的过程   
	パブリック静的ボイドheapify2（INT []木、int型のn、iはINT）{ 
		IF（I> = n）の
		 リターン; 
		int型C1 = 2 * I 1。
		INT、C2 = 2 * I + 2。
		int型の分= I; 
		IF（C1 <N &&ツリー[C1] <ツリー[分]）
			分= C1。
		IF（C2 <N &&ツリー[C2] <ツリー[分]）
			分= C2。
		IF（！分= I）{ 
			スワップ（木、分、I）。
			heapify2（木、N、分）。
		} 
	} 
	
	プライベート静的ボイドスワップ（INT []木、int型I、int型のJ）{ 
		int型のTEMP =ツリー[I]。
		ツリー[I] =木[J]。
		ツリー[J] = TEMP; 
	} 
        //从一组数中建小顶堆
	パブリック静的ボイドbuild_heap2（INT []木、INT n）が{堆
		INT lastnode = N-1; 
		intは= PAR（-lastnode 1）/ 2; //非リーフノードの最後の調整から開始
		（; I> = 0; I = PARをint型I - ）のために{ 
			heapify2（木、N- 、I）; 
		} 
	} 
	
	パブリック静的ボイドheap_sort_small（INT []ツリー、N-INT）{ 
		build_heap2（木、N-）; 
		//交換スタックの上部と現在のスタックの最後の要素、最小位置におけるその最後の要素を確実にするために、結果はそうheapifyことが、小さな山の頂上の後に交換されていないので
		第//パス、スタックの最上位要素と現在の最後の要素を交換し、heapify 
		。（INTのための1-N- = I; I> = 0; I- - ）{ 
			スワップ（木、0、I）; 
			heapify2（木、I、0）; 
		} 
	} 

       //トップ小さな挿入スタック
       パブリック静的ボイドheapInsertを（[]木、N-INT、INT NUMをINT）{ 
		私は、int型J; 
		I = N; J =（N - 1）/ 2; 
		一方（J> = 0 && I！= 0）{ 
			IF（ツリー[J] <= NUM）
				BREAK; 
			ツリー[I] =ツリー[J] ;
			J = I; 
		INT [] = {10、30、20は、100配列2、40、50,14}。 
			J =（1-I）/ 2; 
		}
		;木は、[I]はNUM = 
	} 

        //テスト
        {公共の静的な無効メイン（文字列[] args）を
		INT []配列10,4,5,3,1,2 = {}; 
		intは= Array.lengthとn型である; 
		build_heap2を（アレイ、N-）; 
		// heapify2（アレイ、N-、0）; 
		のSystem.out.println（ "スタックの構築プロセス："）; //スタックが構築されている：2. 3. 1. 5 10 4 
		のために（INT I = 0、I <N - 、Iは++）{ 
			System.out.print（配列[I] + ""）の; 
		} 
		
		のSystem.out.println（）; 

		heap_sort_small（アレイ、N-）; 
		// heapify2（アレイ、N-、0） ; 
		のSystem.out.printlnは（ "ヒープソート結果が"）; //スタックが構築されます。2. 3. 1. 5 10 4 
		のために（INT I = 0、I <N - 、Iは++）{ 
			System.out.printの（配列[I] + ""）; 
		} 
		のSystem.out.println（）; 

		heapInsert（array2,6,14）。
		System.out.println（ "スタックの上部は少数に挿入される"）; //スタックが構築されている：2. 3. 1. 5 10 4 
		（I = 0 int型; Iはarray2.lengthを<; Iは++）{ため
			のSystem.outを.PRINT（配列2 [I] + ""）; 
		} 
	} 
}

7.シェルソート

考えました：

1.シェルソート挿入ソートを改善することです。

2.各挿入ソートのために、最初のグループ（パケットロジック）、各チームの複数に大きなデータセット。

実装：

{クラスシェルソート公共
	のpublic static無効メイン（文字列[] args）{ 
		INT [] = {3,5,2,7,4,8,3,9} ARR、
		シェルソート（ARR）; 
		（I int型= 0。 I <arr.length; {I ++）
			; System.out.print（ARR [I]は+ ""）の
		} 
	} 
	パブリック静的ボイドシェルソート（INT [] ARR）{ 
		INT = N-arr.length; 
		//パケットの先頭にアレイの半分の長さの増分
		のために（INT N-GAP = / 2; GAP> 0; GAP / = 2）{ 
			//パケットが挿入される
			ため（I = GAPをint型; Iは、N <; Iは++）{ 
				// ARR [I]は正しい位置に
				挿入（ARR、GAP、I）; 
			} 
		} 
	} 
	
	プライベート静的ボイド挿入{（INT [] ARR、int型のGAP、I INT）
		; = ARR [I] int値を
		INT J; 
		} 
		ARR [J GAP +] =値。 
		のために（ J =ギャップ; J> = 0 &&値<ARR [J]; J- =ギャップ）{
			ARR [J +ギャップ] = ARR [J]。
	} 
}

8.基数ソート

9.バケットソート

[Javaの] 9とソートアルゴリズムの概要を実装

おすすめ