基础数据结构16:排序

1.

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
//八大排序   排序分为升序和降序   我们默认使用升序
//算法的描述  算法的实现  算法的评价（时间复杂度，空间复杂度，稳定性）
//什么是稳定性：如果排序前A在A`的前面，排序之后A孩子A`的前面，则排序算法稳定
//如何判断其稳定性：看算法中是否存在跳跃交换
//第一个排序算法：直接插入排序：每次从待排序队列中取一个值，放到已排序好的队列，再次保持有序，重复这样的动作，直到把待排序队列中的值全部取完  时间复杂度O（n^2） 空间复杂度O（1）  稳定的
//第二个排序算法：希尔排序（缩小增量排序）：是一个特殊的直接插入排序，相当于多次调用直接插入排序，每一次的增量保持互素，并且最后一个增量一定位1，为1才能保证其完全有序   时间复杂度O(n^1.3~1.5) 空间复杂度O(1)  不稳定
//第三个排序算法：冒泡排序（沉石排序）：两两比较，大的向后挪动，小的向前  时间复杂度O（n^2） 空间复杂度O（1）  稳定的（不存在跳跃交换）
//第四个排序算法：二路归并排序（非递归形式）：两两合并成一个组，当合并后的组能容纳arr所有值的时候，则退出，因为此时已经组内完全有序   时间复杂度O(nlogn)  空间复杂度O（nlogn） 稳定
//第五个排序算法：简单选择排序：每一次将待排序序列中最小值和待排序序列中第一个值进行交换 直到完全有序即可  时间复杂度O（n^2） 空间复杂度O（1）  不稳定
//第六个排序算法：将一维数组臆想成一个完全二叉树，再将其调整为大顶堆，再将根节点和尾节点进行交换，再次进行调整，这样循环往复，直至将其调整为完全有序   时间复杂度O（nlogn） 空间复杂度O（1）  不稳定  



void InsertSort(int arr[], int len)
{
	assert(arr != NULL);
	if(arr == NULL)
	{
		return;
	}

	int count = 0;
	int tmp;
	int j;//将j的生存周期提高，保证break后的的代码arr[j+1] = tmp;有效
	for(int i=1; i<len; i++)//每次从待排序队列中取的值
	{
		tmp = arr[i];//用tmp保存待插入的值
		for(j=i-1; j>=0; j--)//从右向左找不比tmp大的值
		{
			if(arr[j] > tmp)//如果比tmp大  则向右放一格
			{
				arr[j+1] = arr[j];
				count++;
			}
			else//如果不比tmp大
			{
				break;
			}
		}

		arr[j+1] = tmp;
	}
	printf("swap: %d\n", count);
}
void Show(int arr[], int len)
{
	for(int i=0; i<len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}


int count2 = 0;
static void Shell(int arr[], int len, int gap)
{
	int tmp;
	int j;//将j的生存周期提高，保证break后的的代码arr[j+1] = tmp;有效
	for(int i=gap; i<len; i++)//每次从待排序队列中取的值
	{
		tmp = arr[i];//用tmp保存待插入的值
		for(j=i-gap; j>=0; j=j-gap)//从右向左找不比tmp大的值
		{
			if(arr[j] > tmp)//如果比tmp大  则向右放一格
			{
				arr[j+gap] = arr[j];
				count2++;
			}
			else//如果不比tmp大
			{
				break;
			}
		}

		arr[j+gap] = tmp;
	}
}
void ShellSort(int arr[], int len)
{
	//assert

	int gap[] = {5, 3, 1};
	int lengap = sizeof(gap)/sizeof(gap[0]);
	for(int i=0; i<lengap; i++)
	{
		Shell(arr, len, gap[i]);//5 3 1
	}
	

}

void BubbleSort(int arr[], int len)
{
	bool tag = true;//优化标记   如果当前这轮存在一次交换  则tag变成FALSE   
	                 //当tag为true不就代表着不存在前面比后面大 
	                 //则已经完全有序  那直接退出即可  剩余轮次不需要执行
	int count = 0;
	for(int i=0; i<len-1; i++)//少一轮
	{
		tag = true;
		for(int j=0; j+1<len-i; j++)//j<len-1-i
		{
			if(arr[j] > arr[j+1])//两两比较 前面大于后面 则交换两个值
			{
				tag = false;
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
		count++;
		if(tag)
		{
			break;
		}
	}
	printf("跑了%d趟\n", count);
}

//一次融合的代码   时间复杂度O（n）
static void Merge(int arr[], int len, int gap)//gap->几几合并的几
{
	int *brr = (int*)malloc(sizeof(int) * len);//申请额外的辅助空间brr
	assert(brr != NULL);
	int i = 0;//i指向brr的下标
	
	//申请四个指针  用low1 high1来表示左边的组的边界  用low2 high2来表示右边的组的边界 
	int low1 = 0;
	int high1 = low1+gap-1;
	int low2 = high1+1;
	int high2 = low2+gap-1<len ? low2+gap-1 : len-1;
	//low2+gap-1是我应得的   len如果大于我应得的  则该给我多少就给多少  如果小则将你剩余的都给我

	while(low2 < len)//我抓的两个组都存在   low2<len则代表右手没抓空  而右手没抓空 则左手肯定也没抓空  则证明两手都抓中了
	{
		while(low1<=high1 && low2<=high2)//两个组都还有数据  则接着比较向下取到brr内
		{
			if(arr[low1] <= arr[low2])
			{
				brr[i++] = arr[low1++];
			}
			else
			{
				brr[i++] = arr[low2++];
			}
		}
		//此时肯定有一组数据没了 那么将另一组数据直接挪到brr内即可
		//但此时需要判断左右手哪个抓的组里没数据了
		while(low1 <= high1)//左手抓的组里面还有数据 在直接挪到brr内
		{
			brr[i++] = arr[low1++];
		}
		while(low2 <= high2)//右手抓的组里面还有数据 在直接挪到brr内
		{
			brr[i++] = arr[low2++];
		}

		low1 = high2+1;
		high1 = low1 + gap-1;
		low2 = high1+1;
		high2 = low2+gap-1<len ? low2+gap-1 : len-1;

	}

	//此时肯定不能同时两手都抓到组   而且可以得到一个信息  那就是（只可能右手抓的组是空的）
	//左手抓上一个组 右手抓空  接下来只需要将左手的组原样挪下来即可
	while(low1 < len)//左手抓的组里面还有数据 在直接挪到brr内
	{
		brr[i++] = arr[low1++];
	}

	//最后一步：将辅助空间brr里的数据全部重新拷贝到arr里
	for(int i=0; i<len; i++)
	{
		arr[i] = brr[i];
	}
	free(brr);//最后记得将malloc来的brr释放掉  避免内存泄露
	brr = NULL;

}

void MergeSort(int arr[], int len)
{
	//assert
	for(int i=1; i<len; i*=2)//11融合 22融合  44融合  88融合  直到融合后的组包含了arr所有值
	{
		Merge(arr, len, i);//logn次 * O（n）  = nlogn
	}
}

//时间复杂度 O（n^2）  空间复杂度O（1） 稳定吗？  不稳定
void SelectSort(int *arr, int len)
{
	//assert
	int minindex;//minindex 保存的是最小值的下标

	for(int i=0; i<len-1; i++)//趟数  总数少一趟
	{
		minindex = i;//每趟循环一进来  我们首先认为待排序序列的第一个值是最小值 所以minindex先赋值为i
		for(int j=i+1; j<len; j++)//从待排序序列的第二个值开始和arr[minindex]比较
		{
			if(arr[j] < arr[minindex])//如果找到更小的数  则minindex重新赋值为新的最小值的下标
			{
				minindex = j;
			}
		}
		//此时for循环执行结束  代表着minindex保存的就是最小值的下标
		
		//直接进行交换
		if(i != minindex)
		{
			int tmp = arr[i];//因为i保存的是待排序序列第一个值
			arr[i] = arr[minindex];
			arr[minindex] = tmp;
		}
	}
}


void HeapAdjust(int arr[], int start, int end)
{
	int tmp = arr[start];

	for(int i=start*2+1; i<=end; i=start*2+1)//语句3 精髓  时间复杂度O（nlogn）的原因
	{
		if(i<end && arr[i] < arr[i+1])//有右孩子 并且右孩子比左孩子大 
		{
			i++;
		}
		//如果if为假   代表要么右孩子不存在  要么右孩子存在 但是小于左孩子
		//此时 i保存的是左右孩子中较大的值的下标
		//接着让父子比较

		if(arr[i] > tmp)
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;
		}
	}
	//此时for循环推出了，要么此时触底  要莫if(arr[i]>tmp)为假  break跳出循环

	arr[start] = tmp;
}

void HeapSort(int arr[], int len)
{
	//1.先调整成大顶堆
	for(int i=(len-1-1)/2; i>=0; i--)//O（n）
	{
		HeapAdjust(arr, i, len-1);//（logn）    
	}//两个一乘   则时间复杂度O（nlogn）

	//根节点和尾节点交换
	for(int i=0; i<len-1; i++)//O（n）
	{
		int tmp = arr[0];
		arr[0] = arr[len-1-i];//9 8 7 6 5 4 3 2 1
		arr[len-1-i] = tmp;

		HeapAdjust(arr, 0, (len-1-i)-1);//(len-1-i)相当于最后一个节点的下标  然后最后一个节点不参与计算 则再-1
	}
}
int main()
{
	int arr[] = {1,3,2,4,6,5,7,9,8};
	int len = sizeof(arr)/sizeof(arr[0]);

	//InsertSort(arr, len);
	//ShellSort(arr, len);
	//printf("swap = %d\n", count2);
	//BubbleSort(arr, len);
	//MergeSort(arr, len);
	//SelectSort(arr, len);
	HeapSort(arr, len);
	Show(arr, len);


	return 0;
}

简单选择排序：每次从待排序序列中找到最小值和待排序序列的第一个数值进行交换。交换时候保存的是最小值的下标。
堆排序：以完全二叉树结构来管理的一堆数组。
大顶堆：父节点的值大于子节点
小顶堆：父节点的值小于子节点
1.为什么要选择大顶堆：因为每次调整后的根节点的值是最大值，我们将其放到最后，实现从小到大排序。
2.调整规则：从最后一个非叶子节点从后向前开始调整，从上向下开始调整