排序算法整理

1. 冒泡

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

#include <stdio.h>
#include <iostream>

using namespace std;

template<typename T>
void bubble_sort (T arr[], int len){
    for (int idx=0; idx < len-1; idx++){
        for (int idx_sort=0; idx_sort < len-1; idx_sort++){
            if (arr[idx_sort] > arr[idx_sort+1]){
                swap(arr[idx_sort], arr[idx_sort+1]);
            }
        }
    }
}

int main (){    
        int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        for (int i = 0; i < len; i++)
                cout << arr[i] << ' ';
        cout << endl;
        float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
        len = (float) sizeof(arrf) / sizeof(*arrf);
        bubble_sort(arrf, len);
        for (int i = 0; i < len; i++)
                cout << arrf[i] << ' '<<endl;
        return 0;
}

2. 选择

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

template<typename T>
void select_sort(T arr[], int len){
    for (int idx_curr=0; idx_curr<len; idx_curr++){
        int min=idx_curr;
        for (int idx_min=idx_curr+1; idx_min<len; idx_min++){
            if (arr[min]>arr[idx_min]){
                min=idx_min;
            }
        }
        if(min!=idx_curr){
            swap(arr[min], arr[idx_curr]);
        }
    }
}

3. 插入

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。

template<typename T>
void insert_sort(T arr[], int len){
    for (int idx_curr=1; idx_curr<len; idx_curr++){
        for (int idx=idx_curr; idx>0; idx--){
            if (arr[idx-1]>arr[idx]){
                swap(arr[idx], arr[idx-1]);
            }
            else{
                break;
            }
        }
    }
}

4. 希尔排序

https://blog.csdn.net/qq845579063/article/details/51447404

template<typename T>
void insert_sort(T arr[], int len){
    int gap=len/2+1;
    while(gap>2){
        for (int idx=0; idx+gap<len; idx++){
            if (arr[idx]>arr[idx+gap]){
                swap(arr[idx+gap], arr[idx]);
            }
        }
        gap=gap/2+1;
    }
    for (int idx=0; idx+2<len; idx+=1){
        if (arr[idx]>arr[idx+2]){
           swap(arr[idx+2], arr[idx]);
        }
    }
    for (int idx=0; idx+1<len; idx+=1){
        if (arr[idx]>arr[idx+1]){
           swap(arr[idx+1], arr[idx]);
        }
    }
}

5. 归并

template<typename T>
void merge_sort(T arr[], int len){
	T* a=arr;
	T* b=new T[len];
	
	for (int seg=1; seg<len; seg+=seg){
		for (int step=0; step<len; step+=seg+seg){
			int idx_b=step;
			int start_1=step;
			int mid=min(start_1+seg, len);
			int start_2=start_1+seg;
			int end=min(start_2+seg, len);
			while(start_1!=mid && start_2!=end){
				if (a[start_1]>a[start_2]){
					b[idx_b]=a[start_2];
					start_2++;
				}
				else{
					b[idx_b]=a[start_1];
					start_1++;
				}
				idx_b++;
			}
			while(start_1<mid){
				b[idx_b]=a[start_1];
				idx_b++;
				start_1++;
			}
			while(start_2<end){
				b[idx_b]=a[start_2];
				idx_b++;
				start_2++;
			}			
		}
		T* temp=a;
		a=b;
		b=temp;
	}	

    if (a!=arr){
        for (int idx=0; idx<len; idx++){
            arr[idx]=a[idx];
        }
		T* temp=a;
		a=b;
		b=temp;        
    }

    delete[] b;
}