数据结构--排序

于 2024-09-14 16:29:46 发布
阅读量29 收藏
点赞数
分类专栏： 数据结构代码 文章标签： 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxdzuishaui/article/details/142261204
版权

1.直接插入排序：

#include <stdio.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0; 
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

//----以下运算针对堆排序的程序
void CreateList1(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 1; i <= n; i++)			//R[1..n]存放排序记录
		R[i].key = keys[i - 1];
}

void DispList1(RecType R[], int n)	//输出顺序表
{
	for (i = 1; i <= n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void InsertSort(RecType R[], int n) //对R[0..n-1]按递增有序进行直接插入排序
{
	int i, j; RecType tmp;
	for (i = 1; i < n; i++)
	{
		if (R[i].key < R[i - 1].key)	//反序时 
		{
			tmp = R[i];
			j = i - 1;

			do					//找R[i]的插入位置 
			{
				R[j + 1] = R[j];   	//将关键字大于R[i].key的记录后移
				j--;
			} while (j >= 0 && R[j].key > tmp.key);

			R[j + 1] = tmp;      		//在j+1处插入R[i]
		}
		printf("  i=%d: ", i); DispList(R, n);
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };

	CreateList(R, a, n);

	printf("排序前:"); 
	DispList(R, n);

	InsertSort(R, n);
	printf("排序后:"); 
	DispList(R, n);

	return 0;
}

2.折半插入排序：

#include <stdio.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void BinInsertSort(RecType R[], int n)
{
	int i, j, low, high, mid;
	RecType tmp;
	for (i = 1; i < n; i++)
	{
		if (R[i].key < R[i - 1].key)		//反序时 
		{
			tmp = R[i];		  			//将R[i]保存到tmp中
			low = 0;  high = i - 1;
			while (low <= high)	  		//在R[low..high]中查找插入的位置
			{
				mid = (low + high) / 2;		//取中间位置
				if (tmp.key < R[mid].key)
					high = mid - 1;			//插入点在左半区
				else
					low = mid + 1;			//插入点在右半区
			}                          	//找位置high
			for (j = i - 1; j >= high + 1; j--)	//集中进行元素后移
				R[j + 1] = R[j];
			R[high + 1] = tmp;				//插入tmp 
		}
		printf("  i=%d: ", i);
		DispList(R, n);
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	BinInsertSort(R, n);
	printf("排序后:"); 
	DispList(R, n);
	
	return 0;
}

3.希尔排序：

#include <stdio.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void ShellSort(RecType R[], int n) //希尔排序算法
{
	int i, j, d;
	RecType tmp;
	d = n / 2;					//增量置初值
	while (d > 0)
	{
		for (i = d; i < n; i++) 	//对所有组采用直接插入排序
		{
			tmp = R[i];		//对相隔d个位置一组采用直接插入排序
			j = i - d;
			while (j >= 0 && tmp.key < R[j].key)
			{
				R[j + d] = R[j];
				j = j - d;
			}
			R[j + d] = tmp;
		}
		printf("  d=%d: ", d); DispList(R, n);
		d = d / 2;				//减小增量
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	ShellSort(R, n);
	printf("排序后:"); 
	DispList(R, n);

	return 0;
}

4.冒泡排序：

#include <stdio.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void BubbleSort(RecType R[], int n)
{
	int i, j, k;
	RecType tmp;
	for (i = 0; i < n - 1; i++)
	{
		for (j = n - 1; j > i; j--)	//比较,找出本趟最小关键字的记录
			if (R[j].key < R[j - 1].key)
			{
				tmp = R[j];  //R[j]与R[j-1]进行交换,将最小关键字记录前移
				R[j] = R[j - 1];
				R[j - 1] = tmp;
			}
		printf("  i=%d: ", i);
		DispList(R, n);
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	BubbleSort(R, n);
	printf("排序后:"); 
	DispList(R, n);
	
	return 0;
}

5.改进后的冒泡排序：

#include <stdio.h>
#include <stdbool.h>

#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void BubbleSort1(RecType R[], int n)
{
	int i, j;
	bool exchange;
	RecType tmp;
	for (i = 0; i < n - 1; i++)
	{
		exchange = false;					//一趟前exchange置为假
		for (j = n - 1; j > i; j--)				//归位R[i],循环n-i-1次
			if (R[j].key < R[j - 1].key)	//相邻两个元素反序时
			{
				tmp = R[j];				//将这两个元素交换
				R[j] = R[j - 1];
				R[j - 1] = tmp;
				exchange = true;			//一旦有交换，exchange置为真
			}
		printf("  i=%d: ", i);
		DispList(R, n);
		if (!exchange)					//本趟没有发生交换，中途结束算法
			return;
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 0,1,7,2,5,4,3,6,8,9 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	BubbleSort1(R, n);
	printf("排序后:"); 
	DispList(R, n);
	
	return 0;
}

6.快速排序：

#include <stdio.h>
#include <stdbool.h>

#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

int count = 0;
int partition(RecType R[], int s, int t)	//一趟划分
{
	int i = s, j = t;
	RecType tmp = R[i];			//以R[i]为基准
	while (i < j)  				//从两端交替向中间扫描,直至i=j为止
	{
		while (j > i && R[j].key >= tmp.key)
			j--;				//从右向左扫描,找一个小于tmp.key的R[j]
		R[i] = R[j];				//找到这样的R[j],放入R[i]处
		while (i < j && R[i].key <= tmp.key)
			i++;				//从左向右扫描,找一个大于tmp.key的R[i]
		R[j] = R[i];				//找到这样的R[i],放入R[j]处
	}
	R[i] = tmp;
	return i;
}

void QuickSort(RecType R[], int s, int t) //对R[s..t]的元素进行快速排序
{
	int i;
	RecType tmp;
	if (s < t) 					//区间内至少存在两个元素的情况
	{
		count++;
		i = partition(R, s, t);
		DispList(R, 10);			//调试用
		QuickSort(R, s, i - 1);		//对左区间递归排序
		QuickSort(R, i + 1, t);		//对右区间递归排序
	}
}

int main()
{
	int i, n = 10;
	RecType R[MAXL];
	KeyType a[] = { 6,8,7,9,0,1,3,2,4,5 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	QuickSort(R, 0, n - 1);
	printf("排序后:"); 
	DispList(R, n);
	printf("count=%d\n", count);
	
	return 0;
}

7.简单选择排序：

#include <stdio.h>
#include <stdbool.h>

#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

int partition(RecType R[], int s, int t)	//一趟划分
{
	int i = s, j = t;
	RecType tmp = R[i];			//以R[i]为基准
	while (i < j)  				//从两端交替向中间扫描,直至i=j为止
	{
		while (j > i && R[j].key >= tmp.key)
			j--;				//从右向左扫描,找一个小于tmp.key的R[j]
		R[i] = R[j];				//找到这样的R[j],放入R[i]处
		while (i < j && R[i].key <= tmp.key)
			i++;				//从左向右扫描,找一个大于tmp.key的R[i]
		R[j] = R[i];				//找到这样的R[i],放入R[j]处
	}
	R[i] = tmp;
	return i;
}

void SelectSort(RecType R[], int n)
{
	int i, j, k;
	RecType temp;
	for (i = 0; i < n - 1; i++)    	 	//做第i趟排序
	{
		k = i;
		for (j = i + 1; j < n; j++)  	//在当前无序区R[i..n-1]中选key最小的R[k]
			if (R[j].key < R[k].key)
				k = j;           	//k记下目前找到的最小关键字所在的位置
		if (k != i)          		//交换R[i]和R[k]
		{
			temp = R[i];
			R[i] = R[k];
			R[k] = temp;
		}
		printf("  i=%d: ", i); DispList(R, n);
	}
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	
	CreateList(R, a, n);
	
	printf("排序前:"); 
	DispList(R, n);
	
	SelectSort(R, n);
	printf("排序后:"); 
	DispList(R, n);
	
	return 0;
}

8.二路归并，自顶向上：

#include <stdio.h>
#include <stdlib.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void Merge(RecType R[], int low, int mid, int high)
{
	RecType* R1;
	int i = low, j = mid + 1, k = 0; //k是R1的下标,i、j分别为第1、2段的下标
	R1 = (RecType*)malloc((high - low + 1) * sizeof(RecType));  //动态分配空间
	while (i <= mid && j <= high)     	//在第1段和第2段均未扫描完时循环
		if (R[i].key <= R[j].key)    	//将第1段中的记录放入R1中
		{
			R1[k] = R[i];
			i++; k++;
		}
		else                       		//将第2段中的记录放入R1中
		{
			R1[k] = R[j];
			j++; k++;
		}
	while (i <= mid)          	       	//将第1段余下部分复制到R1
	{
		R1[k] = R[i];
		i++; k++;
	}
	while (j <= high)                	//将第2段余下部分复制到R1
	{
		R1[k] = R[j];
		j++; k++;
	}
	for (k = 0, i = low; i <= high; k++, i++) //将R1复制回R中
		R[i] = R1[k];
}

void MergePass(RecType R[], int length, int n)	//对整个数序进行一趟归并
{
	int i;
	for (i = 0; i + 2 * length - 1 < n; i = i + 2 * length) 	//归并length长的两相邻子表
		Merge(R, i, i + length - 1, i + 2 * length - 1);
	if (i + length - 1 < n - 1)                		//余下两个子表,后者长度小于length
		Merge(R, i, i + length - 1, n - 1);  		//归并这两个子表
	printf("length=%d: ", length);
	DispList(R, n);
}

void MergeSort(RecType R[], int n)			//自底向上的二路归并算法
{
	int length;
	for (length = 1; length < n; length = 2 * length)//进行log2n趟归并
		MergePass(R, length, n);
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	CreateList(R, a, n);
	printf("   排序前:"); DispList(R, n);
	MergeSort(R, n);
	printf("   排序后:"); DispList(R, n);
	return 0;
}

9.二路归并，自顶向下(递归)：

#include <stdio.h>
#include <stdlib.h>
#define MAXL 100		//最大长度
typedef int KeyType;	//定义关键字类型为int
typedef char InfoType;

typedef struct
{
	KeyType key;		//关键字项
	InfoType data;		//其他数据项，类型为InfoType
} RecType;				//查找元素的类型

void swap(RecType x, RecType y)	//x和y交换
{
	RecType tmp = x;
	x = y; y = tmp;
}

int i = 0;
void CreateList(RecType R[], KeyType keys[], int n)	//创建顺序表
{
	for (i = 0; i < n; i++)			//R[0..n-1]存放排序记录
		R[i].key = keys[i];
}

void DispList(RecType R[], int n)	//输出顺序表
{
	for (i = 0; i < n; i++)
		printf("%d ", R[i].key);
	printf("\n");
}

void Merge(RecType R[], int low, int mid, int high)
{
	RecType* R1;
	int i = low, j = mid + 1, k = 0; //k是R1的下标,i、j分别为第1、2段的下标
	R1 = (RecType*)malloc((high - low + 1) * sizeof(RecType));  //动态分配空间
	while (i <= mid && j <= high)     	//在第1段和第2段均未扫描完时循环
		if (R[i].key <= R[j].key)    	//将第1段中的记录放入R1中
		{
			R1[k] = R[i];
			i++; k++;
		}
		else                       		//将第2段中的记录放入R1中
		{
			R1[k] = R[j];
			j++; k++;
		}
	while (i <= mid)          	       	//将第1段余下部分复制到R1
	{
		R1[k] = R[i];
		i++; k++;
	}
	while (j <= high)                	//将第2段余下部分复制到R1
	{
		R1[k] = R[j];
		j++; k++;
	}
	for (k = 0, i = low; i <= high; k++, i++) //将R1复制回R中
		R[i] = R1[k];
}

void MergeSortDC(RecType R[], int low, int high)
//对R[low..high]进行二路归并排序
{
	int mid;
	if (low < high)
	{
		mid = (low + high) / 2;
		MergeSortDC(R, low, mid);
		MergeSortDC(R, mid + 1, high);
		Merge(R, low, mid, high);
	}
}

void MergeSort1(RecType R[], int n)	//自顶向下的二路归并算法
{
	MergeSortDC(R, 0, n - 1);
}

int main()
{
	int n = 10;
	RecType R[MAXL];
	KeyType a[] = { 9,8,7,6,5,4,3,2,1,0 };
	CreateList(R, a, n);
	printf("   排序前:"); DispList(R, n);
	MergeSort1(R, n);
	printf("   排序后:"); DispList(R, n);
	return 0;
}

无限大.
关注
专栏目录
图解数据结构--使用Java
04-28
利用大量且丰富的图示与范例， 详解复杂的抽象理论，从最基本的数据结构概念开始 说明，再以Java工具加以诠释阵列结构、堆栈、链表 、队列、排序、查找等重要的概念，引领读者抓住重 点轻松进入数据结构的学习领域
数据结构--排序之希尔排序
qq_52363432的博客
02-03 3282
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
数据结构--排序之冒泡排序
qq_52363432的博客
01-27 2205
冒泡排序也称气泡排序，是一种典型的交换排序方法，其基本思想是通过无序区中相邻元素关键字间的比较和位置的交换使关键字最小的元素如气泡一般逐渐往上"漂浮"直至"水面"。
数据结构--排序分类、常用八大排序
qq_44641527的博客
10-25 2615
一、内部排序的一般分类 1、插入排序 直接插入 希尔排序 折半插入 2-路插入 表插入 2、交换排序 冒泡排序 快速排序 3、选择排序 简单选择 树形选择 堆排序 4、归并排序 5、基数排序 二、八大内部排序 1、直接插入排序【稳定】（O（n^2）） （1）核心思想 将数组中的所有元素依次跟前面已经排好的元素相比较， 如果选择的元素比已排序的元素小，则交换，再和前一个比较，直到全部元素都比较过。 （2）关键：找...
数据结构-十大经典排序算法
qq_64010161的博客
12-09 3750
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
数据结构-十大排序算法
致大尽微 家国天下
12-26 3818
十大排序算法分别是直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、外部排序。其中插入排序包括直接插入排序、折半插入排序、希尔排序；交换排序包括冒泡排序、快速排序；选择排序包括简单选择排序、堆排序。
数据结构--排序--思维导图.pdf
08-29
"数据结构--排序--思维导图" 数据结构中排序是指将一组无序的记录序列按照一定的规则排列成有序的序列，排序的目的是为了提高数据的存储和检索效率。排序算法的稳定性是指在排序过程中，如果待排序表中有两个元素Ri...
数据结构--九种排序算法 --排序001.cpp
11-22
此文件为数据结构中的九种排序算法，包含一些排序方法的过程，其九种排序包括：直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序！
数据结构思维导图-排序.pdf
08-23
以上是数据结构中关于排序的一些基本知识，包括排序的稳定性、比较次数、内部排序和外部排序的定义，以及直接插入排序、折半插入排序、希尔排序和冒泡排序的原理和特点。这些排序算法各有优缺点，选择哪种排序算法取...
数据结构.
weixin_74300052的博客
09-08 942
Hello,大家好，我是小珑也要变强（也是小珑），我是易编程·终身成长社群的一名“创始团队·嘉宾”和“内容共创官”,现在我来为大家介绍一下有关物联网-嵌入式方面的内容。1968年美国克务特教授开创了数据结构的最初体系;数据结构指的是数据的逻辑结构和存储结构及其操作;数据结构是一门综合性的专业课程，是是一门介于数学、计算机硬件、计算机软件之间的一门核心课程。是设计和实现编译系统、操作系统、数据库系统及其他系统程序和大型应用程序的基础。逻辑结构。
数据结构应用实例(四)——最小生成树
Blogs of zcy1221
09-10 1181
每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为。4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；
数据结构————单链表
m0_66847953的博客
09-09 1296
单链表（Singly Linked List）是一种基本的数据结构，它由一系列节点组成，每个节点包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储指向链表中下一个节点的地址。在单链表中，除了最后一个节点外，每个节点的指针域都指向下一个节点，最后一个节点的指针域通常设置为NULL，以标识链表的结束。单链表的特点是其存储不需要连续的内存空间，节点可以分散在内存中的任意位置，通过指针连接形成线性结构。头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点，然后更新头指针以指向新节点。
【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分
sjsjs11的博客
09-11 964
也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。
数据结构归并两个链表并按照学号升序
wsdsbtzk的博客
09-07 331
int id;int score;int N,M;cin>>N>>M;return 0;i<n;i++)Student* q;while(p!=NULL)q=p;p=p->next;free(q);=NULL)p=p->next;p->next=s2;=NULL)
浙大数据结构：04-树6 Complete Binary Search Tree
qq_74924951的博客
09-10 528
int n;i < n;int f = 1;i < n;elseint n;return;i < n;int f = 1;i < n;else。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
最新发布
BamBoo_Bean的博客
09-13 475
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
【数据结构和算法实践-树-LeetCode110-平衡二叉树】
Mao_c的博客
09-10 820
leetcode b树
常见的排序
2302_79712403的博客
09-07 880
常见的10大排序，这里先详细的介绍前7种排序；稳定性定义：如果两个元素具有相同的关键字，那么在排序后他们的相对顺序不变；排序前有标记的5在前面，排序后依旧在前面即稳定，如果位置互换了就不稳定；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值