C语言数据结构基础--限定链表--栈的应用

已于 2023-10-26 23:29:46 修改
阅读量52 收藏
点赞数 1
文章标签： 数据结构 链表 算法
于 2023-10-21 19:06:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhwx666/article/details/133848564
版权

   栈结构具有“后进先出”（LIFO)的特性，使得栈在程序设计中发挥重要作用。本篇文章将讨论栈应用的两个经典例子。

一，括号匹配问题

 1.算法思想

    检验算法中可设置一个栈，每读入一个括号，若是左括号，直接入栈，等相匹配的同类右括号；

若读入右括号，且与当前栈顶左括号相匹配，则将栈顶左括号出栈，否则便不合法，直接返回错误。此外，如果输入序列已经读完，而栈中仍有等待的左括号，即栈非空，或者读入一个右括号，而栈中已无相匹配的左括号，皆是不合法的。只有输入序列与栈同时为空，才说明括号完全匹配。

2.算法实现

          这里我们不妨设括号运算符只有圆括号，方括号，花括号，尖括号四种，他们可以相互嵌套，如（{<>}){(}或{}<>()[]等。何为合法，自然如{}[]()或[(<{}>)]之类。据此，我们得到下面算法的判断条件。

        此算法的实现主要依赖于栈的实现。我这里便以我上篇文章栈的实现中，实现的线栈来操作。此外，就是判断两个符号是否匹配，键值对的设置倒是可以便于使用，不过与其在C中再建立键值对，用哈希表，倒不如把这些括号类型直接枚举出来，用switch进行匹配。

下面便是我用来检测括号是否匹配的函数：

int Char_Match(char x) {
	switch (x) { // 输入右括号，返回其左括号对应的ASCLL值
	case ')':
		return ((int)'(');
	case ']':
		return ((int)'[');
	case '>':
		return ((int)'<');
	case '}':
		return ((int)'{');
	}
}

       之所以如此设计，是因为我前面的链栈是以int类型存储数据元素的，改的话比较麻烦(偷懒,流汗),因此将括号对应的ASCLL值存入栈中，匹配与否也拿其匹配括号的ASCLL值比较判断。

        当然，还有一点，前面我的压栈函数 void  Push_LS(Head head)，只引入一个形参，也就是所要操作的栈，在运行中输入所要压入的元素，自然不方便这里的检测，所以需要进行小制衡。

void  D_Push_LS(Head head,char c) {
	
	LS* node = (Head)malloc(sizeof(LS));  // 申请新的LS空间
	node->date = (int)c;                    // 数据赋值
	node->next = head->next;              // 把之前的数据元素连在他后面
	head->next = node;                    // 把他接在头结点后面
	++head->date;                         // 数量加一 
}

        余下的就是算法的核心，也就是如何判断，其中所使用函数除了上文添改的两个，余下的就是上篇文章实现的栈的基本操作。

bool Bracket_Match(char* str) {
	Head L_B = Init_LS();
	for (int i = 0; str[i] != '\0'; ++i) { // 对字符串逐一扫描
		switch (str[i]) {
		case '(':
		case '[':
		case '<':
		case '{':
			D_Push_LS(L_B,str[i]);  // 将左括号都压入栈内
			break;					// 将右括号拿出来与栈内左括号进行配对
		case ')':
		case ']':
		case '>':
		case '}':									
			if (L_B->date == 0) {		// 如果栈已空，但下一个是右括号，说明括号并不匹配，直接返回false			
				printf("右边不对\n");	// 因为我这个是存储int类型的链栈，
				return false;			// 所以将字符转化为其相应的ASCLL值来比较
			}							// Char_Match() 函数也是将右括号对应的左括号的ASCLL值进行返回	
			else if (Char_Match(str[i]) == L_B->next->date) {
										// 左右括号匹配，那么就可以消去栈内的左括号，然后进行下一个括号的匹配
				Pop_LS(L_B);
			}
			else return false;          // 左右不匹配，那就不匹配喽，直接返回false
		}
	}
	if (L_B->date == 0) // 直到字符串遍历结束，栈也空者，经历了考验，他们是匹配的
	{
		return true;
	}
	else return false;

}

void Test099() {
	char a[13] = "(({[< > ]}))";
	if (Bracket_Match(a)) {
		printf("True!!!\n");
	}
	else printf("False!!!\n");
}

https://mp.csdn.net/mp_blog/creation/editor/133800054icon-default.png?t=N7T8https://mp.csdn.net/mp_blog/creation/editor/133800054上篇文章，栈的实现。

二,表达式求值

1.前缀式，中缀式，后缀式

        表达式求值是高级语言编译中的一个基本问题，是栈的典型应用案例。任何一个表达式都是由运算对象(Operand),运算符(Operator)和界限符(Delimiter)组成的。运算对象既可以是常数，也可以是被说明为变量或常量的标识符；运算符可以分为算术运算符，关系运算符和逻辑运算符三类；基本界限符有括号和表达式结束符等。

        表达式分为三种记录方式，根据运算符与运算对象的位置不同，分为前缀式(波兰式)，中缀式，后缀式。

前缀式：运算符在其所要操作数的前方。

中缀式：与我们日常写法一致，运算符在其操作数之间。

后缀式：与前缀式相反，运算符在其所要操作数的后方。

我们可以以中缀式为例，写出其对应的前后缀表达式来理解此三种表达式。

例：

        中缀式：5+6*（4+5-8/2）+5-7

        前缀式：- + + 5 * 6 - + 4 5 / 8 2 5 7

        后缀式：5 6 4 5 + 8 2 / - * + 5 + 7

        或许有人吃惊，前后缀表达式不应该让运算符在操作数前面吗，这怎么鱼龙混杂的。这就要细看前面的定义了，其所要操作的数的前或后，也就是两个相应操作数之前或之后，因此可以根据此规定，遇到运算符时，可以很容易找到他们对应的运算数。

        由于我们日常接受中缀式，一时难以适应前后缀式，但我们要知道电脑是不如我们大脑那般灵活，可以直接将中缀式中各种运算符以及界限符号所蕴含的表达式运算优先级看穿。一个括号就可以直接令他们费解了。因此可以发现我们的前后缀式，将原来中缀式的括号“溶解”了，也就是将括号所蕴含的优先级关系直接通过前后缀表达式的方式展现。

        利用计算机计算表达式，通常需要将中缀式转换为前缀式或后缀式，然后求解。

2.算法思路

        这里提供一个无括号中缀式求解算法思路：

        1.首先，我们可以建立一个运算符优先级表，然后利用F(x,y)查阅此表,输入x='+',y='*',返回'<';之类，返回值类型可以自己定义，只要可以判断两运算符的优先级关系即可。（说的通俗其实就是整个可以判断运算符优先级的操作功能就行）。

        2.其次，我们要将从表达式中提取出来的操作数与运算符分别存储在运算数栈（OVS）与运算符栈（OPTR）。（为什么如此？因为我们每次操作就是判断两个相邻运算符的优先级，然后对其前或后的两个操作数进行简单的运算操作。通过栈，弹出一个运算符，再弹俩操作数，比较方便。）

        3.自左向右扫描表达式，进行如下操作：

        遇到运算数，就将其压入OVS栈中；遇到运算符就将它与OPTR栈顶的运算符进行优先级比较：

        若当前运算符优先级大于栈顶运算符优先级，就将其压入OPTR栈中。

        若当前运算符优先级小于等于栈顶运算符优先级，就将栈顶运算符退栈出来，然后与从OVS栈中连续退出的两个运算数进行运算，然后将其运算结果压入OVS栈中。（这里需要注意我们是从左向右扫描表达式，故入栈顺序是从左向右，根据栈的定义可知，出栈顺序是从右向左，因此第一个弹出来的运算数是中缀式情况下运算符右侧的数，需要注意顺序）

        

3.算法实现

代码实现如下：

int Operataion_B(char BDS[]) {
	IS* IS = Init_IS();
	CS* CS = Init_CS();

	while (1) {
		if (BDS[i] >= '0' && BDS[i] <= '9' && BDS[i + 1] >= '0' && BDS[i + 1] <= '9') { // 两位及以上字符转化成数字存放
			int j = i;
			int sum = 0;
			while (BDS[j] >= '0' && BDS[j] <= '9') {
				sum = (BDS[j] - '0') + sum * 10;
				++j;
			}
			IS_Push(IS, sum);
			i = j - 1;

		}
		else if (BDS[i] == '=') { // 截至条件，把里面的值运算返回
			if (CS_Top(CS)) {
				while (CS_Top(CS)) {
					int R = IS_Pop(IS);
					int L = IS_Pop(IS);
					IS_Push(IS, Value_Operator(R, L, CS_Pop(CS)));
				}
			}
			return IS_Top(IS);
		}
		else if (BDS[i] >= '0' && BDS[i] <= '9') { // 个位数存放
			IS_Push(IS, BDS[i] - '0');
		}
		else if (CS_Top(CS) == NULL) { // 空 ，第一个，直接入
			CS_Push(CS, BDS[i]);
		}
		else { // 非空，比较边算边入
			if (Char_Comper(CS_Top(CS), BDS[i])) { // 前面的大，算前面,// bukezhijie压后面 这样会失去一次判断机会，所以还是不要走近道
				int R = IS_Pop(IS);
				int L = IS_Pop(IS);
				IS_Push(IS, Value_Operator(R, L, CS_Pop(CS)));
				--i; // 这里老规矩，图省事，虽然现在看来并不省事
				//CS_Push(CS, BDS[i]);
			}
			else { // 后面优先，算后面，前面不用管，此计只可解无括号之围，非长计也
				// 长远之计，在于把运算符优先级高的后方暂存，等一切结算后再清算
				//char Op = BDS[i]; // 因为要变i,只好先把符号记录下来
				//++i; // 搞下一个数
				//IS_Push(IS, Value_Operator(GetNumber(BDS) , IS_Pop(IS),Op ));
				CS_Push(CS, BDS[i]);				
			}
		}
		++i;
	}
}

        

//数值计算 L =Left,前面的数，R=Right,后面的数,注意顺序
int Value_Operator(int R, int L, char x) {
	switch (x) {
	case '+':
		return L +R;
	case '-':
		return L - R;
	case '*':
		return L * R;
	case '/':
		return L / R;
	case '%':
		return L % R;
	}
}

此代码只是实现无括号的整数运算，各位可根据此思路扩展此算法。

补充：扩展了括号与负数的运算，要扩展到实数就得改改栈的数据类型了，后面再补充；

int Operataion_D(char BDS[]) {
	IS* IS = Init_IS();
	CS* CS = Init_CS();

	while (1) {
		if (BDS[i] >= '0' && BDS[i] <= '9' && BDS[i + 1] >= '0' && BDS[i + 1] <= '9') { // 两位及以上字符转化成数字存放
			int j = i;
			int sum = 0;
			while (BDS[j] >= '0' && BDS[j] <= '9') {
				sum = (BDS[j] - '0') + sum * 10;
				++j;
			}
			IS_Push(IS, sum);
			i = j - 1;

		}
		else if (BDS[i] == '=') { // 截至条件，把里面的值运算返回
			if (CS_Top(CS)) {
				while (CS_Top(CS)) {
					int R = IS_Pop(IS);
					int L = IS_Pop(IS);
					IS_Push(IS, Value_Operator(R, L, CS_Pop(CS)));
				}
			}
			return IS_Top(IS);
		}
		else if (BDS[i] == ')') { // 截至条件，把里面的值运算返回
			if (CS_Top(CS)!='(') {
				while (CS_Top(CS) != '(') {
					if (CS_Top(CS) == '-') {
						IS_Push(IS, - IS_Pop(IS));
						CS_Pop(CS);
					}
					else {
						int R = IS_Pop(IS);
						int L = IS_Pop(IS);
						IS_Push(IS, Value_Operator(R, L, CS_Pop(CS)));
					}
				}
			}
			CS_Pop(CS);
			
		}
		else if (BDS[i] >= '0' && BDS[i] <= '9') { // 个位数存放
			IS_Push(IS, BDS[i] - '0');
		}
		else if (CS_Top(CS) == NULL) { // 空 ，第一个，直接入
			CS_Push(CS, BDS[i]);
		}
		else { // 非空，比较边算边入
			if (Char_Comper(CS_Top(CS), BDS[i])) { // 前面的大，算前面,// bu ke zhijie压后面 这样会失去一次判断机会，所以还是不要走近道
				int R = IS_Pop(IS);
				int L = IS_Pop(IS);
				IS_Push(IS, Value_Operator(R, L, CS_Pop(CS)));
				--i; // 这里老规矩，图省事，虽然现在看来并不省事
				//CS_Push(CS, BDS[i]);
			}
			else { // 后面优先，算后面，前面不用管，此计只可解无括号之围，非长计也
				// 长远之计，在于把运算符优先级高的后方暂存，等一切结算后再清算
				//char Op = BDS[i]; // 因为要变i,只好先把符号记录下来
				//++i; // 搞下一个数
				//IS_Push(IS, Value_Operator(GetNumber(BDS) , IS_Pop(IS),Op ));
				CS_Push(CS, BDS[i]);
			}
		}
		++i;
	}
}
bool Char_Comper(char a,char b) {
	if (a == '('|| b == '(') return false;
	int A = Char_Grade(a), B = Char_Grade(b);
	return A >= B;
}

好了，哥们克服懒惰，虽说就是在原代码上再改进了些（狗头），但作用范围拓展到了所有实数：

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


typedef struct Char_Stack_char
{
	char date;
	struct Char_Stack_char* next;
}CSC;

typedef struct Linked_List_Stack_char
{
	float date;
	struct Linked_List_Stack_char* next;
}ISC;

ISC* Init_ISC() {
	ISC* head = (ISC*)malloc(sizeof(ISC)); // 分配空间
	head->date = 0;                       // 存栈长度
	head->next = NULL;
	return head;
}

CSC* Init_CSC() {
	CSC* head = (CSC*)malloc(sizeof(CSC)); // 分配空间
	head->date = '0';                       // 存栈长度
	head->next = NULL;
	return head;
}
//只需要压栈，出栈,初始化

void  CSC_Push(CSC* head, char c) {

	CSC* node = (CSC*)malloc(sizeof(CSC));  // 申请新的LS空间
	node->date = c;                    // 数据赋值
	node->next = head->next;              // 把之前的数据元素连在他后面
	head->next = node;                    // 把他接在头结点后面

}

void ISC_Push(ISC* head, float x) {
	ISC* node = (ISC*)malloc(sizeof(ISC));  // 申请新的LS空间
	node->date = x;                    // 数据赋值
	node->next = head->next;              // 把之前的数据元素连在他后面
	head->next = node;                    // 把他接在头结点后面
	++head->date;
}

char CSC_Pop(CSC* head) {
	if (head->next == NULL) {
		return NULL;
	}
	CSC* temp = head->next; // 为了最后释放此空间，留个指针指向该空间
	char Top = head->next->date;
	head->next = temp->next;
	free(temp);
	return Top;
}

float ISC_Pop(ISC* head) {
	if (head->next == NULL) {
		return 0;
	}
	ISC* temp = head->next; // 为了最后释放此空间，留个指针指向该空间
	float Top = head->next->date;
	head->next = temp->next;
	free(temp);
	--head->date;
	return Top;
}
//
float ISC_Top(ISC* head) {
	if (head->next == NULL) {
		return 0;
	}
	return head->next->date;
}

char CSC_Top(CSC* head) {
	if (head->next == NULL) {
		return 0;
	}
	return head->next->date;
}

//表达式运算

//运算符优先级判断
//给他个值表示优先级
int  Char_Grade_char(char a) {
	switch (a) {
	case '+':
	case '-':
		return 0;
	case '*':
	case '/':
	case '%':
		return 1;
	}
}

bool Char_Comper_char(char a, char b) {
	if (a == '(' || b == '(') return false;
	int A = Char_Grade_char(a), B = Char_Grade_char(b);
	return A >= B;
}

//数值计算 L =Left,前面的数，R=Right,后面的数,注意顺序
float Value_Operator_char(float R, float L, char x) {
	switch (x) {
	case '+':
		return L + R;
	case '-':
		return L - R;
	case '*':
		return L * R;
	case '/':
		return L / R;
	/*case '%':
		return L % R;*/
	}
}

const int Max = 40;
int Math_TQ_char(char a, char b) {
	return (a - 48) * 10 + (b - 48);
}

float Operataion(char BDS[]) {
	ISC* IS = Init_ISC();
	CSC* CS = Init_CSC();
	int i = 0;
	while (1) {
		if (BDS[i] >= '0' && BDS[i] <= '9' && BDS[i + 1] >= '0' && BDS[i + 1] <= '9') { // 两位及以上字符转化成数字存放
			int j = i;
			float sum = 0;
			while (BDS[j] >= '0' && BDS[j] <= '9') {
				sum = (BDS[j] - '0') + sum * 10;
				++j;
			}
			if (BDS[j] == '.') {  // 如果是小数
				++j;
				float chushu = 10;
				while (BDS[j] >= '0' && BDS[j] <= '9') {
					sum = (BDS[j] - '0') / chushu + sum;
					++j;
					chushu *= 10;
				}
			}
			ISC_Push(IS, sum);
			i = j - 1;

		}
		else if (BDS[i] >= '0' && BDS[i] <= '9' && BDS[i + 1] == '.') { // 一位有小数点数字符转化成数字存放
			int j = i+2;
			float sum = BDS[i]-'0';
			float chushu = 10;
			while (BDS[j] >= '0' && BDS[j] <= '9') {
				sum = (BDS[j] - '0')/chushu + sum ;
				++j;
				chushu *= 10;
			}
			ISC_Push(IS, sum);
			i = j - 1;

		}
		else if (BDS[i] == '=') { // 截至条件，把里面的值运算返回
			if (CSC_Top(CS)) {
				while (CSC_Top(CS)) {
					float R = ISC_Pop(IS);
					float L = ISC_Pop(IS);
					ISC_Push(IS, Value_Operator_char(R, L, CSC_Pop(CS)));
				}
			}
			return ISC_Top(IS);
		}
		else if (BDS[i] == ')') { // 截至条件，把里面的值运算返回
			if (CSC_Top(CS) != '(') {
				while (CSC_Top(CS) != '(') {
					if (CSC_Top(CS) == '-') {
						ISC_Push(IS, -ISC_Pop(IS));
						CSC_Pop(CS);
					}
					else {
						int R = ISC_Pop(IS);
						int L = ISC_Pop(IS);
						ISC_Push(IS, Value_Operator_char(R, L, CSC_Pop(CS)));
					}
				}
			}
			CSC_Pop(CS);

		}
		else if (BDS[i] >= '0' && BDS[i] <= '9') { // 个位数存放
			ISC_Push(IS, BDS[i] - '0');
		}
		else if (CSC_Top(CS) == NULL) { // 空 ，第一个，直接入
			CSC_Push(CS, BDS[i]);
		}
		else { // 非空，比较边算边入
			if (Char_Comper_char(CSC_Top(CS), BDS[i])) { // 前面的大，算前面,// bu ke zhijie压后面 这样会失去一次判断机会，所以还是不要走近道
				float R = ISC_Pop(IS);
				float L = ISC_Pop(IS);
				ISC_Push(IS, Value_Operator_char(R, L, CSC_Pop(CS)));
				--i; // 这里老规矩，图省事，虽然现在看来并不省事
				//CS_Push(CS, BDS[i]);
			}
			else { // 后面优先，算后面，前面不用管，此计只可解无括号之围，非长计也
				// 长远之计，在于把运算符优先级高的后方暂存，等一切结算后再清算
				//char Op = BDS[i]; // 因为要变i,只好先把符号记录下来
				//++i; // 搞下一个数
				//ISC_Push(ISC, Value_Operator(GetNumber(BDS) , ISC_Pop(ISC),Op ));
				CSC_Push(CS, BDS[i]);
			}
		}
		++i;
	}
}

int main() {
	char BDS[Max];
	memset(BDS, 0, sizeof(BDS));
	printf("请输入表达式，遇到'='结束\n");
	scanf("%s", BDS);
	printf("%.4f", Operataion(BDS));
	return 12;
}

括号的处理可以特殊定义，如前括号存入栈，遇到其相匹配的后括号，就可以将括号中元素取出来运算，结束后将他们的值压入OVS中，而实数就可以在获取数字的地方扩展。

本文就主要介绍栈的应用，令大家熟悉栈的操作，更多细节。如有更好意见，望各位不吝赐教，感谢。

hhhwx666
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构栈-C语言实现链表
qq_39397165的博客
07-21 457
最近复习数据结构，遇到一道算法题，从尾打印链表，使用的是入栈操作，因为栈属于“先进后出”，正好符合这个题目；借此也把栈复习一下； 1.什么是栈？ 答：保存局部变量。栈上的内容旨在函数的范围内存在，当函数运行结束，这些内容也会自动销毁。其特点是效率高，但空间大小有限。 ** 栈是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶，相应地表头端称为栈底，不含元素的空表...
北航软院04-07年数据结构与C语言程序设计
03-23
但从历年真题来看，通常会涉及数据结构的基本概念、各种数据结构的应用以及C语言的基础编程能力考查。例如，可能会让考生实现某种排序算法、设计一个简单的链表操作程序或者解决一个实际问题等。 通过以上分析可以...
C语言数据结构基础 --限定性线性表之---栈
hhhwx666的博客
10-13 110
栈，顺序栈，双端栈，链栈
c语言数据结构-栈
来自计科大一萌新的编程记录本
01-11 835
c语言数据结构-栈
C语言数据结构--栈
别下完这场雪
06-02 838
基本概念 顺序栈 链栈 数制转换 括号匹配 行编辑程序 表达式求解 汉诺塔
C语言数据结构 - 栈
Flin
11-24 2101
栈的定义 类似很多软件都有撤销的操作，这其实就是用栈这种方法来实现的，当然不同的软件具体实现代码会有差异，不过原理大多都是一样的。 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶(top)，另一端称为栈低(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进后出(Last In First Out)的线性表，简称LIFO结构。 栈的顺序存储结构及实现 它是顺序表的一种，具有顺...
数据结构-栈(C语言代码)
weixin_50246370的博客
08-12 5475
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct.
数据结构（C语言版）--期末考试整理
热门推荐
qq_45209073的博客
12-06 1万+
第一章 数据结构概述 基本概念与术语 1． 数据：数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被 计算机程序所处理的符号的总称。 2. 数据元素：数据元素是数据的基本单位，是数据这个集合中的个体，也称之为元素，结点，顶点记录。 （补充：一个数据元素可由若干个 数据项组成。数据项是数据的不可分割的最小单位。） 3．数据对象：数据对象是具有相同性质的数据元素的集合，是数据的一个子集。（有时候也 叫做属性。） 4． 数据结构：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 （1
c语言实现数据结构---关于线性表包括栈和队列
m0_62598965的博客
11-24 533
顺序表存储一组地址连续的存储单元依次存储线性表的数据元素，即顺序存储直接将线性表的逻辑结构映射到存储结构上，即逻辑上相邻的数据在计算机中的存储位置也是相邻的。线性表的存储结构：//定义一个顺序表#define LInit 100 //顺序表的初始大小#define LInc 10 //顺序表的存储空间增量//表的存储空间基地址，int可以换成别的类型//表的当前长度int lsize;//顺序表的存储空间大小}SQ;// 顺序表的类型包括数据域和指针域int date;
C语言数据结构基础--队列
hhhwx666的博客
10-31 224
队列的两种基本样式以及其简单功能的实现
《数据结构(C语言-耿国华版)》复习大纲参考.pdf
12-26
在C语言环境下，耿国华版的《数据结构》教材提供了全面的知识框架，帮助读者理解这一复杂的主题。 首先，我们要了解数据的基本概念。数据是现实世界事物的描述，它可以是文字符号、数字或其他形式。数据元素是数据...
毕业设计-c语言对对碰游戏源码
02-07
2. **数据结构**：可能使用数组或者链表来存储游戏板的状态，以及元素的位置和状态信息。 3. **内存管理**：动态内存分配和释放，以创建游戏元素和游戏状态的数据结构。 4. **算法**：可能涉及查找算法（如线性搜索...
数据结构(c语言版)复习资料.pdf
04-26
### 数据结构复习知识点 #### 一、数据结构基础概念 1. **数据结构定义**： - 数据结构是一门研究非数值计算的程序设计问题...在实际应用中，根据问题的特点选择合适的数据结构可以极大地提高程序的效率和可维护性。
毕业设计-c语言打字游戏代码
02-06
11. **数据结构**：如果游戏包含多个难度级别或用户历史记录，可能需要使用数组、链表或其他数据结构来存储和检索信息。 通过这个项目，学生不仅可以掌握C语言的基础知识，还能锻炼到程序设计思维、问题解决能力和...
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 675
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构----链表
新手嵌入式学习的博客
08-16 1191
数据结构顺序表中单向链表（包括有头单向链表，无头单向链表，单向循环链表）
数据结构：栈
最新发布
2301_80744520的博客
08-17 334
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 242
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值