普通插入排序，折半插入排序，折半查找

普通插入排序

时间复杂度：O(N^(1-2))

空间复杂度：O(1)

稳定性：稳定

代码（数组的第一个位置即arr[0]是个哨兵，用于存放for循环的arr[i]，便于之后移动比arr[i]要大的所有元素）：

void insert_sort(int arr[],int size){
	for(int i = 2;i <= size;i++){
		arr[0] = arr[i];
		int j = i;
		while(arr[j - 1] > arr[0] && j > 1){
			arr[j] = arr[j - 1];
			j--;
		}
		arr[j] = arr[0];
	}
}

折半排序（一种特殊的插入排序，也叫折半插入排序）

在插入排序的寻找插入位置的方法改进为二分查找

时间复杂度：O(n^2)

空间复杂度：O(1)

稳定性：稳定

代码：

void slit_sort(int arr[], int size){
	
	for (int i = 2;i <= size;i++){
		int inc = arr[i];
		int j = 1;
		int k = i - 1;
		int mid = (j + k) / 2;
		while (j <= k){
			if (arr[mid] < inc){
				j = mid + 1;
			}else {
				k = mid - 1;
			}
			mid = (j + k) / 2;
		}
		for (int l = i; l > j; l--){
			arr[l] = arr[l - 1];
		}
		arr[j] = inc;
	}
} 

希尔排序（插入排序的一种）

空间复杂度：O(1)

稳定性：不稳定

代码：

void shell_sort(int arr[], int size){
	int n = size / 2;
	while (n > 0){
			for(int i = n + 1; i <= size; i++){
				arr[0] = arr[i];
				int j;
				for (j = i - n; arr[j] > arr[0] && j > 0; j -= n){
					arr[j + n] = arr[j];
				}
				arr[j + n] = arr[0];
	}
	n = n / 2;
	}
}

二分查找（二分查找也称折半查找）

时间复杂度：O（log2n）

注意：要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

代码：

int half_find(int arr[], int size, int key){
	int i = 1, j = size;
	int mid = (i + j) / 2;
	while (i <= j){
		if (arr[mid] == key){
			return mid;
		}else if (arr[mid] < key){
			i = mid + 1;
		}else {
			j = mid - 1;
		}
		mid = (i + j) / 2;
	}
	return -1; //没找到返回-1
}