《数据结构（C语言版）第二版》第五章-树和二叉树（5.8 案例分析与实现）

已于 2024-08-09 02:03:31 修改
阅读量509 收藏 9
点赞数 3
分类专栏： 《严蔚敏 数据结构（C语言版）第二版》 文章标签： 数据结构 c语言 算法 c语言版
于 2024-08-09 01:01:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44883214/article/details/141039813
版权

5.8 案例分析与实现

利用二叉树求解表达式的值

表达式树的创建

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

//定义表达树
typedef struct BiTNode
{
	char data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

//定义操作符栈
typedef struct OPTRSNode
{
	char Operator;
	struct OPTRSNode* next;
}OPTRSNode,*OPTRLStack;

//定义表达树栈
typedef struct EXPTSNode
{
	BiTree Tree;
	struct EXPTSNode* next;
}EXPTSNode, * EXPTLStack;

//定义枚举值
/* 枚举数据类型中的枚举元素，是常亮，不是变量，因此枚举元素又称为枚举常量。
既然系统已经在声明枚举类型时，指定了ERROR是一种枚举元素（常量），
则如果再对其进行宏定义 #define ERROR 0，不管是否与枚举中定义的值相等，都会出现编译错误。*/
typedef enum {
	GREATER_THAN = '>',
	LESS_THAN = '<',
	EQUAL = '=',
	ERROR
} Pre;

#define MAXSIZE 100

void InitOPTRLStack(OPTRLStack& OPTR);
void PushOPTRLStack(OPTRLStack& OPTR, char e);
void PopOPTRLStack(OPTRLStack& OPTR, char& e);
char GettopOPTRLStack(OPTRLStack& OPTR);
void InitEXPTLStack(EXPTLStack& EXPT);
void PushEXPTLStack(EXPTLStack& EXPT, BiTree e);
void PopEXPTLStack(EXPTLStack& EXPT, BiTree& e);
BiTree GettopEXPTLStack(EXPTLStack& EXPT);
void CreateExpTree(BiTree& T, BiTree a, BiTree b, char x);
int In(char ch);
Pre Precede(char x, char y);
void InitExpTree(EXPTLStack& EXPT, char* s);
int getline(char* s, int limit);
void PreOrderTraverse(BiTree& T);
void InOrderTraverse(BiTree& T);
void PosOrderTraverse(BiTree& T);
void FreeTree(BiTree& T);


//a+b*(c-d)-e/f#
//a+b*c-d-e/f#
//a*b-c#

int main()
{
	int length = 0;
	int num = 1;
	char  s[MAXSIZE];
	EXPTLStack EXPT = NULL;
	OPTRLStack OPTR = NULL;
	BiTree T = NULL;
	char choice = '\0';

	while (1)
	{
		printf("请输入第%d个表达式：", num);
		length = getline(s, MAXSIZE);
		InitExpTree(EXPT, s);

		T = GettopEXPTLStack(EXPT);

		printf("该表达式树的先序序列为：");
		PreOrderTraverse(T);

		printf("\n该表达式树的中序序列为：");
		InOrderTraverse(T);

		printf("\n该表达式树的后序序列为：");
		PosOrderTraverse(T);
	
		//释放树的内存
		FreeTree(T);


		printf("\n是否继续？（y/n）");
		scanf_s(" %c", &choice);
		getchar();

		if (choice != 'y' && choice != 'Y')
		{
			break;
		}

		num++;

		printf("\n\n");

	}

	return 0;
}



//初始化操作符栈
void InitOPTRLStack(OPTRLStack& OPTR)
{
	OPTR = NULL;
}

//操作符入栈
void PushOPTRLStack(OPTRLStack& OPTR, char e)
{
	OPTRSNode* p = (OPTRSNode*)malloc(sizeof(OPTRSNode));
	if (!p)
	{
		printf("操作符入栈时，内存分配失败。\n");
		return;
	}

	p->Operator = e;
	p->next = OPTR;
	OPTR = p;
}


//操作符出栈
void PopOPTRLStack(OPTRLStack& OPTR, char& e)
{
	if (!OPTR)
	{
		printf("操作符出栈时，栈不存在。\n");
		return;
	}

	OPTRSNode* p = OPTR;
	e = p->Operator;
	OPTR = OPTR->next;
	free(p);
}

//取操作符栈栈顶
char GettopOPTRLStack(OPTRLStack& OPTR)
{
	if (!OPTR)
	{
		printf("取栈顶操作符时，栈不存在。\n");
		return '\0';
	}

	return OPTR->Operator;
}

//初始化表达树栈
void InitEXPTLStack(EXPTLStack& EXPT)
{
	EXPT = NULL;
}

//表达树入栈
void PushEXPTLStack(EXPTLStack& EXPT, BiTree e)
{
	EXPTSNode* p = (EXPTSNode*)malloc(sizeof(EXPTSNode));
	if (!p)
	{
		printf("表达树入栈时，内存分配失败。\n");
		return;
	}

	p->Tree = e;
	p->next = EXPT;
	EXPT = p;
}

//表达树出栈
void PopEXPTLStack(EXPTLStack& EXPT, BiTree& e)
{
	if (!EXPT)
	{
		printf("表达树出栈时，栈不存在。\n");
		return;
	}

	EXPTSNode* p = EXPT;
	e = p->Tree;
	EXPT = EXPT->next;
	free(p);
}

//取表达树栈栈顶
BiTree GettopEXPTLStack(EXPTLStack& EXPT)
{
	if (!EXPT)
	{
		printf("取表达树栈栈顶时，栈不存在。\n");
		return NULL;
	}

	return EXPT->Tree;
}


//以x为根结点的data值，以a为左子树，以b为右子树，创建一棵二叉树T
void CreateExpTree(BiTree& T, BiTree a, BiTree b, char x)
{
	T = (BiTree)malloc(sizeof(BiTNode));
	T->data  = x;
	T->lchild = a;
	T->rchild = b;
}

//判断ch是否是运算符，是则返回1，不是返回0
int In(char ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')'|| ch == '#')
	{
		return 1;
	}
	else
	{
		return 0;
	}
}


//比较两个运算符的优先级，输出结果的含义为：x>y  x<y  x=y
Pre Precede(char x, char y)
{
	//")"与 "("、"＃"与")" 以及"("与"#"相继出现时，报错。
	if ((x == '(' && y == '#') || (x == ')' && y == '(') || (x == '#' && y == ')'))
	{
		return ERROR;  //枚举类型中的ERROR;
	}
	else if (x == '+' || x == '-') {
		if (y == '+' || y == '-' || y == ')' || y == '#')
			return GREATER_THAN;
		else
			return LESS_THAN;
	}
	else if (x == '*' || x == '/') {
		if (y == '+' || y == '-' || y == '*' || y == '/' || y == ')' || y == '#')
			return GREATER_THAN;
		else
			return LESS_THAN;
	}
	else if (x == '(') {
		if (y == ')')
			return EQUAL;
		else
			return LESS_THAN;
	}
	else if (x == ')')
		return GREATER_THAN;
	else {
		if (y == '#')
			return  EQUAL;
		else
			//当x为#时，y是除"#"及")"【ERROR】的字符时，都返回xiao
			//当x为空字符时，y无论是什么字符，都返回xiao
			return LESS_THAN;
	}
}


//算法5.12 表达式树的创建
void InitExpTree(EXPTLStack& EXPT, char *s)
{
	InitEXPTLStack(EXPT);

	OPTRLStack OPTR = NULL;
	InitOPTRLStack(OPTR);
	
	int i = 0;
	char ch = s[i];
	BiTree T = NULL;
	char theta = '\0';
	char x = '\0';
	BiTree a = NULL;
	BiTree b = NULL;

	PushOPTRLStack(OPTR, '#');

	
	while (ch != '#' || GettopOPTRLStack(OPTR) != '#')
	{
		if(!In(ch))
		{
			CreateExpTree(T, NULL, NULL, ch);
			PushEXPTLStack(EXPT, T);
			++i;
			ch = s[i];  //ch = s[++i];
		}
		else
		{
			switch (Precede(GettopOPTRLStack(OPTR), ch))
			{
				case LESS_THAN:
					PushOPTRLStack(OPTR, ch);
					++i;
					ch = s[i];  //ch = s[++i];
					break;
				case GREATER_THAN:
					PopOPTRLStack(OPTR, theta);
					PopEXPTLStack(EXPT, b);
					PopEXPTLStack(EXPT, a);
					CreateExpTree(T, a, b, theta);
					PushEXPTLStack(EXPT, T);
					break;
				case EQUAL:
					PopOPTRLStack(OPTR, x);
					++i;
					ch = s[i]; //ch = s[++i];
					break;
			}
		}
	}

	//清空栈
	while (OPTR) 
	{
		PopOPTRLStack(OPTR, x);
	}
}


int getline(char* s, int limit)
{
	int c = 0;
	int i = 0;

	for (i = 0; i < limit - 1 && (c = getchar()) != EOF && c != '\n'; i++)
	{
		s[i] = c;
	}

	s[i] = '\0';
	return i;
}


//二叉树的先序遍历
void PreOrderTraverse(BiTree& T)
{
	if (T)
	{
		printf("%c", T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

//二叉树的中序遍历
void InOrderTraverse(BiTree& T)
{
	if (T)
	{
		InOrderTraverse(T->lchild);
		printf("%c", T->data);
		InOrderTraverse(T->rchild);
	}
}


//二叉树的后序遍历
void PosOrderTraverse(BiTree& T)
{
	if (T)
	{
		PosOrderTraverse(T->lchild);
		PosOrderTraverse(T->rchild);
		printf("%c", T->data);
	}
}


// 释放树的内存（这个函数好像没啥用）
void FreeTree(BiTree& T) 
{
	if (T) 
	{
		FreeTree(T->lchild);
		FreeTree(T->rchild);
		free(T);
		T = NULL;
	}
}

在这里插入图片描述

表达式树的求值

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

//定义表达树
typedef struct BiTNode
{
	char data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

//定义操作符栈
typedef struct OPTRSNode
{
	char Operator;
	struct OPTRSNode* next;
}OPTRSNode, * OPTRLStack;

//定义表达树栈
typedef struct EXPTSNode
{
	BiTree Tree;
	struct EXPTSNode* next;
}EXPTSNode, * EXPTLStack;

//定义枚举值
/* 枚举数据类型中的枚举元素，是常亮，不是变量，因此枚举元素又称为枚举常量。
既然系统已经在声明枚举类型时，指定了ERROR是一种枚举元素（常量），
则如果再对其进行宏定义 #define ERROR 0，不管是否与枚举中定义的值相等，都会出现编译错误。*/
typedef enum {
	GREATER_THAN = '>',
	LESS_THAN = '<',
	EQUAL = '=',
	ERROR
} Pre;

#define MAXSIZE 100

void InitOPTRLStack(OPTRLStack& OPTR);
void PushOPTRLStack(OPTRLStack& OPTR, char e);
void PopOPTRLStack(OPTRLStack& OPTR, char& e);
char GettopOPTRLStack(OPTRLStack& OPTR);
void InitEXPTLStack(EXPTLStack& EXPT);
void PushEXPTLStack(EXPTLStack& EXPT, BiTree e);
void PopEXPTLStack(EXPTLStack& EXPT, BiTree& e);
BiTree GettopEXPTLStack(EXPTLStack& EXPT);
void CreateExpTree(BiTree& T, BiTree a, BiTree b, char x);
int In(char ch);
Pre Precede(char x, char y);
void InitExpTree(EXPTLStack& EXPT, char* s);
int getline(char* s, int limit);
void PreOrderTraverse(BiTree& T);
void InOrderTraverse(BiTree& T);
void PosOrderTraverse(BiTree& T);
void FreeTree(BiTree& T);
int Operate(int a, char x, int b);
int EvaluateExpTree(BiTree T);

int main()
{
	int length = 0;
	int num = 1;
	char  s[MAXSIZE];
	EXPTLStack EXPT = NULL;
	OPTRLStack OPTR = NULL;
	BiTree T = NULL;
	int result = 0;
	char choice = '\0';

	while (1)
	{
		printf("请输入第%d个表达式：", num);
		length = getline(s, MAXSIZE);
		InitExpTree(EXPT, s);

		T = GettopEXPTLStack(EXPT);

		printf("该表达式树的先序序列为：");
		PreOrderTraverse(T);

		printf("\n该表达式树的中序序列为：");
		InOrderTraverse(T);

		printf("\n该表达式树的后序序列为：");
		PosOrderTraverse(T);


		result = EvaluateExpTree(T);
		printf("\n该表达式的计算结果为：%d", result);

		//释放树的内存
		FreeTree(T);


		printf("\n是否继续？（y/n）");
		scanf_s(" %c", &choice);
		getchar();

		if (choice != 'y' && choice != 'Y')
		{
			break;
		}

		num++;

		printf("\n\n");

	}

	return 0;
}



//初始化操作符栈
void InitOPTRLStack(OPTRLStack& OPTR)
{
	OPTR = NULL;
}

//操作符入栈
void PushOPTRLStack(OPTRLStack& OPTR, char e)
{
	OPTRSNode* p = (OPTRSNode*)malloc(sizeof(OPTRSNode));
	if (!p)
	{
		printf("操作符入栈时，内存分配失败。\n");
		return;
	}

	p->Operator = e;
	p->next = OPTR;
	OPTR = p;
}


//操作符出栈
void PopOPTRLStack(OPTRLStack& OPTR, char& e)
{
	if (!OPTR)
	{
		printf("操作符出栈时，栈不存在。\n");
		return;
	}

	OPTRSNode* p = OPTR;
	e = p->Operator;
	OPTR = OPTR->next;
	free(p);
}

//取操作符栈栈顶
char GettopOPTRLStack(OPTRLStack& OPTR)
{
	if (!OPTR)
	{
		printf("取栈顶操作符时，栈不存在。\n");
		return '\0';
	}

	return OPTR->Operator;
}

//初始化表达树栈
void InitEXPTLStack(EXPTLStack& EXPT)
{
	EXPT = NULL;
}

//表达树入栈
void PushEXPTLStack(EXPTLStack& EXPT, BiTree e)
{
	EXPTSNode* p = (EXPTSNode*)malloc(sizeof(EXPTSNode));
	if (!p)
	{
		printf("表达树入栈时，内存分配失败。\n");
		return;
	}

	p->Tree = e;
	p->next = EXPT;
	EXPT = p;
}

//表达树出栈
void PopEXPTLStack(EXPTLStack& EXPT, BiTree& e)
{
	if (!EXPT)
	{
		printf("表达树出栈时，栈不存在。\n");
		return;
	}

	EXPTSNode* p = EXPT;
	e = p->Tree;
	EXPT = EXPT->next;
	free(p);
}

//取表达树栈栈顶
BiTree GettopEXPTLStack(EXPTLStack& EXPT)
{
	if (!EXPT)
	{
		printf("取表达树栈栈顶时，栈不存在。\n");
		return NULL;
	}

	return EXPT->Tree;
}


//以x为根结点的data值，以a为左子树，以b为右子树，创建一棵二叉树T
void CreateExpTree(BiTree& T, BiTree a, BiTree b, char x)
{
	T = (BiTree)malloc(sizeof(BiTNode));
	T->data = x;
	T->lchild = a;
	T->rchild = b;
}

//判断ch是否是运算符，是则返回1，不是返回0
int In(char ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(' || ch == ')' || ch == '#')
	{
		return 1;
	}
	else
	{
		return 0;
	}
}


//比较两个运算符的优先级，输出结果的含义为：x>y  x<y  x=y
Pre Precede(char x, char y)
{
	//")"与 "("、"＃"与")" 以及"("与"#"相继出现时，报错。
	if ((x == '(' && y == '#') || (x == ')' && y == '(') || (x == '#' && y == ')'))
	{
		return ERROR;  //枚举类型中的ERROR;
	}
	else if (x == '+' || x == '-') {
		if (y == '+' || y == '-' || y == ')' || y == '#')
			return GREATER_THAN;
		else
			return LESS_THAN;
	}
	else if (x == '*' || x == '/') {
		if (y == '+' || y == '-' || y == '*' || y == '/' || y == ')' || y == '#')
			return GREATER_THAN;
		else
			return LESS_THAN;
	}
	else if (x == '(') {
		if (y == ')')
			return EQUAL;
		else
			return LESS_THAN;
	}
	else if (x == ')')
		return GREATER_THAN;
	else {
		if (y == '#')
			return  EQUAL;
		else
			//当x为#时，y是除"#"及")"【ERROR】的字符时，都返回xiao
			//当x为空字符时，y无论是什么字符，都返回xiao
			return LESS_THAN;
	}
}


//算法5.12 表达式树的创建
void InitExpTree(EXPTLStack& EXPT, char* s)
{
	InitEXPTLStack(EXPT);

	OPTRLStack OPTR = NULL;
	InitOPTRLStack(OPTR);

	int i = 0;
	char ch = s[i];
	BiTree T = NULL;
	char theta = '\0';
	char x = '\0';
	BiTree a = NULL;
	BiTree b = NULL;

	PushOPTRLStack(OPTR, '#');


	while (ch != '#' || GettopOPTRLStack(OPTR) != '#')
	{
		if (!In(ch))
		{
			CreateExpTree(T, NULL, NULL, ch);
			PushEXPTLStack(EXPT, T);
			++i;
			ch = s[i];  //ch = s[++i];
		}
		else
		{
			switch (Precede(GettopOPTRLStack(OPTR), ch))
			{
			case LESS_THAN:
				PushOPTRLStack(OPTR, ch);
				++i;
				ch = s[i];  //ch = s[++i];
				break;
			case GREATER_THAN:
				PopOPTRLStack(OPTR, theta);
				PopEXPTLStack(EXPT, b);
				PopEXPTLStack(EXPT, a);
				CreateExpTree(T, a, b, theta);
				PushEXPTLStack(EXPT, T);
				break;
			case EQUAL:
				PopOPTRLStack(OPTR, x);
				++i;
				ch = s[i];  //ch = s[++i];
				break;
			}
		}
	}

	//清空栈
	while (OPTR)
	{
		PopOPTRLStack(OPTR, x);
	}
}


int getline(char* s, int limit)
{
	int c = 0;
	int i = 0;

	for (i = 0; i < limit - 1 && (c = getchar()) != EOF && c != '\n'; i++)
	{
		s[i] = c;
	}

	s[i] = '\0';
	return i;
}


//二叉树的先序遍历
void PreOrderTraverse(BiTree& T)
{
	if (T)
	{
		printf("%c ", T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

//二叉树的中序遍历
void InOrderTraverse(BiTree& T)
{
	if (T)
	{
		InOrderTraverse(T->lchild);
		printf("%c ", T->data);
		InOrderTraverse(T->rchild);
	}
}


//二叉树的后序遍历
void PosOrderTraverse(BiTree& T)
{
	if (T)
	{
		PosOrderTraverse(T->lchild);
		PosOrderTraverse(T->rchild);
		printf("%c ", T->data);
	}
}


// 释放树的内存（这个函数好像没啥用）
void FreeTree(BiTree& T)
{
	if (T)
	{
		FreeTree(T->lchild);
		FreeTree(T->rchild);
		free(T);
		T = NULL;
	}
}


//针对数值，操作数a、b只能是[0,9]的一位数数字，
//计算结果返回值result只能是[-128,127的]区间内的255个值。且大于一位的，打印输出时要选择printf的参数是"%d"，而不能是"%c".
int Operate(int a, char x, int b)
{
	int result = '0';  

	if (x == '+')
	{
		result = a + b ;
	}
	else if (x == '-')
	{
		result = a - b;
	}
	else if (x == '*')
	{
		result = a * b;
	}
	else
	{
		if (b != 0)
		{
			result = a / b;
		}
		else
		{
			printf("除数不能为0");
			return -184656324;
		}
	}

	return result;
}


int EvaluateExpTree(BiTree T)
{
	int lvalue = 0;
	int rvalue = 0;
	int result = 0;

	if (T->lchild == NULL && T->rchild == NULL)
	{
		//printf("\nT = %c", T->data);
		result = T->data - '0';
	}
	else
	{
		//printf("\nT->lchild = %c", T->lchild->data);
		//printf("\nT->rchild = %c", T->rchild->data);
		lvalue = EvaluateExpTree(T->lchild);
		rvalue = EvaluateExpTree(T->rchild);
		result = Operate(lvalue, T->data, rvalue);
	}

	//printf("\nresult = %d", result);
	return result;
}

在这里插入图片描述

Flerken101
关注
专栏目录
数据结构与算法（快速基础C++版）
weixin_50557558的博客
08-27 1129
数据结构与算法（快速基础）
JavaScript数据结构与算法笔记
qq_43645678的博客
07-28 629
JavaScript数据结构与算法笔记
金融科技、算法交易、量化金融必读书:Python金融大数据分析第2版
人邮异步社区
04-15 2761
银行本质上是技术公司。 ——胡戈•班齐格 近来，Python无疑是金融业的重要策略性技术平台之一。到2018年底，这已经不再是个问题：全世界的金融机构现在都尽最大努力利用Python及其强大的数据分析、可视化和机器学习程序库生态系统。在金融领域之外，Python还常常成为编程入门课程选择的语言，例如计算机科学课程项目。 除了容易理解的语法和多重范型方法之外，形成这一局面的主要原因之一是，...
JAVA数据结构预备知识（泛型和包装类）
cjmyydsds的博客
02-02 903
1.泛型的意义是在编译的时候检查数据类型是否正确2.在编译的时候帮助进行类型的转化（自动进行强制转换）3.在实例化泛型对象的时候不可以是基本数据类型。只能是引用类型。在后续的数据结构学习中会出现大量的泛型应用，所以我把泛型加入到了数据结构中而不是语法中。5.4泛型中可以放的符号代表什么含义？【规范】类型形参一般使用一个大写字母表示，常用的名称有：1.E 表示 Element2.K 表示 Key3.V 表示 Value4.N 表示 Number。
数据结构和算法
唔得够
02-13 629
看完视频后的个人简单记录
前端该如何学习数据结构与算法
缓月
10-16 1707
转载的一篇掘金大佬的文章，已经经过大佬的同意哟~ 原文链接 我把它总结成一个思维导图，详情可见我上一篇文章：数据结构与算法——思维导图总结学习。 一、导读 据我了解，前端程序员有相当一部分对“数据结构”和“算法”的基础概念都不是很清晰，这直接导致很多人在看到有关这部分的内容就会望而却步。 实际上，当你了解了“数据结构”和“算法”存在的真正意义，以及一些实际的应用场景，对它有了一个整体的认知之后，你...
软件设计师教程（第5版）- 前言和目录
weixin_30654583的博客
04-10 2429
软件设计师教程（第5版） 2018-06-29 来源： 清华大学出版社 【字体：大 中 小】 前言 全国计算机技术与软件专业技术资格（水平）考试实施至今已经历了二十余年，在社会上产生了很大的影响，对我国软件产业的形成和发展做出了重要的贡献。为了适应我国计算机信息技术发展的需求，人力资源和社会保障部、工业和信息化部决定将考试的级别拓展到计算机信息...
前端应该如何准备数据结构和算法？
yuqing1008的博客
11-14 341
一、导读据我了解，前端程序员有相当一部分不是科班出身，以至于对“数据结构”和“算法”的基础概念都不是很清晰，这直接导致很多人在看到有关这部分的内容就会望而却步。实际上，当你了解了“数据结...
字节跳动大佬教你如何准备数据结构和算法
jj1130050965的博客
07-10 375
一、导读 由于公众号不能放外部链接，一些题目和资料的链接无法访问，可点击阅读全文获得更好阅读体验。 据我了解，前端程序员有相当一部分不是科班出身，以至于对“数据结构”和“算法”的基础概念都不是很清晰，这直接导致很多人在看到有关这部分的内容就会望而却步。 实际上，当你了解了“数据结构”和“算法”存在的真正意义，以及一些实际的应用场景，对它有了一个整体的认知之后，你可能会对它产生强烈的兴趣。当然，它带将带给你的收益也是相当可观的。 很多前端同学在看到“数据结构”和“算法”后会有一定的抵触心理，或者尝
前端如何准备数据结构和算法
学习、分享
08-31 2214
一、导读 据我了解，前端程序员有相当一部分对“数据结构”和“算法”的基础概念都不是很清晰，这直接导致很多人在看到有关这部分的内容就会望而却步。 实际上，当你了解了“数据结构”和“算法”存在的真正意义，以及一些实际的应用场景，对它有了一个整体的认知之后，你可能会对它产生强烈的兴趣。当然，它带将带给你的收益也是相当可观的。 很多前端同学在看到“数据结构”和“算法”后会有一定的抵触心理，或者尝试去练习，...
javaSE从入门到精通的二十万字总结（二）
码农研究僧的博客
09-19 8248
目录前言5. 集合5.1 集合两大类5.2 Collection 前言 在看这篇文章之前先预习ava基础 可查看我之前写的文章java零基础从入门到精通（全） 以及javaSE从入门到精通的十万字总结（一） 5. 集合 集合实际上就是一个容器。可以来容纳其它类型的数据 集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）list.add(100); //自动装箱Integer 不同的集合等同于使用了不同的数据结构 new
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 1069
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 809
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 578
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 767
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 655
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 936
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
《数据结构与算法分析》C语言版第二版解题指南
"《数据结构与算法分析》（英文版）第二版答案" 这本解决方案手册是针对Mark Allen Weiss所著的《数据结构与算法分析 in C》第二版的配套练习解答，由作者本人编写。手册包含了书中大多数练习题的答案，反映了书籍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值