数据结构排序合集（C语言实现）

已于 2024-07-15 23:04:22 修改
阅读量74 收藏
点赞数 1
文章标签： 数据结构 c语言 算法
于 2023-02-05 14:21:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62888595/article/details/128887221
版权

这里写目录标题

前言

在这里插入图片描述

以下代码环境为vs2022

插入排序

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>



// 插入排序

void InsertSort(int* a, int n)

{

	for (int i = 0; i < n-1; i++)

	{

		int end = i;

		int tmp = a[end + 1];

		while (end >= 0)

		{

			if (a[end] > tmp)

			{

				a[end + 1] = a[end];

				--end;

			}

			else

			{

				break;

			}

		}

		a[end + 1] = tmp;

	}

}



int main()

{

	int a[10] = { 0 };

	int i = 10;

	while (i--)

	{

		scanf("%d", &a[i]);

	}

	InsertSort(a, 10);



	for(i=0;i<10;i++)

	{

		printf("%d ", a[i]);

	}

return 0;

}

希尔排序

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

#include<string.h>

// 希尔排序

void ShellSort(int* a, int n)

{

	int gap = n;

	while (gap > 1)

	{

		gap = gap / 3 + 1;

		for (int i = 0; i < n - gap; i++)



		{

			int end = i;

			int tmp = a[end + gap];

			while (end >= 0)

			{

				if (a[end] > tmp)



				{

					a[end + gap] = a[end];

					end -= gap;

				}

				else

				{

					break;

				}

			}

			a[end + gap] = tmp;

		}



	}



}



int main()

{

	int a[10] = { 0 };

	int i = 10;

	while (i--)

	{

		scanf("%d", &a[i]);

	}

	ShellSort(a, sizeof(a) / sizeof(int));



	for (i = 0; i < 10; i++)

	{

		printf("%d ", a[i]);

	}



	return 0;

}

}

选择排序

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

// 选择排序

void swap(int* x1,int* x2)







{







	int x = *x1;







	*x1 = *x2;







	*x2 = x;







}





void SelectSort(int* a, int n)

{

	int begin = 0, end = n - 1;

	while (begin < end)

	{

		int max = begin, min = begin;

		for (int i = begin + 1; i <= end; i++)

		{

			if (a[i] < a[min])

			{

				min = i;

			}

			if (a[i] > a[max])

			{

				max = i;

			}

		}

		swap(&a[min], &a[begin]);

		if (max == begin)

		{

			max = min;

		}



		swap(&a[max], &a[end]);

		begin++;

		end--;

	}

}

int main()



{



	int a[10] = { 0 };



	int i = 10;



	while (i--)



	{



		scanf("%d", &a[i]);



	}



	SelectSort(a, 10);







	for (i = 0; i < 10; i++)



	{



		printf("%d ", a[i]);



	}



	return 0;



}

堆排序

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

#include<string.h>

// 对数组进行堆排序

typedef int HPDataType;

void swap(HPDataType* x1, HPDataType* x2)

{

HPDataType x = *x1;

*x1 = *x2;

*x2 = x;

}

void adjustdown(HPDataType* a, int n, int root)

{


int parent = root;



int child = parent * 2 + 1;



while (child < n)



{



// 选左右孩纸中大的一个



if (child + 1 < n



&& a[child + 1] > a[child])



{



++child;



}







//如果孩子大于父亲，进行调整交换 



if (a[child] > a[parent])



{



swap(&a[child], &a[parent]);



parent = child;



child = parent * 2 + 1;



}



else



{



break;



}



}



}



void HeapSort(int* a, int n)



{



int i = 0;



//升序 建大堆



for (i = (n - 1 - 1) / 2; i >= 0; i--)



{



adjustdown(a, n, i);//建立的大堆的数组并不是升序



}



int end = n - 1;



while (end > 0)



{



swap(&a[end], &a[0]);



adjustdown(a, end, 0);



end--;



}



}

int main()

{

int a[10] = { 0 };

int i = 10;

while (i--)

{

scanf("%d", &a[i]);

}

ShellSort(a, sizeof(a)/sizeof(int));



for (i = 0; i < 10; i++)

{

printf("%d ", a[i]);

}



i = 10;

while (i--)

{

scanf("%d", &a[i]);

}

HeapSort(a, sizeof(a) / sizeof(int));

for (i = 0; i < 10; i++)

{

printf("%d ", a[i]);

}

return 0;

}

冒泡排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
// 冒泡排序
void swap(int* x1, int* x2)







{







	int x = *x1;







	*x1 = *x2;








	*x2 = x;







}


void BubbleSort(int* a, int n)
{
	int i = 0, j = 0;
	for (i = 0; i < n; i++)
	{
		int exchange = 0;
		for (j = 1; j < n - i; j++)
		{
			if (a[j-1] > a[j])
			{
				swap(&a[j], &a[j - 1]);
				exchange = 1;
			}

		}
		if (exchange == 0)
		{
			break;//一趟冒泡排序中没有发生交换，表示已经有序，退出循环
		}
	}

}
int main()



{



	int a[10] = { 0 };



	int i = 10;



	while (i--)



	{



		scanf("%d", &a[i]);



	}



	BubbleSort(a, 10);







	for (i = 0; i < 10; i++)



	{



		printf("%d ", a[i]);



	}



	return 0;



}

快速排序

递归实现

1)hoare快速排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void swap(int* m, int* n)
{
	int tm = *m;
	*m = *n;
	*n = tm;
}

void quicksort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	int left = begin, right = end;
	int key = left;
	while (left < right)
	{
		while (a[right] >= a[key] && right > left)//当左边第一个为key时，右边先走，这样可以确保与key交换位置的都是比key小的数字,从右向左找比key小的数
		{
			right--;
		}
		while (a[left] <= a[key] && right > left)//从左向右找比key大的数
		{
			left++;
		}
		swap(&a[left], &a[right]);
	}

	swap(&a[key], &a[left]);
	key = left;
	quicksort(a, begin, key - 1);
	quicksort(a, key + 1, end);
}

int main()
{
	int a[10] = { 12,5,67,23,54,4,12,3,2,90 };
	int left1 = 0, right1 = 9;
	quicksort(a, left1, right1);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
return 0;
}

2）挖坑法

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
// 三数取中
// begin  mid  end
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else // a[begin] > a[mid]
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}

void swap(int* m, int* n)
{
	int tm = *m;
	*m = *n;
	*n = tm;
}
void InsertSort(int* a, int n)
{
	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;
	}
}

int holesort(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	swap(&a[begin], &a[mid]);

	int left = begin, right = end;
	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 begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	if ((end - begin + 1) < 15)
	{
		// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int keyi = holesort(a, begin, end);

		// [begin, keyi-1]  keyi [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}
int main()
{
	int a[10] = { 12,5,67,23,54,4,12,3,2,90 };
	int left1 = 0, right1 = 9;
	QuickSort(a, left1, right1);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

3）前后指针法


#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
// 三数取中
// begin  mid  end
int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else // a[begin] > a[mid]
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] < a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
}

void swap(int* m, int* n)
{
	int tm = *m;
	*m = *n;
	*n = tm;
}
void InsertSort(int* a, int n)
{
	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;
	}
}

int pointsort(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	swap(&a[begin], &a[mid]);

	int keyi = begin;
	int prev = begin, cur = begin + 1;
	while (cur <= end)
	{
		// 找到比key小的值时，跟++prev位置交换，小的往前翻，大的往后翻
		if (a[cur] < a[keyi] && ++prev != cur)
			swap(&a[prev], &a[cur]);

		++cur;
	}

	swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	if ((end - begin + 1) < 15)
	{
		// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int keyi = pointsort(a, begin, end);

		// [begin, keyi-1]  keyi [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}
int main()
{
	int a[10] = { 12,5,67,23,54,4,12,3,2,90 };
	int left1 = 0, right1 = 9;
	QuickSort(a, left1, right1);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	return 0;
}

非递归实现

非递归需要以栈为工具，栈用c语言编写分为stack.h 和stack.c两个文件

//这部分代码为stack.h
#pragma once
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* a;
	int capacity;
	int top;   // 初始为0，表示栈顶位置下一个位置下标
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);
STDatatype StackTop(ST* ps);

bool StackEmpty(ST* ps);
int StackSize(ST* ps);

#include "Stack.h"//这部分代码为stack.c

void StackInit(ST* ps)
{
	assert(ps);

	//ps->a = NULL;
	//ps->top = 0;
	//ps->capacity = 0;

	ps->a = (STDatatype*)malloc(sizeof(STDatatype)*4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	ps->top = 0;
	ps->capacity = 4;
}

void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

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

	// 
	if (ps->top == ps->capacity)
	{
		STDatatype* tmp = (STDatatype*)realloc(ps->a, ps->capacity * 2 * sizeof(STDatatype));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 20:20
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}

STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

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

bool StackEmpty(ST* ps)
{
	assert(ps);

	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

//非递归实现快排的函数
int PartSort3(int* a, int begin, int end)
{
	//printf("%d,%d\n", begin, end);

	int mid = GetMidIndex(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int keyi = begin;
	int prev = begin, cur = begin + 1;
	while (cur <= end)
	{
		// 找到比key小的值时，跟++prev位置交换，小的往前翻，大的往后翻
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		++cur;
	}

	Swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);

	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort3(a, left, right);
		// [left, keyi-1] keyi [keyi+1, right]
		if (keyi+1 < right)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}

		if (left < keyi-1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
	}

	StackDestroy(&st);
}

归并排序

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;

	int mid = (begin + end) / 2;
	// [begin, mid] [mid+1, end] 递归让子区间有序
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	// 归并[begin, mid] [mid+1, end]
	//...

	int begin1 = begin, end1 = mid;
	int begin2 = mid+1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] <= a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}

	memcpy(a + begin, tmp + begin, sizeof(int)*(end - begin + 1));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1, tmp);


	free(tmp);
	tmp = NULL;
}

计数排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 1; i < n; ++i) {
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
	int range = max - min + 1;
	int* countA = (int*)calloc(range, sizeof(int));
	if (countA == NULL)
	{
		perror("calloc fail\n");
		exit(-1);
	}

	// 1、统计次数
	for (int i = 0; i < n; ++i)
	{
		countA[a[i] - min]++;
	}

		// 2、排序 
		int k = 0;
		for (int j = 0; j < range; ++j) {
			while (countA[j]--)
			{
				a[k++] = j + min;
			}
			
		}
		free(countA);
	}

int main()
{
	int a[10] = { 232,231,454,331,356,345,323,276,234,265 };
	CountSort(a,10);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
return 0;
}
北雁荡山
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】拓扑排序问题C语言实现
「 刘一哥与GIS的故事」
03-10 2300
拓扑排序是有向无环图的一种应用，在实际生活中用的很多。 比如GIS专业的课程设计，许多课程需要前置课程要求，也就是说没上过A课程、则不可能直接去学B课程，画个图表就是： 同理，我们教材中的范例：穿衣服的过程也是一个拓扑排序问题，如下表： 有关这个拓扑排序的模型构造以及解法、我们的教材有着十分详尽的描述，这里不再叙述，我们主要要解决的就是：如何编程： 从教材P194图7.33到图7.34，我们可知该问题的求解过程是： 1 寻找入度为0的顶点、标记它们并进栈； 2 出栈、然后删除该顶点； 3 返回到.
数据结构—快速排序 C语言代码实现
qq_43128902的博客
09-19 2961
快速排序是20世纪的十大算法之一，在常见的o（nlogn）的时间复杂度的算法（快速排序，堆排序，2路归并排序）中，快速排序的平均性能也是最优的，下面是快排的c语言实现代码 // 基本思想是分治法，故一般用到递归 void QuickSort(int L[],int low, int high) //low和high指示排序的范围 { int temp=0; //用于存储待交换的元素的值 int i=low,j=high; if(low<high) {
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8828
数据结构中最全的排序算法（C语言实现）
C语言【数据结构】多种排序 实现
冰果滴的博客
04-24 4556
前言：这里将会实现插入排序、希尔排序，选择排序、堆排序，冒泡排序、快速排序，归并排序和计数排序。 注意：这里的排序都为升序 一.插入类型的排序 1.插入排序 void InsertSort(int* a, int n) { for (int i = 0; i < n - 1; ++i) { int end = i; int tmp = a[end + 1]; //单趟排序 while (end >= 0) { if (tmp < a[end])
数据结构基本排序（c语言）
m0_69023444的博客
09-23 2410
1.冒泡排序 2.插入排序 3.希尔排序 4.直接选择排序 5.堆排序 6.快速排序 7.归并排序
数据结构——堆排序（C语言）
櫆溟的博客
11-06 1419
昨天裸考软考，下午有一题就是堆排序。我21年的时候学过堆排序，可到现在全忘光了，结果就是面对那题发呆良久，脑子里始终想不起堆排序的核心流程，真是后悔莫及，现在重新来复习一遍堆排序。
希尔排序——C语言实现
qq_41890240的博客
02-15 7619
一、希尔排序思想： 希尔排序本质上也是直接插入排序，但是会先进行预排序，使原序列更接近有序序列，最后将预排之后的序列进行直接插入排序。 二、思路详解： 大家看这个序列：arr1[] = {9，8，7，6，5，4，3，2，1，0}，如果用直接插入排序，那么需要往后移动元素的次数为n*(n-1)/2，也就是45次； 但如果是这个序列呢：arr2[] = {0，1，2，3，5，4，8，7，6，9}；，用直接插入排序，需要移动元素的次数仅为4次。 由此可见，对于一个已经比较有序的序列，
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
数据结构排序算法实验报告c语言
hqm793899006的博客
12-12 4118
题目描述 设计并实现一个管理系统（学生管理、图书管理、产品管理等等），系统中需包含1000条以上的记录，系统至少包含以下功能： (1) 自动生成记录信息（或者从文件中读取）； (2) 逐条显示所有记录信息； (3) 利用时间复杂度O(n2)的排序算法（例如直接插入排序或者折半插入排序）按照关键字进行排序； (4) 利用时间复杂度O(nlogn)的排序算法（例如快速排序）按照关键字进行排序； (5) 程序中统计（3）和（4）的算法在数据正序、逆序、乱序情况下的比较次数与移动次数并输出，在报告中对比较次数与移动
数据结构——C语言实现冒泡排序算法
Suasuasua的博客
11-27 1512
C语言实现冒泡排序算法 1.基本思想：        从小到大的冒泡排序是每次从头开始，两两比较，将较大的数放在两个数中的后面一位，循环此过程，将最大的数放在最后的位置；接着再从头开始两两比较，找到第二大的数；如果有n个数，则循环n次便能将无序的记录变成有序的记录。        这个过程存在两层循环，其一，两两比较的循环；其二是“是第几趟的循环”。 2.C语言算法实现
常见数据结构与算法C语言实现
05-04
内容包含常见基本数据结构实现（C语言版）如各自排序、链表、栈、队列、各种树以及应用、图算法、字符串匹配算法、回溯、并查集等 以及包含各个数据结构常见算法题的解答（C语言版） bitTree 二叉搜索树 ...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构使用类C语言实现.zip
10-18
《严蔚敏数据结构使用类C语言实现》是一本经典的计算机科学教材，它详细介绍了如何用类C语言来实现各种重要的数据结构。在本压缩包中，包含的是一个名为"data-structures-master"的项目源码，这个项目是为了帮助读者...
严蔚敏数据结构全套C语言实现
05-21
这本书主要采用C语言作为实现语言，C语言因其高效、灵活而常被用于编写底层数据结构和算法。 1. **数组**：数组是最基础的数据结构，它是一个相同类型元素的集合，通过索引进行访问。C语言中的数组可以是一维、二维...
C语言实现八大排序算法合集
07-20
c语言
插入和选择排序
c23856的博客
07-20 534
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 564
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1076
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 958
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
C语言实现堆排序与数据结构基础
该书深入讲解了数据结构在C语言中的实现，例如堆排序算法，这是通过调整堆数据结构来实现的一种高效排序方法。 堆排序算法的核心在于维护堆的性质，即堆顶元素（关键字最小的记录）总是小于或等于其子节点。在代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值