BJFU|数据结构A（22下）实验2(1)——严蔚敏版教材头歌系统

最新推荐文章于 2024-10-01 20:37:52 发布
最新推荐文章于 2024-10-01 20:37:52 发布
阅读量152 收藏
点赞数 6
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CCCP_lus/article/details/142674348
版权

仅供课外学习使用，任何个人与机构不得利用此文章进行任何形式的作弊。

01基于栈的中缀算术表达式求值

#include <iostream>
#include<iomanip>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
using namespace std;
typedef struct
{//运算符栈
    char *base;
	char *top;
	int stacksize;
}SqStack1;
Status InitStack1(SqStack1 &S)
{//运算符栈初始化
	S.base = new char[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push1(SqStack1 &S, char e)
{//运算符栈入栈
	if(S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop1(SqStack1 &S)
{//运算符栈出栈
	if(S.top == S.base) return ERROR;
	--S.top;
	return OK;
}
char GetTop1(SqStack1 S)
{//运算符栈取栈顶元素
	if(S.top != S.base)
		return *(S.top - 1);
	return ERROR;	
}
typedef struct
{//操作数栈
	double *base;
	double *top;
	int  stacksize;
}SqStack2;
Status InitStack2(SqStack2 &S)
{//操作数栈初始化
	S.base = new double[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push2(SqStack2 &S,double e)
{//操作数栈入栈
	if(S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;	
}
Status Pop2(SqStack2 &S)
{//操作数栈出栈
	if(S.top == S.base) return ERROR;
	--S.top;
	return OK;	
}
double GetTop2(SqStack2 S)
{//操作数栈取栈顶元素
	if(S.top != S.base)
		return *(S.top - 1);
	return ERROR;
}
double Calculate(double a,char op,double b)
{//计算表达式“a op b”的值
    switch (op) 
	{
		case '+':
			return a + b;
			break;
		case '-':
			return a - b;
			break;
		case '*':
			return a * b;
			break;
		case '/':
			if(b == 0) return ERROR;
			return a / b;
			break;			
		default:
			return ERROR;
			break;
	}   
}

char Precede(char a,char b)
{//比较运算符a和b的优先级
	switch (a) 
	{
		case '+':
		case '-':
			switch (b) 
			{
				case '+':
				case '-':
				case ')':
				case '=':
					return '>';
					break;
				case '*':
				case '/':
				case '(':
					return '<';
					break;
			}
			break;
		case '*':
		case '/':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case ')':
				case '=':
					return '>';
					break;
				case '(':
					return '<';
					break;
			}
			break;		
		case '(':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case '(':
					return '<';
					break;
				case ')':
					return '=';
					break;
			}
			break;
		case ')':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case ')':
				case '=':
					return '>';
					break;
			}
			break;	
		case '=':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case '(':
					return '<';
					break;
				case '=':
					return '=';
					break;
			}
			break;
	}
	return ERROR;
}

double EvaluateExpression(SqStack1 OPTR,SqStack2 OPND,char s[])
{//算术表达式求值的算符优先算法
 //设OPTR和OPND分别为运算符栈和操作数栈
 //表达式求值算法调用Precede函数和Calculate函数 
	char c, o; double a, b;
	for(int i = 0; s[i] != '\0'; )
	{
		c = s[i];
		if(!isdigit(c))
		{
			switch (Precede(GetTop1(OPTR), c)) 
			{
				case '<':
					Push1(OPTR, c);
					i++;
					break;
				case '>':
					o = GetTop1(OPTR);
					Pop1(OPTR);
					b = GetTop2(OPND);
					Pop2(OPND);
					a = GetTop2(OPND);
					Pop2(OPND);
					Push2(OPND, Calculate(a, o, b));
					break;
				case '=':
					Pop1(OPTR);
					i++;
					break;
				default:
					return ERROR;
					break;
			}
		}
		else
		{
			int j = 0;
			char num[5] = {'\0'};
			do{
				num[j] = c;
				j++; i++;
				c = s[i];
			}while(isdigit(c) || c == '.');
			num[j] = 0;
			double t = atof(num);
			Push2(OPND, t);
		}
	}
	double n = GetTop2(OPND);
	return n;
}

int main()
{//设OPTR和OPND分别为运算符栈和操作数栈
	SqStack1 OPTR;
	InitStack1(OPTR);    //初始化OPND栈
	SqStack2 OPND;
	InitStack2(OPND);    //初始化OPTR栈
	Push1(OPTR,'=');     //提前在OPTR栈中放入'='，便于以后比较符号优先级        
    char s[100];
	while(cin>>s)
	{//循环读入多组数据	
		if(s[0]=='=') 
		   break;    //当表达式只有一个“=”时，输入结束 
		//输出中缀算术表达式的值
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPTR,OPND,s)<<endl;	
	}
	return 0;
}

02中缀表达式转化为后缀表达式

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef struct
{
	char *base;
	char *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{//初始化栈
	S.base = new char[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack &S, char e)
{//入栈
	if(S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack &S)
{//出栈
	if(S.top == S.base) return ERROR;
	--S.top;
	return OK;
}
char GetTop(SqStack S)
{//取栈顶元素
	if(S.top != S.base)
		return *(S.top - 1);
	else return ERROR;
}
char Precede(char a,char b)
{//比较运算符a和b的优先级
	switch (a) 
	{
		case '+':
		case '-':
			switch (b) 
			{
				case '+':
				case '-':
				case ')':
				case '=':
					return '>';
					break;
				case '*':
				case '/':
				case '(':
					return '<';
					break;
			}
			break;
		case '*':
		case '/':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case ')':
				case '=':
					return '>';
					break;
				case '(':
					return '<';
					break;
			}
			break;		
		case '(':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case '(':
					return '<';
					break;
				case ')':
					return '=';
					break;
			}
			break;
		case ')':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case ')':
				case '=':
					return '>';
					break;
			}
			break;	
		case '=':
			switch (b) 
			{
				case '+':
				case '-':
				case '*':
				case '/':
				case '(':
					return '<';
					break;
				case '=':
					return '=';
					break;
			}
			break;
	}
	return ERROR;
}
void InfixToSuffix(SqStack OPTR,char s[])
{//将中缀表达式转化为后缀表达式并输出 
	char t;
	for(int i = 0; s[i] != '\0'; )
	{
		while(isdigit(s[i]))
		{
			cout << s[i];
			i++;
		}
		switch (Precede(GetTop(OPTR), s[i])) 
		{
			case '<':
				Push(OPTR, s[i]);
				i++;
				break;
			case '>':
				t = GetTop(OPTR);
				Pop(OPTR);
				cout << t;		
				break;
			case '=':
				t = GetTop(OPTR);
				Pop(OPTR);
				i++;
				break;
		}
	} 
	cout << endl;
}

int main()
{
	SqStack OPTR;
	InitStack(OPTR);      //初始化操作符栈OPTR
	Push(OPTR,'=');		//先在栈底放入'='便于以后比较符号优先级	
	char s[100];
	while(cin>>s)
	{
		if(s[0]=='=')
			break;    	//当表达式只有一个“=”时，输入结束 
		else
			InfixToSuffix(OPTR,s); 	//将中缀表达式转化为后缀表达式并输出	
	}
	return 0;
}

03基于栈的后缀算术表达

#include <iostream>
#include<iomanip>
#include <string>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
using namespace std;
typedef struct
{//操作数栈
	double* base;
	double* top;
	int  stacksize;
}SqStack;
Status InitStack(SqStack& S)
{//操作数栈初始化
	S.base = new double[MAXSIZE];
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack& S, double e)
{//操作数栈入栈
	if(S.top - S.base == S.stacksize)
		return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack& S)
{//操作数栈出栈
	if(S.top == S.base)
		return ERROR;
	S.top--;
	return OK;
}
double GetTop(SqStack S)
{//操作数栈取栈顶元素

	if(S.top == S.base)
		return ERROR;	//若不存在栈顶元素则返回ERROR
	double e = *(S.top - 1);
	return e;
}
double Calculate(double a, char op, double b)
{//计算表达式“a op b”的值
	switch (op) 
	{
		case '+':
			return a + b;
			break;
		case '-':
			return a - b;
			break;
		case '*':
			return a * b;
		case '/':
			return a / b;
		default:
			return ERROR;
			break;
	}
}
double EvaluateExpression(SqStack OPND,char s[])
{//后缀算术表达式求值
 //设OPND为操作数栈
 //表达式求值算法调用Calculate函数 
	for(int i = 0; s[i] != '\0'; i++)
	{
		if(isdigit(s[i]))
		{
//			char c = s[i];
//			int j = 0;
//			char num[5] = {'\0'};
//			do
//			{
//				num[j] = c;
//				j++; i++;
//				c = s[i];
//			}while(isdigit(c) || c == '.');
//			num[j] = 0;
//			double t = atof(num);
//			Push(OPND, t);
			Push(OPND, s[i] - '0');
		}
		else if(s[i] == ' ') continue;
		else
		{
			if(s[i] == '=') break;
			double a, b;
			b = GetTop(OPND); Pop(OPND);
			a = GetTop(OPND); Pop(OPND);
			Push(OPND, Calculate(a, s[i], b));
		}
	}
	double n = GetTop(OPND);
	return n;
}

int main()
{
	char s[100];
	//用字符数组存储表达式，每个数组元素仅存一个字符
	while(1)
	{
		cin.getline(s,100);		//输入一行含空格的后缀表达式
		if(s[0]=='=') 
			break;				//当表达式只有一个"="时，输入结束
		SqStack OPND;
		InitStack(OPND);		//初始化数字栈
		cout<<fixed<<setprecision(2)<<EvaluateExpression(OPND,s)<<fixed<<setprecision(2)<<endl;
	}
	return 0;
}

04入栈和出栈的基本操作式求值

#include<iostream>
using namespace std;
#define  MAXSIZE  100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef struct
{
	int* base;
	int* top;
	int stacksize;
}SqStack;
Status InitSqStack(SqStack& S)
{//栈的初始化
	S.base = new int[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack& S, int e)
{//入栈
	if(S.top - S.base == S.stacksize)
		return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack& S)
{//出栈
	if(S.top == S.base) return ERROR;
	int e;
	e = *--S.top;
	return OK;
}
Status GetTop(SqStack S)
{//取栈顶元素
	if(S.top != S.base)
		return *(S.top - 1);
	return ERROR;
}
void InOutS(SqStack& S, int a[], int n)
{//入栈和出栈的基本操作
	for(int i = 0; i < n; i++)
	{
		if(a[i] == -1)
		{
			int t = GetTop(S);
			if(S.top == S.base)
			{
				cout << "POP ERROR" << endl;
				break;
			}
			else
			{
				cout << t << endl;
				Pop(S);
			}
		}
		else
		{
			Push(S, a[i]);
		}
	} 
}

int main()
{
	int n;
	while(cin>>n)
	{
      	if(n==0) break;
      	SqStack S;
		InitSqStack(S);
		int a[n];
		for(int i=0;i<n;i++) cin>>a[i];  //整数序列
		InOutS(S,a,n);
	}
	return 0;
}

05双栈的基本操作

#include<iostream>
using namespace std;
typedef int Status;
typedef struct
{
	int top[2], bot[2];//栈顶和栈底指针
	int* V;//栈数组
	int m;//栈最大可容纳元素个数
}DblStack;
void InitDblStack(DblStack& S, int m)
{//初始化一个大小为m的双向栈
	S.V = new int[m];
	S.bot[0] = S.top[0] = -1;
	S.bot[1] = S.top[1] = m;
}
Status IsEmpty(DblStack S, int i)
{//判断指定的i号栈是否为空，空返回1，否则返回0
	if(S.top[i] == S.bot[i]) 
		return 1;
	else
		return 0;
}
Status IsFull(DblStack S)
{//判断栈是否满，满则返回1，否则返回0
	if(S.top[0] + 1 == S.top[1])
		return 1;
	else
		return 0;
}
void Push(DblStack& S, int i)
{//向指定的i号栈中插入元素x，先移动指针再入栈
	if(IsFull(S)) 
		exit(-1);
	if(i == 0)
		cin >> S.V[++S.top[i]];
	else	
		cin >> S.V[--S.top[i]];
}

void Pop(DblStack& S, int i)
{//删除指定的i号栈的栈顶元素，先出栈再移动指针
	if(IsEmpty(S, i))
		exit(-1);
	if(i == 0)
		cout << S.V[S.top[i]--] << " ";
	else
		cout << S.V[S.top[i]++] << " ";
}

int main()
{
  	DblStack S;
	int m,e0,e1,d0,d1;
	while(cin>>m)
	{
		if(m==0) break;
		InitDblStack(S,m);
      	cin>>e0>>e1>>d0>>d1;
		while(e0--)
			Push(S,0);
		while(e1--)
			Push(S,1);
      	cout<<IsFull(S)<<endl;
		while(d0--)
			Pop(S,0);
      	cout<<!IsEmpty(S,0)<<endl;
		while(d1--)
			Pop(S,1);
      	cout<<!IsEmpty(S,1)<<endl;
	}
	return 0;
}

06基于栈的回文字符序列判断

#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
using namespace std;
typedef struct
{
	char* base;
	char* top;
	int stacksize;
}SqStack;
Status InitStack(SqStack& S)
{//栈初始化
	S.base = new char[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack& S, char e)
{//入栈
	if(S.top - S.base == S.stacksize)
		return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack& S)
{//出栈返回栈顶元素
	if(S.top == S.base)
		return ERROR;
	char e = *--S.top;
	return e;
}
Status IsPalindrome(SqStack& S, char* t)
{//判断栈的回文字符序列，不等则返回零, 相等则返回1
	char *p = new char[sizeof(t)];
	for(int i = 0; t[i]!= '\0'; i++)
		Push(S, t[i]);
	for(int i = 0; t[i]!= '\0'; i++)
		p[i] = Pop(S);
	bool flag = true;
	for(int i = 0; t[i]!= '\0'; i++)
	{
		if(p[i] != t[i])
		{
			flag = false;
			break;
		}
	}
	p[sizeof(t)] = '\0';
	delete p;
	if(flag) return 1;
	else return 0;
}

int main()
{
  	char t[100];
	while(cin>>t&&t[0]!='0')
	{
		SqStack S;
		InitStack(S);
		if(IsPalindrome(S,t)==1) cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
	return 0;
}

07基于栈的可操作判断

#include <iostream>
#include <cstring>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
using namespace std;
typedef struct
{
    char* base;
    char* top;
    int stacksize;
}SqStack;
Status InitStack(SqStack& S)
{//初始化栈
	S.base = new char[MAXSIZE];
	if(!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
    return OK;
}
Status Push(SqStack& S)
{//入栈
	if(S.top - S.base == S.stacksize)
		return ERROR;
	S.top++;
	return OK;
}
Status Pop(SqStack& S)
{//出栈
	if(S.top == S.base) return ERROR;
	S.top--;
	return OK;
}
Status IsEmpty(SqStack S)
{//判断栈是否为空，空返回1，否则返回0
    if(S.top == S.base)	return 1;
    return 0;
}
bool Judge(char a[], SqStack& S)
{//栈的可操作判断
    for(int i = 0; a[i] != '\0'; i++)
    {
		if(a[i] == 'I')
		{
			if(!Push(S)) 
				return false;
		}
		if(a[i] == 'O')
		{
			if(!Pop(S))
				return false;
		}
	}
	if(S.top != S.base)
		return false;
	return true;
}

int main()
{
    char a[100];
    while(cin>>a)
    {
        if(a[0]=='0') break;
        SqStack op;
        InitStack(op);
        if(Judge(a,op)) cout<<"TRUE"<<endl;
        else cout<<"FALSE"<<endl;
    }
    return 0;
}


 

CresCent_Charles
关注
专栏目录
BJFU_OJ系统数据结构习题目录
雪地行进
11-27 2万+
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 持续补充中 黑色标题意味代码未完成 204基于顺序存储结构的图书信息表的创建和输出 205基于顺序存储结构的图书信息表的排序 206基于顺序存储结构的图书信息表的修改 207基于顺序存储结构的图书信息表的逆序存储 208基于顺序存储结构的图书信息表的最贵图书的查找 209基于顺序存储结构的图书信息表的最爱图书的查找 210...
BJFU_数据结构习题_239猴子选大王
雪地行进
10-12 1662
239猴子选大王 描述 一堆猴子都有编号，编号是1，2，3 …m，这群猴子（m个）按照1~m的顺序围坐一圈，从第1开始数，每数到第n个，该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王。利用单向循环链表模拟此过程，依次输出出圈的猴子编号。 输入 多组数据，每组数据占一行，包括两个数据m和n。m代表猴子个数，n代表步数，m=0且n=0时输入结束。 输出 依次输出出圈的猴子...
BJFU|数据结构A（22下）实验4——严蔚敏版教材头歌系统
CCCP_lus的博客
11-02 598
BJFU|北京林业大学|数据结构A（22下）
BJFU|数据结构A（22下）实验3——严蔚敏版教材头歌系统
CCCP_lus的博客
10-27 1235
BJFU|北京林业大学|数据结构A（22下）
BJFU|数据结构A（22下）实验2(2)——严蔚敏版教材头歌系统
最新发布
CCCP_lus的博客
10-01 55
BJFU|北京林业大学|数据结构A（22下）
头歌数据结构课程实验（基于链表的图书信息管理）
zzj的博客
07-15 1430
然后输入m+1行，其中，第一行是一个整数m，代表查找m次，后m行每行内容为一个整数，代表待查找的图书的位置序号。若查找成功： 总计输出m*（k+1）行，对于每一次查找，第一行是最爱图书数目（同一书名的图书可能有多本），后k行是最爱图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，其中价格输出保留两位小数。总计输入n+1行，其中，第一行是图书数目n，后n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格（书号可能重复）。
BJFU|操作系统考试复习纲要（思维导图版）
CCCP_lus的博客
03-07 324
纲要涵盖五个章节，每节一图。红色框部分为必考重点，建议认真复习。
BJFU|计算机导论（21下）第四章-数据结构与算法
CCCP_lus的博客
04-11 412
BJFU|北京林业大学|计算机导论（21下）
BJFU_数据结构习题_214基于链式存储结构的图书信息表的创建和输出
雪地行进
10-10 3958
214基于链式存储结构的图书信息表的创建和输出 描述 定义一个包含图书信息（书号、书名、价格）的链表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。 输入 输入n+1行，其中前n行是n本图书的信息（书号、书名、价格），每本图书信息占一行，书号、书名、价格用空格分隔，价格之后没有空格。最后第n+1行是输入结束标志：0 0 0（空格分隔的三个0）。其...
数据结构实验1必做部分OJ版-配套实验
06-12
1. 数据结构实验目的和要求：该文件描述了一系列数据结构实验的必做部分，这些实验是针对《数据结构（C语言版）》一书的相关章节内容设计的。实验的目的在于加深学习者对数据结构中线性表操作的理解和应用，特别是...
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 615
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
2：数据结构：列表与元组
weidl001的博客
09-27 770
它是一个可变的序列，支持任意类型的数据元素，可以动态调整长度。是一种键值对（key-value pair）的数据结构。每个键都是唯一的，可以通过键快速访问对应的值。字典非常适合存储无序的关联数据。与列表类似，但它是不可变的，这意味着元组一旦创建，不能修改其内容。这种不可变性使得元组在需要确保数据安全或不可变的场景中非常有用。字典非常适合存储无序的关联数据，例如学生成绩、商品价格等。是一种无序、不重复的元素集合。它适合用于去重和集合运算，如交集、并集等。集合可以用来快速去重，或进行集合运算。
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 478
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
数据结构（Map、Set、搜索树）
wuweixiaoyue的博客
09-27 816
概念优势：查找元素时可以直接砍去一半的值，达到 log(N)示例：此时如果要找4，因为4比6小，所以要去6的左边找，此时因为4比3大，所以要去3的右树找，最终找到了如果找到了就返回，如果直到全部找完遇到null了也没找到，说明该搜索树下根本就没有该元素有序问题：二叉搜索树的中序遍历是有序的概念：Map和Set是专门用来进行搜索的容器或数据结构Set是纯key模型，Map是 Key-Value 模型Set最大的功能就是对集合中的元素进行去重接口实例化。
数据结构和算法基础（一）
叶子叶来
09-30 547
趁空闲时间刷一遍极客时间上王争的《数据结构与算法之美》课程，个人觉得写的很好，每章节由浅入深且从基础到引入设计类问题，如果写过很多代码想要进行架构设计转型时再回头看这些基础知识还蛮有趣的，以下纪录下随着课程走的部分实现代码和思考； 内容主要是笔记和代码，注：手写一遍代码是有必要的；
Java：插入排序
xiaochuan_bsj的博客
09-28 624
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；直接插入排序是稳定的，由上面图片能看到它是具有稳定性的，但如果是代码部分的 arr[j] > tmp 改为：arr[j] >= tmp，以上面的2a和2b为例，它们的顺序就会发生变化。所谓的排序，就是使一串记录，按照某个或某些关键字的大小，递增或递减的排列起来的操作。
王道408考研数据结构-树与二叉树-第五章-第三四节
qq_55882840的博客
09-23 983
对应的递归算法如下： 2.中序遍历(InOrder) 对应的递归算法如下： 3.后序遍历(PostOrder) 对应的递归算法如下： 4.递归算法和非递归算法的转换 图5.10用带箭头的虚线表示了这三种遍历算法的递归执行过程。其中，向下的箭头表示更深一层的递归调用，向上的箭头表示从递归调用退出返回；虚线旁的三角形、圆形和方形内的字符分别表示在先序、中序和后序遍历的过程中访问根结点时输出的信息。例如，由于中序遍历中访问结点是在遍历左子树之后、遍历右子树之前进行的，
python-ds：Python 中的数据结构库（适用于面试的数据结构和算法合集）
技术无疆
09-27 1926
python-ds 是一个开源的 Python 数据结构库，旨在提供多种高级数据结构的实现，如链表、树、图等。这些数据结构可用于解决各种计算问题，增强 Python 在数据处理和算法开发方面的能力。
bjfu数据结构图书管理系统
09-09
bjfu数据结构图书管理系统是一个基于线性表的图书信息管理系统。它包括了创建和输出图书信息表、排序、修改、逆序村春、最贵图书的查找、最爱图书的查找、最佳位置图书的查找、新图书的入库、旧图书的出库、图书去重等常用的基本操作。该系统使用了顺序存储结构和链式存储结构来实现。 该系统的设计参考了《数据结构习题解析与实验指导》一书中的第一个实验。 其中，图书去重的实现是通过遍历图书信息表，对于重复的图书进行删除。具体的实现代码如下： ``` void DeleteRepeatInformation(table *T) { int flag; for(int i=0;i<T->length;i++){ for(int j=i+1;j<T->length;j++){ if(strcmp(T->date[i].name,T->date[j].name)==0){ DeleteInformation(T,j+1); j=j-1; } } } } ``` 该函数会删除重复的图书，保留第一本出现的图书。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CresCent_Charles

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

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

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

打赏作者

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

抵扣说明：

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

余额充值