数据结构八大排序

冒泡排序

一、概念

冒泡排序的思想是从第一个数据开始不断地向后比较，如果这两个数不满足目标顺序则进行交换，这样一趟循环下来可以确认数据最后未排序的数据。

二、代码实现

// 冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)//i<n-1是因为比较的时候是下标
	{							   //当前下标和下一个下标进行比较
        
		for (int j = 0; j < n - 1 - i; j++)//n-1-i是因为每次排序都会确认一个数在
                                           //最后未排序的位置
		{
			if (a[j] > a[j + 1])
			{
				swap(&a[j], &a[j + 1]);
			}
		}
	}
}

时间复杂度O(N^2)
空间复杂度O(1)
稳定性 是

插入排序

一、概念

插入排序的思想是类似于我们在打牌的时候理牌时候的方法
每轮排序选择一个数字向前比较，直到到达合适的位置则插入该位置

二、代码实现

void InsertSort(int* arr, int size)//直接插入排序
{
	for (int i = 0; i < size - 1; i++)
	{
		//单趟插入排序
		//基本思想：[0,end]区间值为有序
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (tmp < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;//在这里break出去再去赋值tmp是为了防止最后一次end = -1进不来赋值
			}
		}
		arr[end + 1] = tmp;
	}
}

时间复杂度在数组接近有序的时候比较快，如果数据为倒序则时间复杂度为O(N^2)
空间复杂度O(1)
稳定性 是

希尔排序

一、概念

希尔排序属于是插入排序的进阶版本
如果直接使用插入排序，如果数据为逆序，则后面的数据要转移到前面要花费大量的时间，但是如果数据接近有序，使用插入排序的速度就非常的快
我们再次基础上对数据进行预排序优化
不在是直接相邻的两位进行比较，我们设定一个gap为步长，把间隔为gap的数据进行插入排序，然后不断缩小gap，直到gap为1进行最终排序

希尔排序的时间复杂度计算起来比较复杂，大概在N^1.3左右
空间复杂度N(1)
稳定性 否
希尔排序的稳定性由于相同的数值可能会被分到不同的组进行排序，可能会被打乱顺序，所以稳定性为否

二、代码实现

 void ShellSort(int* nums, int n)
{
    int gap = n;//定义第一次的步长
        while (gap >= 1)//直到步长为一之后最后一次排序
        {
            for (int i = 1; (i + gap) <= n; i++)//步长为gap的数据排序
            {
                int end = i - 1;//最后一个有序元素的位置
                int tmp = nums[end+ gap];//把下一个对比数据保存起来
                while (end >= 0)//挪动数据的循环给数据找合适的位置
                {
                    if (nums[end] > nums[end + gap])//如果当前数比tmp数据要大就把当前数字移动到下一个位置
                    {
                        nums[end + gap] = nums[end];
                        end-=gap;
                    }
                    else//如果当前数字比对比的数字小就吧对比的数字放到当前数字的下一个
                    {
                        break;
                    }
                    nums[end + gap] = tmp;
                }
            }
            gap /= 2;
}

选择排序

一、概念

选择排序的思想就比较简单了，不断的选出未排序中最大/小的数据排到数组未排序数据的前面

二、代码实现

// 选择排序
void SelectSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		int max = a[0];
		int maxi = 0;
		for (int i = 0; i < n-j; i++)
		{
			if (a[i] < a[maxi])
			{
				maxi = i;
			}
		}
		int tmp = a[n - j - 1];
		a[n-j-1]= a[maxi];
		a[maxi] = tmp;
	}
}

选择排序的时间复杂度极其稳定为N^2
空间复杂度O(1)

堆排序

详情见链接

快速排序

一、概念

快速排序有多个版本，这里展示的版本是双指针版本，虽然有多个版本，但是总体思想不变，只是实现的方法有所不同
（排升序下）
1.选出一个基准数值key，一般使用数组首元素作为key
2.创建两个指针/下标，prev和cur，cur指向第二个数值
3.cur开始往后遍历，如果cur数值比key要小则prev++，交换cur和prev所指向的数
4.当cur为NULL时停止遍历，同时将key和prev进行交换，这要key左边的都不大于key，右边的都不小于key，key的位置就是最终排序位置，之后把key左边和右边用相同的方式排序进行递归完成排序

但是如果数据是有序的话，取首元素作key的方式会导致左右两边的分隔极其不平衡，会导致大幅效率下降
所以我们对取key进行优化
我们从首尾中三个数字中选一个次大的来保证左右两边分隔相对平衡

代码实现

int GetMidNumi(int a, int b, int c)
{
	if (a>=b)
	{
		if (b >= c)
		{
			return b;
		}
		else if(c>=a)
		{
			return a;
		}
		else
		{
			return c;
		}
	}
	else if(a<=b)
	{
		if (c >= b)
		{
			return b;
		}
		else if(c<=a)
		{
			return a;
		}
		else
		{
			return c;
		}
	}
}
// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMidNumi(*a, left, right);
	if (midi != left)
		swap(&a[midi], &a[left]);

	int cur, prev;
	int key = a[left];
	int keyi = left;
	prev= left;
	cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < key)
		{
			swap(&a[++prev], &a[cur]);
		}
		++cur;
	}
	swap(&a[keyi], &a[prev]);
	
	return prev;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort3(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

时间复杂度O(N)
空间复杂度O(1)
稳定性 否

归并排序

一、概念

归并排序的思想
1.把数据分隔成多个小区间，对小区间进行排序
2.小区间有序之后合并成大区间，逐步递归完成排序

代码实现

递归版本，由于归并排序要使用额外的空间，所以要开辟一个空间，这样在函数内部开辟空间之后就不能递归自己了，所以需要一个子函数来递归

//归并排序子函数
void _MergeSort(int* a, int* tmp, int left, int right
	if (left >= right)
	{
		return;
	}
	int mid = (left + right) / 2;
	_MergeSort(a, tmp, left, mid);
	_MergeSort(a, tmp, mid+1, right);

	int left1 = left, right1 = mid;
	int left2 = mid + 1, right2 = right;
	int i = left;
	while (left1 <=right1 && left2 <= right2)
	{
		if (a[left1] <= a[left2])
		{
			tmp[i++] = a[left1++];
		}
		else
		{
			tmp[i++] = a[left2++];
		}
	}
	while (left1 <=right1)
	{
		tmp[i++] = a[left1++];
	}
	while (left2 <=right2)
	{
		tmp[i++] = a[left2++];
	}
	memcpy(a + left, tmp + left, 4*(right - left + 1));
}

//归并排序
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	int left = 0;
	int right = n - 1;
	_MergeSort(a, tmp, left, right);
}

非递归版本是使用多重循环进行排序的，其中的边界控制要求比较高

//归并排序非递归
void MergeSortNoR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	int gap = 1;
	
	while (gap < n)
	{
		for (int i = 0; i < n; i += gap*2)//gap*2是对下两组进行归并
		{
			int left1 = i, right1 = i + gap - 1;
			int left2 = i + gap, right2 = i + 2 * gap - 1;
			int j = i;
			if (right1 >= n)//无归并必要
			{
				break;
			}
			else if(right2>=n)//修正
			{
				right2 = n - 1;
			}
			while (left1 <= right1 && left2 <= right2)
			{
				if (a[left1] <=a[left2])
				{
					tmp[j++] = a[left1++];
				}
				else
				{
					tmp[j++] = a[left2++];
				}
			}
			while (left1 <= right1)
			{
				tmp[j++] = a[left1++];
			}
			while (left2 <= right2)
			{
				tmp[j++] = a[left2++];
			}

			memcpy(a + i, tmp + i, sizeof(int) * (right2 - i + 1));
		}
		gap *= 2;
	}
}

时间复杂度O(logN)
空间复杂度O(N)
稳定性 是

计数排序

一、概念

计数排序
1.创建一个额外数组，存储着数组最大值-最小值个数据
2.遍历一遍数组记录每个数字出现了几次
3.遍历一边记录数组，复原数组

二、代码实现

void CountSort(int *a,int n)
{
	int max = a[0], min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	
	int* count = (int*)calloc((max - min + 1),sizeof(int));
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < (max - min + 1); i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

看起来这个排序很吊，但是这个排序只能排序整数，数值范围比较集中的情况下才比较优秀

总结