几种排序算法（插入，希尔，冒泡，快速）

目录

插入排序

希尔排序

冒泡排序

快速排序

插入排序

本质上就是遍历一个数组，每遍历到一个元素，就把这个元素和他前面的元素进行比较，如果这个元素小于前面的元素，就让前面的元素后移，这个元素一直前移，直到这个元素的前驱元素比他小。

//插入排序,数组
void InsertSort(int arr[], int length) {
	int t, i, j;
	for (i = 1; i < length; i++) {
		if (arr[i] < arr[i - 1]) {
			//后继结点小于前驱结点，开始执行判定
			t = arr[i];//保存当前元素
			//从前驱元素开始向前遍历，如果前驱大于t，那么前驱结点后移，所谓后移操作就是前驱元素赋值给后继元素。
			for (j = i - 1; arr[j] > t && j >= 0; j--) {
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = t;
		}
	}
}

希尔排序

希尔排序的本质就是设置一个d增量，然后根据d增量来对原始数组进行一次逻辑上的分组（物理空间上数组并没有改变）。然后对这些分组依次使用插入排序。之后缩小d增量，重复上诉操作，知道d增量=1，表示该分组基本就是原始数组经过n轮排序后的数组，进行最后一次排序。

在希尔排序中，由于依赖d增量这一参数，所以该算法只能使用在可以支持随机访问的数据结构上。

//希尔排序
void ShellSort(int arr[], int length, int du) {
	int temp,k,j;
	for (int d = du; d >= 1; d = d / 2) {
		for (int i = 0; i < d; i++) {
            //本层循环是分组循环层
			for (j = i + d; j < length; j += d) {
                //本层循环是对其中一个分组的元素进行遍历
				if (arr[j - d] > arr[j]) {
					temp = arr[j];//保存当前元素
					for (k = j - d; k >= 0 && arr[k] > temp; k -= d) {
                        //所有前驱元素大于temp元素，全部后移一位
						arr[k + d] = arr[k];
					}
					arr[k + d] = temp;//temp元素插入对应位置
				}
			}
		}
	}
	
}

冒泡排序

冒泡排序的本质就是遍历n轮，每一轮都让小的元素交换位置到前面或者后面，也就是每一轮都可以确定剩下元素里一个最小的元素，放到它应该在的位置上。

void BubbleSort(int arr[], int length) {
	int temp;
	for (int i = 0; i < length - 1; i++) {
		bool flag = false;//设置bool量，当本轮循环中没有出现置换，那么说明数组有序了
		for (int j = length-1; j > i; j--) {
			if (arr[j - 1] > arr[j]) {
				//前驱大于后继，那么前驱结点移动到后继结点后面
				temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
				flag = true;
			}
		}
		if (!flag) {
			return;
		}
	}
}

快速排序

快速排序核心：设置一个基准数（一般可以把数组0下标的元素作为基准元素），之后设置low和high两个索引指针。每一轮都会让执行区域内的所有大于基准元素的数组元素放置再基准数的右边，小于基准元素的放置在基准数的左边。算法采用递归算法结构，直到数组有序。

//快速排序-分部排序函数
int Partition(int arr[], int low, int high) {
	int pivot = arr[low];//将数组元素的第一个作为基准数
	while (low < high) {
		//low指针小于high指针，执行程序
		while (low < high && arr[high] >= pivot) {
			--high;//high指针左移
		}
			
		arr[low] = arr[high];//把high元素赋值给low，随后high元素位置为逻辑空
		while (arr[low] <= pivot && low < high) {
			++low;//low指针右移
		}
			
		arr[high] = arr[low];//把low元素赋值给high，随后low元素位置为逻辑空
	}
	arr[low] = pivot;//最后把基准元素放置到low和high指针重叠位置，arr[low]换成arr[high]也是一样的
	return low;//把基准元素的索引下标返回
}

//快速排序
void QuickSort(int arr[], int low,int high) {
	if (low < high) {
		int pivot_index = Partition(arr, low, high);//划分,pivot_index为基准数的数组下标
		QuickSort(arr, low, pivot_index -1);//左子表继续排序
		QuickSort(arr, pivot_index + 1,high );//右子表继续排序
	}
}