初阶数据结构之排序（完整版）

于 2024-08-21 22:12:10 发布
阅读量627 收藏 14
点赞数 13
文章标签： 数据结构 算法 排序算法 c语言 开发语言 链表 visualstudio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Xuhhh/article/details/141403913
版权

排序

插⼊排序

基本思想

直接插⼊排序是⼀种简单的插⼊排序法，其基本思想是：把待排序的记录按其关键码值的⼤⼩逐个插 ⼊到⼀个已经排好序的有序序列中，直到所有的记录插⼊完为⽌，得到⼀个新的有序序列 。

在这里插入图片描述

实际中我们玩扑克牌时，就⽤了插⼊排序的思想

直接插⼊排序

当插⼊第 i(i>=1) 个元素时，前⾯的 array[0],array[1],…,array[i-1] 已经排好序，此时 ⽤ array[i] 的排序码与 array[i-1],array[i-2],… 的排序码顺序进⾏⽐较，找到插⼊位置 即将 array[i] 插⼊，原来位置上的元素顺序后移

在这里插入图片描述

InsertSort.h

#pragma once
#include <stdio.h>

void InsertSort(int* arr, int n);

void Print(int* arr, int n);

InsertSort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "InsertSort.h"
 
void InsertSort(int* arr, int n)
{
	//外层循环控制内部要进行多少次
	//n-1是因为end+1的时候，end=n的话，会造成越界
	for (int i = 0; i < n - 1; i++)
	{
		//end表示有序数组的最后一位
		int end = i;
		//tmp表示有序数组的下一位
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				//这是从后往前进行比较
				end--;
			}
			//如果顺序不用变动，就跳出循环
			else
			{
				break;
			}
		}
		//最后循环出来得到的结果
		arr[end + 1] = tmp;
	}
}
void Print(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "InsertSort.h"
int main()
{
	int arr[] = { 3,4,2,1,6,5,7,9,8 };
	int n = sizeof(arr) / sizeof(arr[0]);
	InsertSort(arr, n);
	Print(arr, n);
	return 0;
}

直接插⼊排序的特性总结

1.元素集合越接近有序，直接插⼊排序算法的时间效率越⾼

2.时间复杂度：O(N^2)

3.空间复杂度：O(1)

注意点：最不好的情况是降序排序的时候

那么我们该怎样进一步优化呢，接下来我们来看希尔排序

希尔排序

希尔排序法⼜称缩⼩增量法。希尔排序法的基本思想是：先选定⼀个整数（通常是gap = n/3+1），把 待排序⽂件所有记录分成各组，所有的距离相等的记录分在同⼀组内，并对每⼀组内的记录进⾏排 序，然后gap=gap/3+1得到下⼀个整数，再将数组分成各组，进⾏插⼊排序，当gap=1时，就相当于 直接插⼊排序。

它是在直接插⼊排序算法的基础上进⾏改进⽽来的，综合来说它的效率肯定是要⾼于直接插⼊排序算 法的。

在这里插入图片描述

代码如下：

ShellSort.h

#pragma once
#include <stdio.h>

void ShellSort(int* arr, int n);
void Print(int* arr, int n);

ShellSort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "ShellSort.h"

void ShellSort(int* arr, int n)
{
	int gap = n;
	//不能够等于1，等于1的时候会造成死循环，因为下面的+1是保证最后gap=1的
	while (gap>1)
	{
		gap = gap / 3 + 1;//保证最后gap=1
        //使用i++是分成三组，分别比较每组的第一个大小，再比较两组的第二个，这样时间复杂度进一步降低
		for (int i = 0; i < n - gap; i++)//相较于直接排序时间复杂度小一点
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end+gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}
void Print(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "ShellSort.h"

int main()
{
	int a[] = { 2,1,4,3,5,6,8,7,9,10 };
	int n = sizeof(a) / sizeof(a[0]);
	ShellSort(a, n);
	Print(a, n);
	return 0;
}

希尔排序的特性总结

1.希尔排序是对直接插⼊排序的优化。

2.当 gap > 1 时都是预排序，⽬的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序 的了，这样就会很快。这样整体⽽⾔，可以达到优化的效果。

更进一步来说就是：

1.预排序 gap>1

2.直接插入排序 gap=1

小的靠前，大的靠后

希尔排序的时间复杂度计算

希尔排序的时间复杂度估算：

外层循环：

外层循环的时间复杂度可以直接给出为： O(log2 n) 或者 O(log3 n) ，即 O(log n)

内层循环：

在这里插入图片描述

在这里插入图片描述

希尔排序时间复杂度不好计算，因为 gap 的取值很多，导致很难去计算，因此很多书中给出的希尔排 序的时间复杂度都不固定。

  • 《数据结构(C语⾔版)》— 严蔚敏书中给出的时间复杂度为：

在这里插入图片描述

选择排序

选择排序的基本思想：

每⼀次从待排序的数据元素中选出最⼩（或最⼤）的⼀个元素，存放在序列的起始位置，直到全部待 排序的数据元素排完 。

直接选择排序

1.在元素集合 array[i]–array[n-1] 中选择关键码最⼤(⼩)的数据元素

2.若它不是这组元素中的最后⼀个(第⼀个)元素，则将它与这组元素中的最后⼀个（第⼀个）元素 交换

3.在剩余的 array[i]–array[n-2]（array[i+1]–array[n-1]） 集合中，重复上述步 骤，直到集合剩余 1 个元素

在这里插入图片描述

代码实现过程如下：

SelectSort.h

#pragma once
#include <stdio.h>
void Swap(int* x, int* y);
void SelectSort(int* arr, int n);
void Print(int* arr, int n);

SelectSort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SelectSort.h"
//交换数组内的元素
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//选择排序
void SelectSort(int* arr, int n)
{
	//end=n-1是为了防止越界
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		//begin+1是为了减少比较的次数
		int mini = begin;
		int maxi = begin;
		for (int i = begin + 1; i <= end; i++)
		{
			if (arr[maxi] < arr[i])
			{
				maxi = i;
			}
			if (arr[mini] > arr[i])
			{
				mini = i;
			}
		}
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&arr[begin], &arr[mini]);
		Swap(&arr[end], &arr[maxi]);
		begin++;
		end--;
	}
	
}
void Print(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SelectSort.h"

int main()
{
	int arr[] = { 3,4,5,1,2,7,8,6,9 };
	int n = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr, n);
	Print(arr, n);
	return 0;
}

直接选择排序的特性总结：

1.直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使⽤

2.时间复杂度： O(N2)

3.空间复杂度： O(1)

交换排序

交换排序基本思想：

所谓交换，就是根据序列中两个记录键值的⽐较结果来对换这两个记录在序列中的位置 交换排序的特点是：将键值较⼤的记录向序列的尾部移动，键值较⼩的记录向序列的前部移动

快速排序

快速排序是Hoare于1962年提出的⼀种⼆叉树结构的交换排序⽅法，其基本思想为：任取待排序元素 序列中的某元素作为基准值，按照该排序码将待排序集合分割成两⼦序列，左⼦序列中所有元素均⼩ 于基准值，右⼦序列中所有元素均⼤于基准值，然后最左右⼦序列重复该过程，直到所有元素都排列 在相应位置上为⽌。

hoare版本

算法思路 ：

1）创建左右指针，确定基准值

2）从右向左找出⽐基准值⼩的数据，从左向右找出⽐基准值⼤的数据，左右指针数据交换，进⼊下次 循环

问题1：为什么跳出循环后right位置的值⼀定不⼤于key？

当 left > right 时，即right⾛到left的左侧，⽽left扫描过的数据均不⼤于key，因此right此时指 向的数据⼀定不⼤于key

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

代码如下：

QuickSort.h

#pragma once
#include <stdio.h>

void Swap(int* x, int* y);
int _QuickSort(int* arr, int left, int right);
void QuickSort(int* arr, int left, int right);
void Print(int* arr, int n);

QuickSort.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "QuickSort.h"
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
//找基准值
int _QuickSort(int* arr, int left, int right)
{
	//keyi表示基准值
	int keyi = left;
	left++;
	//取等号是一个关键，如果不取等号会造成left和right相遇比基准值大
	while (left <= right)
	{
		//这里数组里面的值不取等，是因为要跳出循环，保证基准值在序列的中间位置
		while (left <= right && arr[right] > arr[keyi])
		{
			right--;
		}
		while (left <= right && arr[left] < arr[keyi])
		{
			left++;
		}
		if (left <= right)
		{
			//这里也是细节
			Swap(&arr[left++], &arr[right--]);
		}
	}
	Swap(&arr[keyi], &arr[right]);
	return right;
}
//快速排序
void QuickSort(int* arr, int left, int right)
{
	if (left <= right)
	{
		return;
	}
	//第一步找基准值
	int keyi = _QuickSort(arr, left, right);
	//左子序列
	QuickSort(arr, left, keyi - 1);
	//右子序列
	QuickSort(arr, keyi + 1, right);
}
挖洞法

思路： 创建左右指针。⾸先从右向左找出⽐基准⼩的数据，找到后⽴即放⼊左边坑中，当前位置变为新 的"坑"，然后从左向右找出⽐基准⼤的数据，找到后⽴即放⼊右边坑中，当前位置变为新的"坑"，结 束循环后将最开始存储的分界值放⼊当前的"坑"中，返回当前"坑"下标（即分界值下标）

在这里插入图片描述

代码如下：

int _QuickSort(int* arr, int left, int right)
{
	//定义坑
	int hole = left;
	int key = arr[hole];
	while (left < right)
	{
		//挖坑
		while (left<right && arr[right]>arr[key])
		{
			--right;
		}
		//填坑
		arr[hole] = arr[left];
		hole = left;
		while (left<right&&arr[left]<arr[key])
		{
			++left;
		}
		arr[hole] = arr[right];
		hole = right;
	}
	arr[hole] = key;
	return hole;
}
lomuto前后指针

创建前后指针，从左往右找⽐基准值⼩的进⾏交换，使得⼩的都排在基准值的左边
在这里插入图片描述

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
int _QuickSort(int* arr, int left, int right)
{
	//prev起到占位置的作用，cur跟keyi比较大小，找到小于keyi的并且cur!=keyi的时候与
	//prev交换
	int prev = left, cur = prev + 1;
	int keyi = left;
	while (cur <= right)
        //这里加不加等号区别不是很大，因为快速排序对于处理这样重复的数据时间复杂度较高
	{
		if (arr[cur] < arr[keyi] && ++prev != cur)
		{
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	//keyi和prev交换
	Swap(&arr[keyi], &arr[prev]);
	return prev;
}

快速排序特性总结：

时间复杂度： O(nlogn)

空间复杂度： O(logn)

快速排序的非递归

需要借助数据结构：栈

在这里插入图片描述

代码如下：

//Stack.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

//定义栈的结构
typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int capacity;     //栈的空间大小
	int top;          //栈顶
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);

//栈顶---入数据、出数据
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);

//取栈顶元素
STDataType StackTop(ST* ps);

bool StackEmpty(ST* ps);

//获取栈中有效元素个数
int STSize(ST* ps);
//Stack.c
#include"Stack.h"

void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//1.判断空间是否足够
	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
	//空间足够
	ps->arr[ps->top++] = x;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}


//取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->arr[ps->top - 1];
}

//获取栈中有效元素个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//QuickSort.h
#include <stdio.h>
void QuickSortNonR(int* arr, int left, int right);
void Swap(int* x, int* y);
//QuickSort.c
void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
void QuickSortNonR(int* arr, int left, int right)
{
	ST st;
	STInit(&st);
	StackPush(&st, right);
	StackPush(&st, left);
	while (!StackEmpty(&st))
	{
		//取栈顶元素---取两个
		int begin = StackTop(&st);
		StackPop(&st);

		int end = StackTop(&st);
		StackPop(&st);
		//类似于双指针法
		int prev = begin;
		int cur = prev + 1;
		int keyi = begin;
		while (cur <= end)
		{
			if (arr[cur] < arr[keyi] && ++prev != cur)
			{
				Swap(&arr[cur], &arr[prev]);
			}
			cur++;
		}
		Swap(&arr[prev], &arr[keyi]);
		keyi = prev;
		//划分左右区间
		//右区间
		if (keyi + 1 < end)
		{
			StackPush(&st, end);
			StackPush(&st, keyi + 1);
		}
		//左区间
		if (keyi - 1 > begin)
		{
			StackPush(&st, begin);
			StackPush(&st, keyi - 1);
		}
	}
}

归并排序

归并排序算法思想： 归并排序（MERGE-SORT）是建⽴在归并操作上的⼀种有效的排序算法,该算法是采⽤分治法（Divide and Conquer）的⼀个⾮常典型的应⽤。将已有序的⼦序列合并，得到完全有序的序列；即先使每个 ⼦序列有序，再使⼦序列段间有序。若将两个有序表合并成⼀个有序表，称为⼆路归并。 归并排序核 ⼼步骤：

在这里插入图片描述

//MergeSort.h
#include <stdio.h>
#include <stdlib.h>

void MergeSort(int* arr, int n);
void _MergeSort(int* arr, int left, int right, int* tmp);
//MergeSort.c
#include "MergeSort.h"

void _MergeSort(int* arr, int left, int right, int* tmp)
{
	//递归
	if (left <= right)
	{
		return;
	}
	//基准值
	int mid = (left + right) / 2;
	_MergeSort(arr, left, mid - 1, tmp);
	_MergeSort(arr, mid + 1, right, tmp);
	//划分左右区间
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	//对于临时数组的初始化，如果是右边的区间，不能够从0开始
	//合并
	int index = begin1;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (begin1 <= end1)
		{
			tmp[index++] = arr[begin1++];
		}
		if (begin2 <= end2)
		{
			tmp[index++] = arr[begin2++];
		}
	}
	//出现越界，要么左区间，要么右区间
	while (begin1 <= end1)
	{
		tmp[index++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = arr[begin2++];
	}
	//将临时的拷贝到数组中去
	for (int i = left; i < right; i++)
	{
		arr[i] = tmp[i];
	}
}

void MergeSort(int* arr, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	_MergeSort(arr, 0, n - 1,tmp);
	free(tmp);
}

在这里插入图片描述

归并排序特性总结：

时间复杂度： O(nlogn)

空间复杂度： O(n)

非比较排序
计数排序
计数排序⼜称为鸽巢原理，是对哈希直接定址法的变形应⽤。
操作步骤：
1）统计相同元素出现次数
2）根据统计的结果将序列回收到原来的序列中

在这里插入图片描述

#include "CountSort.h"
void Count(int* arr, int n)
{
	//根据最大值和最小值确定数组范围
	int max = arr[0];
	int min = arr[0];
	for (int i = 0; i < n; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
		}
		if (arr[i] < min)
		{
			min = arr[i];
		}
	}
	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	//初始化，使range数组中所有数据为0
	memset(count, 0, range * sizeof(int));
	//统计数组中每个数据出现的次数
	for (int i = 0; i < n; i++)
	{
		count[arr[i] - min]++;
	}
	//给数组元素初始化
	int index = 0;
	for (int i = 0; i < range; i++)
	{
		//取count中的数据往arr中放
		while (count[i]--)
		{
			arr[index++] = i + min;
		}
	}
	}

#include “CountSort.h”
void Count(int* arr, int n)
{
//根据最大值和最小值确定数组范围
int max = arr[0];
int min = arr[0];
for (int i = 0; i < n; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
if (arr[i] < min)
{
min = arr[i];
}
}
int range = max - min + 1;
int* count = (int*)malloc(sizeof(int) * range);
if (count == NULL)
{
perror(“malloc fail!”);
exit(1);
}
//初始化，使range数组中所有数据为0
memset(count, 0, range * sizeof(int));
//统计数组中每个数据出现的次数
for (int i = 0; i < n; i++)
{
count[arr[i] - min]++;
}
//给数组元素初始化
int index = 0;
for (int i = 0; i < range; i++)
{
//取count中的数据往arr中放
while (count[i]–)
{
arr[index++] = i + min;
}
}
}

计数排序的特性：
计数排序在数据范围集中时，效率很⾼，但是适⽤范围及场景有限。
时间复杂度： O(N + range)
空间复杂度： O(range)
稳定性：稳定
注意点：
时间复杂度主要是因为count数组会出现里面元素0的情况

排序算法复杂度及稳定性分析
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
Q:怎样理解稳定性？
A:通俗点来说就是 ，举一个例子，2，1，3，4，2 稳定的情况是排完序后相同的数字前后顺序一致，不稳定则相反

在这里插入图片描述

稳定性验证案例
直接选择排序：5 8 5 2 9
希尔排序：5 8 2 5 9
堆排序：2 2 2 2
快速排序：5 3 3 4 3 8 9 10 11

注意：
希尔排序不稳定是在于分组
归并排序不稳定是因为找基准值

Mr_Xuhhh
关注
  • 13
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
初阶数据结构5 排序
Yusei_0523的博客
08-07 2128
插⼊排序 直接插⼊排序 希尔排序 选择排序 直接选择排序 堆排序 交换排序 冒泡排序 快速排序 hoare版本 挖坑法 lomuto前后指针 ⾮递归版本 归并排序 ⾮⽐较排序 计数排序
初阶数据结构—排序
Awkwardx的博客
07-10 874
3. 空间复杂度：O(logN)4. 稳定性：不稳定。
手撕初阶数据结构之---排序
2301_80863610的博客
08-15 1692
排序：所谓排序，就是使⼀串记录，按照其中的某个或某些关键字的⼤⼩，递增或递减的排列起来的操作。常见的排序算法直接插入排序的时间复杂度是O(N^2)这个是最差的情况下，就是大的在前面，小的在后面希尔排序就是直接插入排序的优化版本将时间复杂度优化为O(N^1.3)时间选择排序是雷打不动的O(N^2)堆排序是O(N logN)冒泡排序是O(N^2)在数组有序的情况下我们能优化成O(N)，但是这种情况很少见。
数据结构初阶之排序（下）
2406_83947720的博客
08-03 927
上一期内容中我们了解了基本排序中的插入与选择排序，今天我将为大家带来剩下的几种排序算法。
初阶数据结构：排序详解
2302_79860961的博客
07-31 992
任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列。
初阶数据结构.排序（1.归并排序）
2302_79860961的博客
07-09 309
（6）这是当上述两个数组结束比较，其中肯定有一个未结束判断，如果是begin1未结束，则将begin1所在数组数组元素依次放入temp数组，相反将begin2未结束，将其中所在数组的元素依次放入temp数组中。（1）a为我们需要排序的数组，temp为我们创建的第三方数组，最后面会讲解其作用，begin为a数组的首个元素，end为a数组的位于末尾的元素。（2）判断a数组中的元素是否只有一个值，就返回，或者开始就判断该数组是否含有元素，如果没有就返回，大于两个元素，则进行下面的归并排序。
数据结构初阶：八大排序
yourfriendyo的博客
02-07 3069
排序是一种非常重要的基础算法，在校招和工作中都非常的实用，它在日常生活中无处不在。本章将介绍八大基本排序。所谓排序，就是将一串序列按照某种递增递减的关系，使该序列成为一个有序的序列。常见并实用的排序有如下八种。
【数据结构初阶 9】内排序
shangguanxiu的博客
03-11 3593
1. 直接插入排序。2. 希尔排序。3. 简单选择排序。4. 堆排序。5. 冒泡排序。6. 快速排序。7. 归并排序。8. 计数排序。
【数据结构初阶】八大排序算法+时空复杂度
The porters of knowledge
12-10 4466
1.5万字排序，面试官看后，直呼小伙子有前途。
C语言实现数据结构算法初阶算法
06-15
在IT领域，掌握数据结构和算法是至关重要的。C语言作为底层编程的首选语言，它提供了直接操作内存的灵活性，因此用C语言实现数据结构和算法可以深入理解这些概念的本质。下面将详细介绍标题和描述中提到的几个核心...
本仓库用于记录与发布日常学习中所编写的C语言代码以及使用C语言实现的初阶数据结构代码 .zip
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，...
数据结构之---堆（2）
2301_81684056的博客
08-15 632
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 906
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
DKPT的博客
08-16 559
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 914
带你了解时间复杂度和空间复杂度
【数据结构入门】二叉树之堆的实现
最新发布
KevinRay_0854的博客
08-20 1120
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值