One, O(n^2) sorting algorithm
1. Selection Sort
Find the smallest
public static void selectsort(int[] arr){
for (int i =0;i<arr.length ;i++){
for (int j =i;j<arr.length-1;j++){
if (arr[i] >arr[j+1]){
int temp = arr[i];
arr[i] =arr[j+1];
arr[j+1] = temp;
}
}
}
}
2. Bubble Sort
Find the largest
public static void bubblesort(int[] arr){
for (int i = 0 ;i < arr.length ;i++){
for (int j = 0;j < arr.length - 1-i;j++){
if (arr[j] > arr[j +1]){
int temp = arr[j +1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
3. Insertion Sort
By index position, traverse from front to back, compare the element with the element before it, and swap the smaller with it
Inner loop can be terminated early compared to selection sort
public static void insersort(int[] arr){
for (int i = 1;i < arr.length;i++){
for (int j = i ;j > 0;j --){
if (arr[j] < arr[j - 1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}else {
break;
}
}
}
}
Improved Insertion Sort,
public static void insertsort2(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int temp = arr[i];
int j;
for (j = i; j > 0 && temp < arr[j-1]; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
Insertion sort works well for neatly sorted arrays and is faster than selection sort
4. Hill sorting Donald Shell shrinking incremental sorting O(n 3/2 )
public static void shellsort(int[] arr){
int n = arr.length;
int gap,i,j,temp;
for (gap = n/2 ;gap >0 ;gap= gap/2){
for(i = gap; i < n; i++)
for(j = i-gap; j>=0 && arr[j]>arr[j+gap]; j -= gap)
{
temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
Second, the sorting algorithm of O(nlog n)
1. Merge Sort
(1) recursion
public static void mergesort(int[] arr){
mergeS(arr,0,arr.length-1);
}
public static void mergeS(int[] arr,int l,int r){
if (l >= r)
return;
int mid = (l + r)/2;
mergeS(arr,l,mid);
mergeS(arr,mid + 1,r);
if (arr[mid] > arr[mid+1]){
merge(arr,l,mid,r);
}
}
//Merge the two parts of arr[l,mid] and arr[mid+1, r]
private static void merge(int[] arr, int l, int mid, int r) {
int[] aux = new int[arr.length];
for (int i = l; i <= r; i++) {
aux [i -l] = arr [i];
}
int i = l,j = mid +1;
for (int k = l;k <= r;k ++){
if (i > mid){
arr[k] = aux[j -l];
j ++;
}else if (j >r){
arr [k] = aux [i -l];
i ++;
}else if (aux[i - l] <aux[j -l]){
arr [k] = aux [i -l];
i ++;
}else {
arr[k] = aux[j -l];
j++;
}
}
}
(2) Iteration, bottom-up is suitable for sorting the linked list, because there is no value by the index of the array
public static void mergeSortBU(int[] arr){
for (int sz = 1 ;sz <= arr.length; sz += sz){
for (int i = 0 ;i + sz< arr.length; i += sz +sz){
merge(arr, i ,i +sz -1 , Math.min(i +sz + sz -1,arr.length-1));
}
}
}
private static void merge(int[] arr, int l, int mid, int r) {
int[] aux = new int[arr.length];
for (int i = l; i <= r; i++) {
aux [i -l] = arr [i];
}
int i = l,j = mid +1;
for (int k = l;k <= r;k ++){
if (i > mid){
arr[k] = aux[j -l];
j ++;
}else if (j >r){
arr [k] = aux [i -l];
i ++;
}else if (aux[i - l] <aux[j -l]){
arr [k] = aux [i -l];
i ++;
}else {
arr[k] = aux[j -l];
j++;
}
}
}
2. Quick Sort
Quick sort degenerates to O(n^2) when the array is nearly ordered
If there is no recursive stop condition, it will cause stack overflow
(1) Two-way quick row
public static void quicksort(int[] arr){
quick(arr,0,arr.length -1 );
}
public static void quick(int[] arr,int l,int r){
if (l >= r)
return;
int p = partition(arr,l,r);
quick(arr,l,p-1);
quick(arr,p+1,r);
}
//return p so that arr[l,p-1] is less than p so that arr[p+1,r] is greater than p
public static void swap(int[] arr,int i ,int j ){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static int partition(int[] arr,int l ,int r){
int privot = arr[l];
int j = r,i = l ;
while (i < j){
while (i < j && arr[j] > privot) {j --;}
swap(arr,i,j);
while (i < j && arr[i] <= privot) {i ++;}
swap(arr,i,j);
}
return i;
}
(2) Three-way quick row, divided into <=>
public static void quciksort3ways(int[] arr,int l ,int r){
if (l >= r)
return;
int v = arr [l];
int lt = l; // <
int gt = r +1; // >
int i = l +1; // =
while (i < gt){
if (arr[i] < v){
swap(arr,i,lt+1);
lt ++ ;
i ++;
}else if (arr[i] > v){
swap(arr ,i,gt -1);
gt --;
}else {
i ++;
}
}
swap(arr,l,lt);
quciksort3ways(arr,l,lt -1);
quciksort3ways(arr,gt,r);
}
3. Heap sort