C语言描述数据结构 —— 常见排序(2)冒泡排序、快速排序

已于 2022-09-06 15:47:46 修改
阅读量734 收藏 9
点赞数 21
文章标签： 数据结构 c语言 排序算法
于 2022-09-06 15:20:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59913110/article/details/126723082
版权

目录

1.冒泡排序

冒泡排序在C语言的部分提到过，它可以说是我们认识第一个认识的排序算法。虽然它的时间复杂度为 O(N^2) ，但是它也是可以存在一些优化的，在一定角度上来将，冒泡的效率是高于选择排序的。既然我们介绍过冒泡排序，这里就直接写代码了。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//冒泡排序
void BubbleSort(int* a, int n)
{
	assert(a);
	int flag = 0;
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n -i-1; j++)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
				flag = 1;
			}
		}
		//如果第一遍遍历为有序，那么就不用排序了
		if (!flag)
		{
			break;
		}
	}
}

int main()
{
	int size = 10;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	BubbleSort(arr, size);
	Print(arr, size);
	return 0;
}

2.快速排序基本思想

快速排序是1962年由Hoare提出的一种二叉树结构的排序方法。其思想我们可以这么理解：我们在待排序的元素当中选取一个基准值，经过排序的操作，使得这个基准值的左边是比它小的数；这个基准值的右边是比它大的数。由此就被待排序元素就被分成了两个区间，这两个区间又重复这样的操作。
在这里插入图片描述
由此可见，快速排序是需要用到递归的，而这又衍生出三种排序的方法：Hoare法、挖坑法、前后指针法。

3.Hoare法快速排序

我们介绍过二叉树的各种递归，其核心就是要掌握每次递归都要干些什么。在快速排序中，其核心就是要掌握单趟排序。那么Hoare法是一个怎样的排序方法呢？
在这里插入图片描述
递归也是重复同样的过程：选取一个一个数作为key(一般都是选取最左边或最右边的值)，然后让right指针先走(如果选取最左边的值作为key，那么一定要让right先走)，找到比key小的数停下，让left指针走找到比key大的数停下，交换left和right位置的值。重复，直到left和right指针相遇便交换和key位置的值，进行下一轮递归。用代码描述是更加清晰的：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>


void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//Hoare法单趟排序
int PartSort1(int* a, int left, int right)
{
	assert(a);
	int keyi = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		if (left < right)
		{
			Swap(&a[left], &a[right]);
		}
	}
	int meeti = left;
	Swap(&a[keyi], &a[meeti]);
	return meeti;

}

//快速排序递归
void QuickSort(int* a, int left, int right)
{
	assert(a);
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort1(a, left, right);
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}
int main()
{
	int size = 1000000;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

在这里插入图片描述
不过我们存在一个问题。我们刚才提到，快速排序是二叉树结构的，那如果是逆序或者有序的元素，我们还能建立二叉树结构吗？
在这里插入图片描述
我们只要选好了中位数，再把这个中位数与最左边的数交换一下就好了。也就是说key的位置还是不变，还是最左边。接下来就到了优化代码的环节：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>


void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidNum(int* a, int left, int right)
{
	assert(a);
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//Hoare法单趟排序
int PartSort1(int* a, int left, int right)
{
	assert(a);
	//找到中位数并与 left 进行交换
	int mid = GetMidNum(a, left, right);
	Swap(&a[left], &a[mid]);

	int keyi = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		if (left < right)
		{
			Swap(&a[left], &a[right]);
		}
	}
	int meeti = left;
	Swap(&a[keyi], &a[meeti]);
	return meeti;

}

//快速排序递归
void QuickSort(int* a, int left, int right)
{
	assert(a);
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort1(a, left, right);
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}
int main()
{
	int size = 1000000;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

同样的，我么知道，二叉树的最后一层的节点数占了总结点数的一半。如果我们将最后三层的递归将它用直接插入排序进行排序的话，大家想想，是不是可以起到减少递归次数的作用？那么我们继续优化：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

//直接插入排序
void InsertSort(int* a,int n)
{
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidNum(int* a, int left, int right)
{
	assert(a);
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//Hoare法单趟排序
int PartSort1(int* a, int left, int right)
{
	assert(a);
	//找到中位数并与 left 进行交换
	int mid = GetMidNum(a, left, right);
	Swap(&a[left], &a[mid]);

	int keyi = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		if (left < right)
		{
			Swap(&a[left], &a[right]);
		}
	}
	int meeti = left;
	Swap(&a[keyi], &a[meeti]);
	return meeti;

}

//快速排序递归
void QuickSort(int* a, int left, int right)
{
	assert(a);
	if (left >= right)
	{
		return;
	}
	//STL的源代码的数值为 16
	if (right - left <= 16)
	{
		InsertSort(a+left, right - left + 1);
	}
	else
	{
		int keyi = PartSort1(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
	
}
int main()
{
	int size = 1000000;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

倒数第三层左右的剩余排序元素为 8 个左右。但是参考了源码，这里将值设置为 16。

4.挖坑法快速排序

挖坑法，实际上与Hoare是一样的。我们简单的画图分析一下：
在这里插入图片描述
我们用代码描述也是非常简单的：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

//直接插入排序
void InsertSort(int* a,int n)
{
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidNum(int* a, int left, int right)
{
	assert(a);
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//挖坑法
int PartSort2(int* a, int left, int right)
{
	assert(a);
	int mid = GetMidNum(a, left, right);
	Swap(&a[left], &a[mid]);
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;

		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}

//快速排序递归
void QuickSort(int* a, int left, int right)
{
	assert(a);
	if (left >= right)
	{
		return;
	}
	//STL的源代码的数值为 16
	if (right - left <= 16)
	{
		InsertSort(a+left, right - left + 1);
	}
	else
	{
		//int keyi = PartSort1(a, left, right);
		int keyi = PartSort2(a, left, right);

		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
	
}
int main()
{
	int size = 10;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

5.前后指针法快速排序

前后指针法就跟上面的两种方法有些差别了，我们来看图：
在这里插入图片描述
我们用代码描述：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

//直接插入排序
void InsertSort(int* a,int n)
{
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidNum(int* a, int left, int right)
{
	assert(a);
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

int PartSort3(int* a, int left, int right)
{
	assert(a);
	int mid = GetMidNum(a, left, right);
	Swap(&a[left], &a[mid]);
	int keyi = left;
	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[keyi], &a[prev]);
	return prev;
}

//快速排序递归
void QuickSort(int* a, int left, int right)
{
	assert(a);
	if (left >= right)
	{
		return;
	}
	//STL的源代码的数值为 16
	if (right - left <= 16)
	{
		InsertSort(a+left, right - left + 1);
	}
	else
	{
		//int keyi = PartSort1(a, left, right);
		//int keyi = PartSort2(a, left, right);
		int keyi = PartSort3(a, left, right);

		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
	
}
int main()
{
	int size = 10;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

6.非递归的快速排序

使用递归的方式来实现快排是相对来说比较简单的。那么我们如何使用循环来代替递归呢？我们学过一种数据结构——栈。我们结合栈来实现非递归实现非递归快速排序。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include "Stack.h"

//直接插入排序
void InsertSort(int* a,int n)
{
	assert(a);
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
void Print(int* a, int n)
{
	assert(a);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
}
void Swap(int* p1, int* p2)
{
	assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidNum(int* a, int left, int right)
{
	assert(a);
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

int PartSort3(int* a, int left, int right)
{
	assert(a);
	int mid = GetMidNum(a, left, right);
	Swap(&a[left], &a[mid]);
	int keyi = left;
	int prev = left;
	int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			prev++;
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[keyi], &a[prev]);
	return prev;
}

//快速排序递归
//void QuickSort(int* a, int left, int right)
//{
//	assert(a);
//	if (left >= right)
//	{
//		return;
//	}
//	//STL的源代码的数值为 16
//	if (right - left <= 16)
//	{
//		InsertSort(a+left, right - left + 1);
//	}
//	else
//	{
//		//int keyi = PartSort1(a, left, right);
//		//int keyi = PartSort2(a, left, right);
//		int keyi = PartSort3(a, left, right);
//
//		QuickSort(a, left, keyi - 1);
//		QuickSort(a, keyi + 1, right);
//	}
//	
//}

//非递归快速排序
void QuickSort(int* a, int left, int right)
{
	assert(a);
	Stack st;
	StackInit(&st);
	//先入右，再入左
	StackPush(&st, right);
	StackPush(&st, left);
	while (!StackEmpty(&st))
	{
		//取的便是先左、后右
		int left = StackTop(&st);
		StackPop(&st);
		int right = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort3(a, left, right);
		//先将右区间入栈
		if (keyi+1 < right)
		{
			//先入右，再入左
			StackPush(&st, right);
			StackPush(&st, keyi+1);
		}

		//再将左区间入栈
		if (left<keyi-1)
		{
			//先入右，再入左
			StackPush(&st, keyi-1);
			StackPush(&st, left);
		}
		
	}
}
int main()
{
	int size = 1000000;
	int* arr = (int*)malloc(sizeof(int) * size);
	assert(arr);
	srand((unsigned int)time(NULL));
	for (int i = 0; i < size; i++)
	{
		arr[i] = rand();
	}
	//BubbleSort(arr, size);
	QuickSort(arr, 0, size - 1);
	Print(arr, size);
	return 0;
}

在这里插入图片描述

7.总结

无论是哪一种方式实现快速排序，它的效率都非常高。如果有热爱数学、计算的朋友，一定能算出快速排序的时间复杂度，O(NlogN)。当我们优化快排之后，能适用于很多场景，并且效率很高。所以C语言的库中有 qsort 这么一个函数。

小龙向钱进
关注
常见排序算法之交换排序——冒泡排序、快速排序
保护小周ღ的博客
07-07 3550
​ 哈喽大家好，我是保护小周ღ，本期为大家带来的是常见排序算法中的交换排序，主要有冒泡排序，快速排序，快排分享了三种算法：挖坑法，左右指针法，前后指针法，以及两种优化方式：解决快排最坏情况的“三数取中”，避免递归次数过多的"小区间优化"，包您一看就会，快来试试吧~ ​......
C语言数据结构——排序类算法
h2608011009的博客
06-01 490
文章目录前言基于插入的排序算法直接插入排序希尔排序基于选择的排序算法直接选择排序堆排序冒泡排序分治类排序算法快速排序归并排序计数排序（非比较排序） 前言 这几天耗费了大量的时间去理清排序类算法的实现以及复杂度，对排序也算是略懂一二，下面博主就进行详细的介绍算法的思路与实现过程的代码。 基于插入的排序算法 这一类算法类似于，有序的整理扑克牌，将牌不断插入从而形成有序的牌堆。 插入类排序与之类似，其主要分为直接插入排序以及衍生出来的希尔排序。 直接插入排序 使用最后一个元素与其数组其他元素通过遍历比较，找到需
快速排序c语言实验报告,冒泡排序和快速排序实验报告.doc
weixin_31782323的博客
05-23 1199
冒泡排序和快速排序实验报告.doc下载提示(请认真阅读)1.请仔细阅读文档，确保文档完整性，对于不预览、不比对内容而直接下载带来的问题本站不予受理。2.下载的文档，不会出现我们的网址水印。3、该文档所得收入(下载+内容+预览)归上传者、原创作者；如果您是本文档原作者，请点此认领！既往收益都归您。文档包含非法信息？点此举报后获取现金奖励！下载文档到电脑，查找使用更方便12积分还剩页未读，继续阅读关...
冒泡排序和快速排序（C语言实现）
qq_54717101的博客
10-15 680
C语言实现快排和冒泡排序
排序（三）冒泡排序与快速排序（C语言实现）
qq_64662686的博客
07-06 942
冒泡排序与快速排序
冒泡排序，快速排序和堆排序 C语言实现（湖北汽车工业学院数据结构实验）
qing_shi的博客
12-30 572
冒泡排序算法，完成对数组list中的index个数进行排序。 // An highlighted block void bubbleSort(int *list, int index) { int i,j,a; for(i=0;i<index;i++) for(j=0;j<index-1;j++) { if(list[j]>list[j+1]) {
C语言实现冒泡排序、选择排序、快速排序
qq_43605229的博客
08-15 1088
冒泡法排序相对来说比选择法简单，由于冒泡法每次都要交换元素的顺序，而选择法则只需要记录元素的下标，因此冒泡法效率较低。对于数据较小的数组，运用冒泡法足以胜任，对于数据较大的数组，选择法排序的效率会明显提高。1.2 如果first...
基于C语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等
04-05
本课程设计实例集合了10个核心的数据结构问题，包括二叉树的建立、遍历，以及常用的排序算法——冒泡排序和快速排序。下面将详细解析这些知识点。 一、数据结构 数据结构是编程中用于组织和管理大量数据的方法。...
c语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等
11-27
本课程设计实例聚焦于10个关键的数据结构问题，其中包括二叉树的建立、遍历，以及两种常见的排序算法——冒泡排序和快速排序。 一、数据结构基础 数据结构是存储和组织数据的方式，它可以是简单的线性结构如数组或...
快速排序与冒泡排序的效率对比
ghijrf的博客
12-31 2159
快速排序与冒泡排序的效率对比 鄙人在这里谈一下自己对冒泡排序与快速排序的看法，在经过详细的浏览代码以及文章后，我们可以得出以下结论： 1 快速排序是冒泡排序的一种改进，跟冒泡排序有一定的区别。 2. 首先快速排序是选取一个基准数值（数值可以是任何数字），然后在与其他的数字进行比较，比基准数大的放在基准数的左边女，比基准数小的放在右边，与基准数相等的可以任意放置。 ...
冒泡排序
ypjsdtd的博客
12-19 139
1、程序文件 #include &amp;lt;stdio.h&amp;gt; // 两两交换 void mySwap(int *a, int i, int j) { int tmp = a[i]; a[i] = a[j]; a[j] = tmp; } // 冒泡排序 void mySort(int *a, int len) { int i; int j; // 第一次循环遍历整个数组，找出最...
C语言常用排序算法---冒泡排序，选择排序，快速排序
wzk456的专栏
02-26 738
冒泡排序：两两之间进行比较，把大的移到后面，每轮比较之后之后一个就是最大的 #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h.h&gt; //从头向尾遍历 //相邻两数进行比较 //将最大数(相对)沉入尾部(相对) void BubbleSort1(int *arr,int sz){ ...
【排序】数据结构——排序算法概念及代码详解（插入、冒泡、快速、希尔）
皮皮不调皮的博客
03-29 981
排序一、排序基本概念1、稳定性2、内排序与外排序3、性能分析二、插入排序1、思路2、时间复杂度分析3、示例代码4、代码分析三、冒泡排序1、概念2、时间复杂度3、思路4、示例代码5、代码分析四、快速排序1、概念2、思路3、示例代码五、希尔排序1、比较插入排序和希尔排序2、概念3、示例代码 一、排序基本概念 排序是处理数据的一种最常见的操作，所谓排序就是将数据按某字段规律排列，所谓的字段就是数据节点的其中一个属性。比如一个班级的学生，其字段就有学号、姓名、班级、分数等等，我们既可以针对学号排序，也可以针对分数排
14_L3缓存友好的数据结构
刘炫320的博客
09-11 638
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
21_动态规划与数据结构结合
刘炫320的博客
09-11 491
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 563
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
从头开始嵌入式第三十八天（数据结构 双向链表）
最新发布
qq_64792908的博客
09-11 629
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
【Python】数据结构,链表,算法详解
2201_75415080的博客
09-09 1773
自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树"""案例: 自定义代码, 模拟链表.​背景:顺序表在存储数据的时候, 需要使用到连续的空间, 如果空间不够, 就会导致扩容失败, 针对于这种情况, 我们可以通过链表实现.链表在内存中存储的时候, 可以不是连续的空间, "有地儿就行", 所以: 增删相对更好操作.​。
C语言数据结构：冒泡与快速排序耗时对比
在"算法耗时的实际测试-数据结构C语言版"这篇文章中，作者通过实例探讨了两种常见排序算法——冒泡排序和快速排序在处理大量数据时的实际性能差异。文章以数据元素个数为30000为例，展示了在C语言环境下进行的测试。...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小龙向钱进

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值