C语言排序算法

---

冒泡排序

思路：无序序列 有序序列（按照从小到大）
每一趟都在无序序列中找出最大的数，然后放到有序序列的左边
如何找最大的数：每一趟都从无序序列的第一个元素开始，前一个和后一个两两进行比较，前面的比后面的大，就进行交换

//冒泡排序
void maopSort(int *arr, int size)
{
	//入参检查
	if(NULL == arr || size <= 0)
	{
		return ;
	}
	int i,j;
	for(i = 0; i < size-1; i++)
	{//需要排序size -1 次
		for(j = 0; j < size-1-i; j++)
		{//遍历数组，把最大值放到最右边
			if(arr[j] > arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
}

冒泡排序法的时间复杂度为O(N^2)

---

选择排序

思路：有序序列 无序序列
每一趟都在无序序列中找最小的数，然后放到有序序列的右边
如何找到最小的数：将无序序列中的第一个数的下标赋值给min，然后依次将arr[min]和无序序列中的其他数进行比较，一旦arr[min]大于其他的数，就将这个数的下标赋值给min，最终min就是最小的值的下标，将无序序列中的第一个数和这个下标处的数进行交换

//选择排序
void selectSort(int *arr, int size)
{
	if(NULL == arr || size <= 0)
	{
		return ;
	}
	int i,j,min;
	//i表示无序序列的开始
	for(i = 0; i < size-1; i++)
	{
		//min记录的是无序序列的最小元素的下标，
		//min的初始值每一次都是无序序列的第一个元素的下标
		min = i;
		for(j = i+1; j < size; j++)
		{//j是从无序列表第二个开始遍历
			if(arr[min] > arr[j])
				min = j;
		}
		//交换
		int temp = arr[i];
		arr[i] = arr[min];
		arr[min] = temp;
	}

}

选择排序算法的时间复杂度为O(N^2)

---

插入排序

思路：有序序列 无序序列
每一趟都从无序序列中拿出来第一个数，将这个数与有序序列中的数从右向左进行比较，一旦发现这个数比有序序列中的某个数大，就将这个数放在有序序列这个数的后面，如果比有序序列的数小，就将有序序列的数往右移动.

//插入排序
void insertSort(int *arr, int size)
{
	if(NULL == arr || size <= 0)
	{
		return ;
	}
	int i,j,temp;//j 是无序序列下标，i 是有序序列下标
	for(j = 1; j < size ; j++)
	{
		temp = arr[j];//temp保存无序序列第一个值
					//防止有序序列在后移的过程覆盖数据
		for(i = j-1; i >= 0; i--)
		{
			if(temp >= arr[i])
			{
				break;
			}
			//如果要插入的数值小，将这个大的数后移
			arr[i+1] = arr[i];
		}
		//将这个数插入
		arr[i+1] = temp;
	}
}

插入排序算法的时间复杂度最优为O(N)，最差为O(N^2)

---

快速排序

思路：在无序序列中将第一个元素作为基准，将比基准小的元素放在基准的左边，比基准大的元素放到基准的右边，然后对基本左边和右边的无序序列再次按照上面的方法进行排序，因此采取递归。
如何实现将比基准大的值放在基准的右边，比基准小的值放在基准的左边？
1、先将基准保存起来，基准的位置腾出来了
2、用i表示左边的元素，初始值是第一个元素的下标
3、用j表示右边的元素，初始值为最后一个元素的下标
4、将基准和arr[j]进行比较，如果比基准大，就j–，否则就将arr[j]拷贝给左边有空的位置，此时这个位置就腾出来了
5、将基准和arr[i]进行比较，如果比基准小，就i++，否则就将arr[i]拷贝到右边有空的位置
6、继续重复第4步和第五步，直到i==j

//快速排序
void quickSort(int *arr, int l, int r)
{
	if(NULL == arr || l < 0 || r < 0 || l >= r)
	{
		return;
	}
	int i = l, j = r, x = arr[i];
	//x为基准
	//将基准放到中间
	while(i < j)
	{
		//先从最右边的元素和基准进行比较
		//只要右边大于x，j--
		//否则就将大于x的这个数赋值给左边的空闲位置		
		while(arr[j] > x && i < j)
		{
			j--;
		}
		if(i < j)
		{
			arr[i++] = arr[j];
		}
		//从左边的元素和基准进行比较
		//只要左边小于x，i--
		//否则就将大于x的这个数赋值给右边的空闲位置

		while(arr[i] < x && i < j)
		{
			i++;
		}
		if(i < j)
		{
			arr[j--] = arr[i];
		}
	}
	arr[i] = x;//i和j相等
	//对基准左边无序序列继续进行快排
	quickSort(arr, l, i-1);
	//对基准右边无序序列继续进行快排
	quickSort(arr, j+1, r);
}

快速排序法的时间复杂度是nlogn

---

归并排序

思路：
第一步：申请临时空间，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾

void Merge(int arr[], int tmp[], int start,int mid, int end)
{//合并子序列
	int i = start;//指向左序列的第一个元素
	int j = mid+1;//指向右序列的第一个元素
	int k = start;//tmp数组下标的起始位置
	while(i <= mid && j <= end)
	{//左序列越界或者右序列越界
		if(arr[i] < arr[j])
		{
			tmp[k++] = arr[i++];//把左序列的值放入临时数组
		}
		else
		{
			tmp[k++] = arr[j++];//把右序列的值放入临时数组
		}
	}
	while(j <= end)
	{
		tmp[k++] = arr[j++];//若左序列放完
	}
	while(i <= min)
	{	
		tmp[k++] = arr[i++];//若右序列放完，把左序列剩余放入tmp
	}
	for(k = start; k < = end; k++)
	{
		arr[i] = tmp[i];
	}//把临时数组的值放入arr中
}
/*
arr 原数组
tmp 临时数组，与原数组大小一致
*/
void Merges(int arr[], int tmp[], int start, int end)//划分子序列
{
	if(start < end)
	{
		int mid = (start + end)/2;
		Merges(arr,tmp,start,mid);//递归分左子序列
		Merges(arr,tmp,mid+1,end);//递归分右子序列
		Merge(arr,tmp,start,mid,end);//将左右子序列合并
	}
}