ディレクトリ
まず、挿入ソート
1、直接挿入ソート
第一種の第一の部分が完了し、その後、挿入、二つの部分に分割するソート配列、（挿入される要素を除く）配列のすべての要素、他の部分は、要素を挿入すること：考えアルゴリズムであります要素第1の部分はによって実行二つの部分に再分割である。ソート。
ここでデフォルトARR [0]の配列部分、ARR [J] = ARR [J - 1]排出され、数が後方から前方へトラバースの数よりも小さい場合には、後方に移動し、その後、ソートされる電流を表します[J] = TEMPをARR、挿入位置に対応する値を表しています。
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int gap = 1,i,j;
int temp;
int len = arr.length;
for(i = 1;i < len;i++){
temp = arr[i];
for(j = i;j >= 1&&arr[j - 1] > temp;j -= 1){
arr[j] = arr[j - 1];
}
arr[j] = temp;
}| 平均時間の複雑さ |
ベストケース |
最悪の場合 |
宇宙複雑 |
| O（n²） |
O（N） |
O（n²） |
O（1） |
2、ヒルソート
バイナリ各ギャップは、その後減少し、上述の動作サイクル;その後、各グループの要素は、ソートの直接挿入ソートの方法を用いて、以下の工程におけるソートパケットギャップなるように配列ギャップ= 1、直接挿入を使用して、完全なソート。）
実際に、直接挿入ソートステップが示さヒル選別工程は、ギャップになった2つの値1を比較することです。これは、直接挿入ソートの最適化です。
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int gap = 1,i,j;
int temp;
int len = arr.length;
while(gap < len /3){
gap = gap * 3 + 1;
}
for(;gap > 0; gap /= 3){
for(i = gap ; i < len;i++){
temp = arr[i];
for(j = i;j >= gap && arr[j - gap]> temp;j -= gap){
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
| 平均時間の複雑さ |
ベストケース |
最悪の場合 |
宇宙複雑 |
| O（nlog2 N） |
O（nlog2 N） |
O（nlog2 N） |
O（1） |
第二に、選択ソート
1、簡単な選択ソート
このアルゴリズムは比較的単純で、最も小さい値を毎回見つけ、その後、彼の前の最初の添え字1,2 ..... arr.length-1交換を保存することです。
int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
for(int i = 0;i < arr.length - 1;i++){
int min = i;
for(int j = i + 1;j < arr.length;j++){
if(arr[j] < arr[i]){
min = j;
}
}
if(min != i){
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}| O（n²） |
O（n²） |
O（n²） |
O（1） |
2、ヒープソート
トップは大きなヒープで山にすべての最初の配列の最初の。そして、それぞれが大きなトップ杭先頭の要素を取って横断、再びheapify。完全なシーケンシング。
public static void main(String[] args) {
// int[] arr = {1,4,2,8,74,12,9,30,8,11,22,87,12,44,28};
int[] arr = {2,5,3,1,10,4};
heap_sort(arr,arr.length);
for(int k = 0;k < arr.length;k++){
System.out.print(arr[k] + " ");
}
}
//通过堆排序，输出
public static void heap_sort(int[] arr,int len){
build_heapify(arr,len);
for(int i = len - 1;i >= 0; i--){
swap(arr,i,0);
heapify(arr,i,0);
}
}
//构建整个堆，每一个堆节点
public static void build_heapify(int[] arr,int len){
int last_node_index = len - 1;
int parent_index = (last_node_index - 1) / 2;
for(int i = parent_index;i >= 0;i--){
heapify(arr,len,i);
}
}
//对单个堆进行排序
public static void heapify(int []arr,int len,int i){
if(i >= len)
return ;
int left = i * 2 + 1;
int right = i * 2 + 2;
int max = i;
if(left < len && arr[max] < arr[left])
max = left;
if(right < len &&arr[max] < arr[right])
max = right;
if(max != i){
swap(arr,max,i);
heapify(arr,len,max);
}
}
public static void swap(int[] arr,int x,int y){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}| 平均時間の複雑さ |
ベストケース |
最悪の場合 |
宇宙複雑 |
| O（nlog2n） |
O（nlog2n） |
O（nlog2n） |
O（1） |
第三に、交換ソート
1、バブルソート
このアルゴリズムは、最後の位置にバブリング比較的単純な、直接の最大値です。
for(int i = arr.length;i >= 0;i--){
for(int j = 0;j < i&& j + 1 < i;j++){
if (arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}| 平均時間の複雑さ |
ベストケース |
最悪の場合 |
宇宙複雑 |
| O（n²） |
O（N） |
O（n²） |
O（1） |
2、クイックソート
クイックソートバブルソートこのアイデアの最適化をすることです：基準値を選択し、基準値の左側には、その右側にその値より大きい未満です。
public static void quick_sort(int[] arr ,int low,int high){
if(arr.length < 0 || low > high)
return ;
int left = low;
int right = high;
//保存基准值
int temp = arr[left];
while(left < right){
//从后向前找到比基准小的元素
while(left < right && arr[right] >= temp){
right--;
}
arr[left] = arr[right];
//从前往后找到比基准大的元素
while(left < right && arr[left] <= temp){
left++;
}
arr[right] = arr[left];
}
arr[left] = temp;
quick_sort(arr,low,left - 1);
quick_sort(arr,left + 1,high);
}| O（nlog₂n） |
O（nlog₂n） |
O（n²） |
（再帰バージョンを区画する代わりに）O（1） |
第四に、マージソート
思想：
。①隣り合うシーケンス番号は、操作、床（N / 2）配列、2つのソート要素を含む各シーケンスをマージします。
。②上記のシーケンスが再び形成するためにマージ（N / 4）床配列は、4つの要素を含む各配列。
③。繰り返しステップは②、すべての要素がソートされるまで。
public static int[] mergingSort(int[] arr){
if(arr.length <= 1)
return arr;
int num = arr.length >> 1;
int[] arrLeft = Arrays.copyOfRange(arr,0,num);
int[] arrRight = Arrays.copyOfRange(arr,num,arr.length);
return mergeTwoArray(mergingSort(arrLeft),mergingSort(arrRight));
}
public static int[] mergeTwoArray(int[] arr1,int[] arr2){
int[] result = new int[arr1.length + arr2.length];
int i = 0,j = 0, k = 0;
while(i < arr1.length && j < arr2.length){
if(arr1[i] < arr2[j]){
result[k++] = arr1[i++];
}else{
result[k++] = arr2[j++];
}
}
while(i < arr1.length){
result[k++] = arr1[i++];
}
while(j < arr2.length){
result[k++] = arr2[j++];
}
return result;
}第五に、基数ソート
思考のバケットソートの使用
public static void radixSort(int[] arrays){
int max = findMax(arrays);
//遍历位数
for(int i = 1;max / i > 0;i *= 10){
int[][] buckets = new int[arrays.length][10];
//获取每一位数字(个、十、百、千位...分配到桶子里)
for(int j = 0;j < arrays.length;j++){
int num = (arrays[j] / i) % 10;
//将其放入桶子里
buckets[j][num] = arrays[j];
}
//回收桶子里的元素
int k = 0;
for(int j = 0;j < 10;j++){
for(int y = 0;y < arrays.length;y++){
if(buckets[y][j]!=0){
arrays[k++] = buckets[y][j];
}
}
}
}
}
public static int findMax(int[] arrays){
int max = 0;
for(int i = 0;i < arrays.length;i++){
if(arrays[i] > max){
max =arrays[i];
}
}
return max;
}
