一直沒自己寫過 然後自己寫了下

先插排 插入排序（英語：Insertion Sort）是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

演算法描述

一般來說，插入排序都採用in-place在陣列上實現。具體演算法描述如下：

1. 從第一個元素開始，該元素可以認為已經被排序
2. 取出下一個元素，在已經排序的元素序列中從後向前掃描
3. 如果該元素（已排序）大於新元素，將該元素移到下一位置
4. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
5. 將新元素插入到該位置後
6. 重複步驟2~5

如果比較操作的代價比交換操作大的話，可以採用二分查詢法來減少比較操作的數目。該演算法可以認為是插入排序的一個變種，稱為二分查詢插入排序。

歸併排序

歸併排序（英語：Merge sort，或mergesort），是建立在歸併操作上的一種有效的排序演算法，效率為O(n log n)。1945年由約翰·馮·諾伊曼首次提出。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用，且各層分治遞迴可以同時進行。

演算法描述

歸併操作

歸併操作（merge），也叫歸併演算法，指的是將兩個已經排序的序列合併成一個序列的操作。歸併排序演算法依賴歸併操作。

迭代法

1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列
2. 設定兩個指標，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置
4. 重複步驟3直到某一指標到達序列尾
5. 將另一序列剩下的所有元素直接複製到合併序列尾

遞迴法

原理如下（假設序列共有n個元素）：

1. 將序列每相鄰兩個數字進行歸併操作，形成{\displaystyle floor(n/2)}個序列，排序後每個序列包含兩個元素
2. 將上述序列再次歸併，形成{\displaystyle floor(n/4)}個序列，每個序列包含四個元素
3. 重複步驟2，直到所有元素排序完畢

#include<iostream>
#include <stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
//之前一直沒有寫過插入排序和歸併排序，所以就很方
//插入排序
void insertion_sort(int arr[], int len)
{
    int i, j;
    int temp;
    for (i = 1; i < len; i++)
    {
    temp = arr[i];
//與已排序的數逐一比較，大於temp時，該數向後移
    j = i - 1;
 // 如果將賦值放到下一行的for迴圈內, 會導致在第10行出現j未宣告的錯誤
 	    for (; j >= 0 && arr[j] > temp; j--)
        { //j迴圈到-1時，由於[[短路求值]](http://zh.wikipedia.org/wiki/短路求值)，不會運算array[-1]
 			arr[j + 1] = arr[j];
 	    }
 	arr[j + 1] = temp;
     //被排序數放到正確的位置
     }
 }
//寫個非遞迴的歸併排序
int min(int x, int y) {
	return x < y ? x : y;
}
void merge_sort_d(int arr[], int len) {
	int* a = arr;
	int* b = (int*) malloc(len * sizeof(int));
	int seg, start;
	for (seg = 1; seg < len; seg += seg) {
		for (start = 0; start < len; start += seg + seg) {
			int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
			int k = low;
			int start1 = low, end1 = mid;
			int start2 = mid, end2 = high;
			while (start1 < end1 && start2 < end2)
				b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
			while (start1 < end1)
				b[k++] = a[start1++];
			while (start2 < end2)
				b[k++] = a[start2++];
		}
		int* temp = a;
		a = b;
		b = temp;
	}
	if (a != arr) {
		int i;
		for (i = 0; i < len; i++)
			b[i] = a[i];
		b = a;
	}
	free(b);
}
//遞迴的歸併排序
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
	if (start >= end)
		return;
	int len = end - start, mid = (len >> 1) + start;
	int start1 = start, end1 = mid;
	int start2 = mid + 1, end2 = end;
	merge_sort_recursive(arr, reg, start1, end1);
	merge_sort_recursive(arr, reg, start2, end2);
	int k = start;
	while (start1 <= end1 && start2 <= end2)
		reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
	while (start1 <= end1)
		reg[k++] = arr[start1++];
	while (start2 <= end2)
		reg[k++] = arr[start2++];
	for (k = start; k <= end; k++)
		arr[k] = reg[k];
}
void merge_sort_r(int arr[], const int len) {
	int reg[len];
	merge_sort_recursive(arr, reg, 0, len - 1);
}
int main()
{
    int a[10]= {12,23,32,15,25,36,53,75,98,16};
    insertion_sort(a,10);
    cout<<"插入排序："<<endl;
    for(int i=0; i<10; i++)
        cout<<a[i]<<" ";
        cout<<endl;
    merge_sort_r(a,10);
    cout<<"遞迴法歸併排序："<<endl;
    for(int i=0; i<10; i++)
        cout<<a[i]<<" ";
        cout<<endl;
    merge_sort_d(a,10);
    cout<<"非遞迴歸併排序："<<endl;
    for(int i=0; i<10; i++)
        cout<<a[i]<<" ";
        cout<<endl;

}