第二节课：8.10：常用排序算法上

第二节课：8.10：常用排序算法上

一、选择插入冒泡的比较：

选择和冒泡的比较次数多，交换次数也多，

而插入排序的比较次数较少，优化后的交换换成了赋值

可以举例来画流程图验证；

如：5，7，3，4，6

二、插入排序的算法流程和优化过程：

1.算法：

void insert_sort(int arr[], int len)
{
	3.进一步优化：
	int j = 0;
	int tempval = 0;
	for (int i = 1; i < len; ++i)//外层大循环，i为待插入元素的下标
	{
		tempval = arr[i];//保存待插入的元素
		j = i;
		while (j > 0 && tempval < arr[j - 1])//替换了break；
		{
				arr[j] = arr[j - 1];//减少了交换的步骤，改用赋值，次数更加的少
				--j;
		}
		arr[j] = tempval;
	}

    
    2.修改之后的算法
	//int j = 0;
	//int tempval = 0;
	//for (int i = 1; i < len; ++i)//外层大循环，i为待插入元素的下标
	//{
	//	tempval = arr[i];//保存待插入的元素
	//	for (j = i; j > 0; --j)
	//	{
	//		if (tempval < arr[j - 1])
	//		{
	//			arr[j] = arr[j - 1];//减少了交换的步骤，改用赋值，次数更加的少
	//		}
	//		else
	//			break;//break为指令，执行时间长
	//	}
	//	arr[j] = tempval;
	//}

    
    1.最初的插入算法
	//for (int i = 1; i < len; ++i)//外层大循环，i为待插入元素的下标
	//{
	//	for (int j = i; j > 0; --j)
	//	{
	//		if (arr[j] < arr[j - 1])
	//		{
	//			int temp = arr[j];
	//			arr[j] = arr[j - 1];
	//			arr[j - 1] = temp;
	//		}
	//		else
	//			break;
	//	}
	//}
}

2.新知识点：讲for改成while

for(int i = 0;i < len; ++i)
{
    //
}

i = 0;
while(i < len)
{
    ++i;
}

三、希尔排序：

1.希尔排序流程图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ygPcTgaZ-1630465951875)(8.10第二节课：常用排序算法上.assets/00AA7A277B21DED089B3F4D973AA0EFD.jpg)]

2.希尔排序code：

void Sell_sort(int arr[], int len)//快速记忆希尔排序的方法：插入排序将1改成jump
{
	int jump = 0;
	jump = len >> 1;
	int tempval = 0;
	while (jump > 0)
	{
		for (int i = jump; i < len; ++i)
		{
			int j = 0;
			tempval = arr[i];
			j = i - jump;
			while (j >= 0 && tempval < arr[j])
			{
				arr[j + jump] = arr[j];
				j = j - jump;
			}
			arr[j + jump] = tempval;
		}
		jump >>= 1;
	}
}

3.复习时：将希尔排序和插入排序多代入几种不同的数据来画流程图比较他们的效率

四、快速排序：

1.快速排序的流程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JK9dQEGK-1630465951877)(8.10第二节课：常用排序算法上.assets/D1EB21F74250A35B51099C254AD703D0.jpg)]

2.快速排序code：（未经过优化）

void quick_sort(int arr[], int low, int hight)
{
	int t = arr[low];//要确定标杆，要找这个值的正确位置
	int f = low + 1;//f指针，希望用来指向比标杆小的数
	int b = hight;//b指针，希望用来指向比标杆大的数
	if (low >= hight) return;//表示只有一个元素，这个元素无需定位
	int tempVal;
	while (f <= b)//表示等定位的区间还没有找完
	{
		while (f <= b && arr[f] <= t) f++;//如果当前f指的数比标杆小，f后移
		while (f <= b && arr[b] >= t) b--;//如果当前b指的数比标杆大，b前移
		if (f < b)//区间还没有搜索完成
		{
			tempVal = arr[f];
			arr[f] = arr[b];
			arr[b] = tempVal;
			f++;
			b--;
		}
	}
	arr[low] = arr[b];
	arr[b] = t;
	quick_sort(arr, low, b - 1);
	quick_sort(arr, b + 1, hight);
}

3.自己优化过后的代码：

void quick_sort(int arr[], int low, int high)
{
	static int  left_flag = 0;
	int t = arr[low];//标杆值
	int f = low + 1;
	int b = high;

	if (low >= high)//递归结束条件，先左递归结束
	{
		left_flag = 1;
		return;
	}

	while (f <= b)//定位标杆
	{

		//刚开始为了优化，理解错误：将f <= b &&的语句删除了
		/*while (t >= arr[f]) f++;
		while (t <= arr[b]) b--;*/

		while (f <= b && t >= arr[f]) f++;//找到标杆值大的   while (f <= b && arr[f] <= t) &&前面的就是为了防止数组越界的操作
		while (f <= b && t <= arr[b]) b--;//找到比标杆值小的
		if (f <= b)
		{
			
			arr[f] = arr[f] ^ arr[b];
			arr[b] = arr[b] ^ arr[f];
			arr[f] = arr[f] ^ arr[b];
			f++;
			b--;
		}
	}

	//将标杆值送到对应位置上去
	arr[low] = arr[b];
	arr[b] = t;

	if (0 == left_flag)
	quick_sort(arr, low, b - 1);//左递归

	quick_sort(arr, b + 1, high);//右递归,1.右递归会越界 加上f<=b && 的条件防止越界，2.右递归每次递归都要重复左递归，效率低
}

五、遇到新的特定的算法应该怎么样去学：

直接用数字例子去带入->画流程图->计算

换另外的例子接着计算，多算几次，大概的流程就会了