【数据结构】带你细致理解八大排序

文章目录

  • 前言
  • 一.冒泡排序
    • 前一个数跟后一个数比较
    • 后一个数跟前一个数比较
    • 优化
    • 复杂度与稳定性
  • 二.插入排序
    • 初始化条件从第一个元素开始
    • 初始化条件从第二个元素开始
    • 复杂度与稳定性
  • 三.选择排序
    • 一趟选出一个最小的
    • 一趟选出一个最大的和一个最小的
    • 复杂度与稳定性
  • 四.堆排序
    • 建堆用向下调整
    • 建堆用向上调整
    • 复杂度与稳定性
  • 五.希尔排序
    • 初始化条件为0,结束条件为size-gap
    • 初始化条件为gap,结束条件为size
    • 复杂度与稳定性
  • 六.快速排序
    • 原始Hore版本
    • 挖坑法
    • 前后指针法
    • 非递归快排
      • 前序遍历
      • 层序遍历
    • 复杂度与稳定性
    • 优化
      • 三数取中
      • 设置随机key
  • 七.归并排序
    • 递归写法
    • 非递归写法
      • 一把梭哈
      • 分步拷贝
    • 稳定性与时间复杂度
  • 八.计数排序
    • 复杂度

前言

以下排序,实现的都是升序
为了简化操作:这里将打印函数和交换函数以及头文件先给出

#include
#include
void Swap(int* n1, int* n2)
{
	int tmp = *n1;
	*n1 = *n2;
	*n2 = tmp;
}

void Print(int* arr,int size)
{
	for (int i = 0; i < size; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

建议:先写一趟的,再写全部的

  • 补充知识:排序的稳定性指的是:排序前后相同数据的相对位置变化的情况,如果排序之后没有发生变化化,我们就称这个排序算法是稳定的!

一.冒泡排序

  • 思想:通过两两打擂台的方式,强者胜出,每个人都打一次,从而筛选出一个冠军,把冠军排除在外,让剩余的人继续打,再打一次筛选亚军,以此类推得出每一个人的排名。
  • 把人换成数字带进去便可理解冒泡的思想
  • 交换条件: 后一个数小或者前一个数大
  • 我用的是:前一个数大
//动态图使用的数组:
	int arr[] = { 3,44,38,5,47,15,36,26,27,2,46,4,19,50,48 };
	int size = sizeof(arr) / sizeof(arr[0]);

【数据结构】带你细致理解八大排序_第1张图片

前一个数跟后一个数比较

  • 起点从第一个元素开始,到倒数第二个元素结束
void BubbleSort1_0(int *arr,int size)
{

	//总躺数:size - 1,最后一趟只剩下最后一个数就不用比了
	for (int i = 0; i < size - 1; i++)
	{
		//拿前一个数跟后一个数比较的一趟
		for (int j = 0; j < size - 1 - i; j++)
		{
			//如果前一个数大就交换
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
			}
		}
	}
}

后一个数跟前一个数比较

  • 第一趟的起点从第二个元素开始,终点到最后一个元素
void BubbleSort2_0(int* arr, int size)
{

	//总躺数:size - 1,最后一趟只剩下最后一个数就不用比了
	for (int i = 0; i < size - 1; i++)
	{
		//拿后一个数跟前一个数比较的一趟
		for (int j = 1; j < size - i; j++)
		{
			//如果前一个数大就交换
			if (arr[j-1] > arr[j])
			{
				Swap(&arr[j], &arr[j - 1]);
			}
		}
	}
}

优化

  • 当比较完一趟时,如果有序不用再比了。
void BubbleSort1_1(int* arr, int size)
{

	//总躺数:size - 1,最后一趟只剩下最后一个数就不用比了
	for (int i = 0; i < size - 1; i++)
	{
		//若是有序的就跳出,假设是有序的

		bool Is_Order = true;
		//拿前一个数跟后一个数比较的一趟
		for (int j = 0; j < size - 1 - i; j++)
		{
			//如果前一个数大就交换,如果是无序的才会进去if
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
				Is_Order = false;
			}
		}
		if (Is_Order)
		{
			break;
		}
	}
}

复杂度与稳定性

  • 最坏的情况:排升序数据是降序,排降序时升序——O(N2)

时间复杂度的准确函数表达式:F(N)=1+2+……+N-1=(N-1)*N/2=N2 / 2 - N / 2

  • 最好的情况:排升序是升序,排降序时降序——O(N),这是优化之后的冒泡

在接近有序的情况下:数据的准确函数表达式为:F(N)=a*N,a是大于等于1的正整数

  • 空间:没有使用额外的空间——O(1)
  • 稳定性:因为相同数据前后并不会发生交换,因此冒泡排序算法稳定

二.插入排序

【数据结构】带你细致理解八大排序_第2张图片

  • 思想:洗牌
  • 先从牌头开始洗,遇到大于的就把牌插入它的前面,以此类推。

【数据结构】带你细致理解八大排序_第3张图片

初始化条件从第一个元素开始

void InsertSort1_0(int* arr, int size)
{
	for (int i = 0; i < size-1; i++)//结束条件:倒数第二个数
	{
		int cur = arr[i + 1];//这里要注意边界问题
		int end = i;
		while (1)
		{
			if (end >= 0 && arr[end] > cur)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				arr[end + 1] = cur;
				break;
			}
		}
	}
}

初始化条件从第二个元素开始

void InsertSort1_1(int* arr, int size)
{
	for (int i = 1; i < size; i++)//结束条件为:倒数第一个元素
	{
		int cur = arr[i];
		int end = i - 1;
		while (end >= 0)
		{
			if (cur < arr[end])
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = cur;
	}
}

复杂度与稳定性

  • 最坏的情况:排升序数据是降序,排降序时升序——O(N2)

函数表达式:F(N)=1+2+3+4+5+……+N=(N+1)*N / 2

  • 最好的情况:接近有序——O(N)

函数表达式:F(N)=a*N,a为正整数
与冒泡比较,插入排序较好,原因是在接近有序的情况下,插入相当于只需遍历一次,冒泡至少要遍历两次。

  • 没有用额外的空间——O(1)
  • 相等的数据并不会发生交换,因此插入排序的稳定性很好

三.选择排序

【数据结构】带你细致理解八大排序_第4张图片

一趟选出一个最小的

  • 选完之后,与最左边交换
  • 处理好的数据就不再动了
void SelectSort1_0(int* arr, int size)
{
	//总的比较次数
	for (int j = 0; j < size; j++)
	{
		//先选出最小的下标
		int min = j ;
		for (int i = j+1; i < size; i++)
		{
			if (arr[min] > arr[i])
			{
				min = i;
			}
		}
		//与正在处理的最左边的数据进行交换
		Swap(&arr[min], &arr[j]);
		
	}
}

一趟选出一个最大的和一个最小的

  • 当选完之后,一种特殊情况:
  • 最大的下标与交换的最左边下标时,最左边下标是最小值的下标
  • 因此:交换之后,要更新最小值的下标为最大值的下标
void SelectSort1_1(int* arr, int size)
{
	int begin = 0;
	int end = size - 1;
	
	while (begin < end)
	{
		int max = begin;
		int min = begin;
		//选出最大的和最小的
		for (int i = begin+1; i <= end; i++)
		{
			if (arr[max] < arr[i])
			{
				max = i;
			}
			if (arr[min] > arr[i])
			{
				min = i;
			}
		}
		Swap(&arr[max], &arr[end]);
		if (end == min)
		{
			min = max;
		}
		Swap(&arr[min], &arr[begin]);
		//更新处理的数据范围
		end--;
		begin++;
	}
}

复杂度与稳定性

  • 最坏的情况与最好的情况相同——O(N2)

第一种:选出最小的时间复杂度的函数表达式F(N)=1+2+3+……N-1=N2 / 2 - N / 2
第二种:选出最大的和最小的时间复杂度表达式F(N)=2+4+6+8+……+N-1=(N-1+2)*(N-1)/2/2=(N2-1)/4

  • 没有用额外的空间——O(1)
  • 假如对1,1,-1排序,选出最小的-1会对最左边的1进行交换,破坏了1,1的相对顺序,因此选择排序是不稳定的

四.堆排序

  • 核心思想:排升序建大根堆,排降序建小根堆
  • 注意:下标与边界问题

建堆用向下调整

void AdjustDown(int* arr, int parent, int size)
{
	//假设左孩子是比较大的
	int child = 2 * parent + 1;
	while (child < size)
	{
		//如果右孩子大就把孩子给右孩子
		if (child + 1 < size && arr[child + 1] > arr[child])
		{
			child++;
		}
		if (arr[child] > arr[parent])//孩子大就进行交换
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		//小于等于就跳出循环
		else
		{
			break;
		}
	}
}

void HeapSort(int* arr, int size)
{
	//升序建大堆
	for (int i = ((size - 1) - 1) / 2; i >= 0; i--)
	{
		AdjustDown(arr, i, size);
	}
	int end = size - 1;//最后一个数的下标
	while (end)//end为0表明只有一个数据,因此不用再循环
	{
		Swap(&arr[end], &arr[0]);
		end--;
		AdjustDown(arr, 0, end + 1);//这里的end+1指的是需要管理的数据个数
	}
}

建堆用向上调整

void AdjustUp(int* arr, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (arr[parent] < arr[child])
		{
			Swap(&arr[parent], &arr[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* arr, int size)
{
	//升序建大堆
	for (int i = 1; i < size; i++)
	{
		AdjustUp(arr, i);
	}
	int end = size - 1;//最后一个数的下标
	while (end)//end为0表明只有一个数据,因此不用再循环
	{
		Swap(&arr[end], &arr[0]);
		end--;
		AdjustDown(arr, 0, end + 1);//这里的end+1指的是需要管理的数据个数
	}
}

复杂度与稳定性

  • 向下调整建堆的时间复杂度为O(N),向上调整建堆的时间复杂度为O(NlogN),排序的时间复杂度为O(NlogN),综合看堆排序的时间复杂度为O(N*logN)
  • 由于是在数组里面建堆的。没有使用额外的空间——O(1)
  • 当堆是2,1,1时,2会先与最后的1发生交换,破坏了相同数据的相对位置,因此堆排序是不稳定的

五.希尔排序

  • 思想:想象一下你要到很远的地方,拜访朋友,你大概率不会走路过去,假设是坐飞机过去,到飞机场这时离朋友的家不算太远了,但大概率走路需要很远才到,这时又做出租车过去,又离朋友更近一步,到朋友家一段距离我们都会出于礼貌,再步行一段距离到朋友家。
  • 代入希尔排序:先坐飞机,再坐出租车,最后走路,这样初速度很大,但在慢慢变小的,整体在趋近有序,这就是希尔排序的思想
  • gap其实就是我们换乘的工具——飞机,出租车,走路

初始化条件为0,结束条件为size-gap

 void ShellSort(int *arr,int size)
{
	int gap = size;
	while (gap > 1)
	{
		gap = gap / 3+1;//加1是为了要处理的gap等于2时的情况
		for (int i = 0; i < size-gap ; i++)
		{
			int cur = arr[i+gap];
			//cur指向最后一个元素下标时为:size-gap+gap-1即为size-1
			int end = i;
			while (end >= 0)
			{
				if (cur < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = cur;
		}
		
	}
}

初始化条件为gap,结束条件为size

void ShellSort(int *arr,int size)
{
	int gap = size;
	while (gap > 1)
	{
		gap = gap / 3+1;//加1是为了要处理的gap等于2时的情况
		for (int i = gap; i < size ; i++)
		{
			int cur = arr[i];
			int end = i-gap;
			while (end >= 0)
			{
				if (cur < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = cur;
		}
		
	}
}

复杂度与稳定性

  • 很遗憾由于一些的数学难题尚未被攻破,时间复杂度我们很难进行准确的计算,但是一些局部的数据表明希尔排序的时间复杂度为:O(N1.25)到O(1.65N1.25)范围内,这是Knuth提出的,并且做了大量的实验数据。
  • 没有使用额外的空间——O(1)
  • 因为希尔排序在排序1,1,-1假如gap为2,这里的1和-1会交换位置,从而破坏了相同数据1,1的相对位置,因此希尔排序是不稳定的

六.快速排序

原始Hore版本

【数据结构】带你细致理解八大排序_第5张图片

void QuickSort(int *arr,int left,int right)
{
    if(left>=right)
    {
        return;
    }
    int key=left;
    int begin = left;
    int end =right;
    while(begin<end)
    {
        while(begin<end&&arr[end]>=arr[key])
        {
            end--;
        }
        while(begin<end&&arr[begin]<=arr[key])
        {
            begin++;
        }
        Swap(&arr[begin],&arr[end]);
    }
    key = end;
    Swap(&arr[left],&arr[key]);
    //剩余[left,key-1]与[key+1,right]
    QuickSort(arr,left,key-1);
    QuickSort(arr,key+1,right);
}
  • 循环内部和外部都得保证begin小于end
  • 左边先走,保证了最后遇到的是比key小的数
  • 遇到和key 相等的数据时,在左边和在右边都无所谓,因此不用管
  • 走完一趟后已经排好一个数的位置了,剩余的区间为[left,key-1]与[key+1,right]
  • 走完一趟后还需要更新key值
  • 递归的返回条件:left>=right

挖坑法

  • 因为第一个坑位在最左边,所以首先要保存key值
  • 右边先走找到小的就放进坑位,左边后走找大的放进坑位
  • 坑位在不断更新
  • 最后一个坑位:左边等于右边,即为key值的下标
  • 最后把坑里放进key值即可
void QuickSort2_0(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int key = arr[left];
	int hole = left;
	int begin = left;
	int end = right;
	while (begin < end)
	{
		while (begin < end && arr[end] >= key)
		{
			end--;
		}
		Swap(&arr[end], &arr[hole]);
		hole = end;
		while (begin < end && arr[begin] <= key)
		{
			begin++;
		}
		Swap(&arr[begin], &arr[hole]);
		hole = begin;
	}
	arr[hole] = key;
	//剩余[left,hole-1]与[hole+1,right]
	QuickSort2_0(arr, left, hole - 1);
	QuickSort2_0(arr, hole + 1, right);
}

前后指针法

  • cur找比key小的,prev用于交换数据
  • cur与prev之间存的是比key大的数prev以及以前存的是小于等于key的值
  • 最后cur走完数组,prev的位置就是坑位
void QuickSort3_0(int* arr, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int key = left;
	int prev = left;
	int cur = left+1;
	while (cur <= right)//注意等于,这里的right是数组的
	{
		if (arr[cur] < arr[key])
		{
			prev++;
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	Swap(&arr[prev], &arr[key]);
	key = prev;
	//剩余[left,key - 1]与[key + 1,right]
	QuickSort3_0(arr, left, key - 1);
	QuickSort3_0(arr, key + 1, right);
}

非递归快排

  • 非递归要使用的单趟排序,这里先列出来
  • 由于要使用栈和对列的结构,C语言得自己搓(我这里就省了)
  • 栈和对列的结构可自行在此文章里复制:栈和对列
int _QuickSort(int* arr, int left, int right)
{
	int key = left;
	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (arr[cur] < arr[key])
		{
			prev++;
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	Swap(&arr[prev], &arr[key]);
	key = prev;
	return key;
}

前序遍历

void QuickSortNonR1_0(int* arr, int left, int right)
{
	Stack s;
	StackInit(&s);
	StackPush(&s, right);
	StackPush(&s, left);
	while (!StackEmpty(&s))
	{
		int begin = StackTop(&s);
		StackPop(&s);

		int end = StackTop(&s);

		StackPop(&s);

		int key = _QuickSort(arr, begin, end);

		//[begin,key-1]
		//[0,1]
		//两个元素:key-1>begin
		if (key - 1 > begin)
		{
			StackPush(&s, key - 1);
			StackPush(&s, begin);
		}
		//[key+1,end]
		if (key + 1 < end)
		{
			StackPush(&s, end);
			StackPush(&s, key + 1);
		}
	}
}

层序遍历

void QuickSortNonR1_1(int* arr, int left, int right)
{
	Queue q;
	QueueInit(&q);
	QueuePushBack(&q, left);
	QueuePushBack(&q, right);
	while (!QueueEmpty(q))
	{
		int begin = QueueTop(q);
		QueuePopFront(&q);
		int end = QueueTop(q);
		QueuePopFront(&q);

		int key = _QuickSort(arr, begin, end);
		
		//[begin,key-1][key+1,end]
		if (begin < key - 1)
		{
			QueuePushBack(&q,begin);
			QueuePushBack(&q, key - 1);
		}
		if (key + 1 < end)
		{
			QueuePushBack(&q,key + 1);
			QueuePushBack(&q, end);
		}
	}
}

复杂度与稳定性

  • 时间复杂度
    在理想状况下
    【数据结构】带你细致理解八大排序_第6张图片
    每一层排序N个数据,设分h次把数据分完,则2的h次方就等于N个数据
    则:高度为log2N
    因此理想状况下时间复杂度为:O(N*log2N)
    最坏的情况
    当排升序数据是降序时,递归是N*(N-1)(N-2)……1——高度是N
    如图:
    【数据结构】带你细致理解八大排序_第7张图片
    时间复杂度可以估算为O(N2)
    这样数据大的话递归层数过多,甚至会导致栈溢出!

  • 空间复杂度——递归层数为logN到N因此空间复杂度为——O(logN)到O(N)

  • 稳定性
    在排序1 2 -1 -1时,由于左边的数据会先交换——1 -1 -1 2,破坏了相同数据的相对位置,因此快排不是稳定的。

优化

三数取中

int GetMid(int* arr, int left, int right)
{
	int mid = (left + right) / 2;
	if (arr[mid] > arr[left])
	{
		if (arr[right] >= arr[mid])
		{
			return mid;
		}
		else//arr[mid]>a[right]
		{
			if (arr[right] >= arr[left])
			{
				return right;
			}
			else
			{
				return left;
			}

		}
	}
	else//arr[left]>=arr[mid]
	{
		if (arr[mid] >= arr[right])
		{
			return mid;
		}
		else//arr[right]>arr[mid]
		{
			if (arr[right] >= arr[left])
			{
				return left;
			}
			else
			{
				return right;
			}
		}
	}
}

设置随机key

void Randkey(int* arr, int left, int right)
{
	srand((unsigned int)time(NULL));
	int key = rand() % (right - left) + left;
	Swap(&arr[key], &arr[left]);
}
  • 以上两种将最坏的情况的可能降到最低,但是如果大量的数据相同呢?
  • 时间复杂度毫无疑问还是O(N2),有什么方法解决吗?
  • 答案是有的——三路划分

七.归并排序

【数据结构】带你细致理解八大排序_第8张图片

递归写法

  • 将数据被拆分成有序的情况——一个的一个数据
  • 再将一个数据和另一数据进行排序。
  • 然后再用一组中含有连个数据排序与另一组中两个数据进行排序
  • 依次类推,直到整个数据有序
  • 排序需要用到另一个数组,排序完然后拷贝回去。
  • 注意:拷贝回去的起点需要注意。
//这是由于要开辟数据所以写了两个函数
void _MergeSort(int* arr, int* tmp, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int mid = (left + right) / 2;
	_MergeSort(arr, tmp, left, mid);
	_MergeSort(arr, tmp, mid + 1, right);
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (arr[begin1] <= arr[begin2])
		{
			tmp[i++] = arr[begin1++];
		}
		else
		{
			tmp[i++] = arr[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = arr[begin2++];
	}
	memcpy(arr + left, tmp + left, sizeof(int) * (right - left + 1));
	//切记arr跟arr+left指向的位置可不一样!
}
void MergeSort(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(int) * size);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	_MergeSort(arr, tmp, 0, size-1);
}

非递归写法

  • 从递归的最底层进行排序,也就是gap等于1
  • 不断分组进行排序——相当于倒着的层序遍历
  • 每一层遍历之后gap乘等2,直到大于原数组的大小为止
  • 其次还要考虑边界的处理

一把梭哈

void MerageSortNonR1_0(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(int) * size);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	int gap = 1;
	while (gap < size)
	{
		for (int i = 0; i < size; i += 2*gap)
		{
			//归并的两个区间
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			//修正越界的部分
			//首先begin1是不可能越界的
			//end1越界
			//修正end1
			//因为梭哈要全拷贝
			//修正end2与begin2满足begin2>=end2
			//begin2越界
			//修正end2与begin2满足begin2>=end2
			//end2越界
			//修正end2
			if (end1 >= size)
			{
				end1 = size - 1;
				begin2 = size;
				end2 = size - 1;
			}
			else if (begin1 >= size)
			{
				begin2 = size;
				end2 = size - 1;
			}
			else if (end2 >= size)
			{
				end2 = size - 1;
			}
			//排序
			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					tmp[j++] = arr[begin1++];
				}
				else
				{
					tmp[j++] = arr[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{

				tmp[j++] = arr[begin2++];
			}
		}
		//一下子梭哈
		memcpy(arr, tmp, sizeof(int) * size);
		//调整gap
		gap *= 2;
	}
}

分步拷贝

void MerageSortNonR1_1(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(int) * size);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	int gap = 1;
	while (gap < size)
	{
		for (int i = 0; i < size; i += 2 * gap)
		{
			//归并的两个区间
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			//修正越界的部分
			//首先begin1是不可能越界的
			//end1越界与begin2越界
			//直接跳出循环即可
			//end2越界
			//修正end2
			if (end1 >= size||begin2>=size)
			{
				break;
			}
			else if (end2 >= size)
			{
				end2 = size - 1;
			}
			//排序
			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] <= arr[begin2])
				{
					tmp[j++] = arr[begin1++];
				}
				else
				{
					tmp[j++] = arr[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{

				tmp[j++] = arr[begin2++];
			}
			//注意这里end2不能减去begin1+1因为这里的begin1在循环之后已经成为begin1l
			//真正的左区间是i
			memcpy(arr+i, tmp+i, sizeof(int) * (end2-i+1));
		}	
		//调整gap
		gap *= 2;
	}
}

稳定性与时间复杂度

  • 时间复杂度
    【数据结构】带你细致理解八大排序_第9张图片
    可以类比快排的理想状态,这里每一层都要排序,排序的次数等于层数。

设节点有N个。层数为h
则:2h = N,
h = log2N
因此时间复杂度为层数乘以每次排序的次数——O(N*logN)

  • 空间复杂度
    递归的空间消耗为——O(logN)
    额外开辟的空间为——O(N)
    因此:空间复杂度为O(N)

  • 稳定性
    在排序 1 12 和 1 2两组有序数组 时,1 2 和 1 2,如果相等则先放左边的,后放右边的,这样相对顺序就不会发生变化,因此归并排序是稳定的。

八.计数排序

void CountSort(int* arr, int size)
{
	//第一步:找最大最小确定数的范围
	int max = arr[0];
	int min = arr[0];
	//可不敢初始化为0,因为0不一定在数组内部
	for (int i = 0; i < size; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}

		if (arr[i] < min)
		{
			min = arr[i];
		}
	}
	int range = max - min + 1;
	//假如0到9为最大和最小,则[0,9]一共有9-0+1=10个数
	int* Count = (int*)calloc(range, sizeof(int) * range);
	if (Count == NULL)
	{
		perror("calloc fail");
		exit(-1);
	}
	//下标与数的关系为
	//F =x-min,F是下标,min是最小值,x是数
	//这是可以存负数的!
	//当存的最小值是-9时,下标为-9-(-9)= 0,最小值的下标为0
	for (int i = 0; i < size; i++)
	{
		Count[arr[i] - min]++;
	}
	//将记过的数再拷贝回原数组
	for (int i = 0,j = 0; i < range; i++)
	{
		while (Count[i]--)
		{
			arr[j++] = i + min;
		}
	}
}

复杂度

  • 时间复杂度

最大与最小值相差较小时,且数据比较集中(计数排序有奇效)时,我们可认为时间复杂度为O(N)

在最大值与最小值相差较大时,我们认为时间复杂度为O(N+range),range为最大值与最小值的数据范围

  • 空间复杂度

计数的数组的大小是额外开辟的空间,因此空间复杂度为O(range),range意思同上

  • 稳定性
    由于计数排序不是对原数组进行直接排序,所以稳定性我们不加讨论

你可能感兴趣的:(数据结构,算法,数据结构,排序算法,算法)