考研数据结构之栈的实现

最新推荐文章于 2022-10-10 08:27:13 发布
最新推荐文章于 2022-10-10 08:27:13 发布
阅读量446 收藏 1
点赞数
分类专栏： 考研专业课 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Calarqiang/article/details/108041340
版权

栈的顺序实现和链式实现

1.栈的定义

栈是只允许在一端进行插入或者删除的受限制的线性表。

几个概念：

  1. 栈顶：线性表允许进行操作（删除和插入）的那一端。
  2. 栈低：固定的，线性表不允许操作的那一端。
  3. 空栈：即和空线性表一样，指的是里面并没有元素。在线性表中，我们判定空表的依据是length=0,而在栈中判定的条件是top=-1.

栈的数学性质： 重点
考研中可能会出现给定几个元素分别入栈，然后要你判断有几种出栈的方式？
此时就可以记住一个结论，或者说是一个公式，即卡特兰（Catalan）数

具体公式为：
出栈的不同排列的个数为： 1 n + 1 C 2 n n \frac{1}{n+1}C^{n}_{2n} n+11​C2nn​
这里为了打出卡特兰数真的是费劲了周折，哈哈！

2.栈的基本操作—栈的顺序静态存储和动态存储

2.1.0 静态分配和动态分配的结构体类型：

静态分配的结构

typedef struct stack {
	ElementType data[Maxsize];  //静态分配数组的长度
	int top; //栈顶指针
}sqStack;

动态分配的结构

typedef struct stack {
	ElementType *data;  //动态分配数组的指针
	int top; //栈顶指针
}sqStack;

这里的静态分配和动态分配唯一不同的点是：静态分配刚开始就已经分配了一个固定大小的内存空间，而动态分配并没有分配固定的空间大小，而是用指针去指向一个动态分配的数组！

2.1.1 静态分配函数声明和动态分配的函数声明

基本操作函数声明：

//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
2.1.2 静态分配函数实现

基本操作函数的实现

//初始化一个空栈
void InitStack(sqStack & S) {
	S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
}
//栈判空
Status StackEmpty(sqStack S) {
	if (S.top == -1) {
		return True;
	}
	else {
		return False;
	}
}
//进栈
Status push(sqStack & S, ElementType x) {
	//首先要判断栈是否满了，即可不可能发生溢出
	if (S.top == Maxsize - 1) {
		printf("栈满了，无法进行入栈操作\n");
		return False;
	}
	else {
		S.data[++S.top] = x;  //这里相当于两句，即先将栈顶指针+1，然后再进行栈顶元素赋值操作
		return True;
	}

}
//出栈
Status pop(sqStack & S, ElementType & x) {
	//首先要判断栈是否为空
	if (StackEmpty(S)) {
		printf("栈为空，无法进行出栈操作\n");
		return False;
	}
	else {
		x = S.data[S.top--]; //先将值取出，然后栈顶指针进行-1操作。
		return True;
	}

}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
	if (StackEmpty(S)) {
		printf("栈为空，无法获取栈顶元素\n");
		return False;
	}
	else {
		x = S.data[S.top]; //将栈顶元素的值赋值给变量x
		return True;
	}
};
2.1.3 动态分配的函数实现—唯一不同点，即初始化和对Maxsize的处理
//初始化一个空栈
void InitStack(sqStack & S) {
	S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
	S.data = (ElementType *)malloc(sizeof(ElementType) *  MAXSIZE);
}
2.1.4 静态分配的完整代码：

静态分配完整代码：

/**
author:Calarqiang
date:2020-8-15
message:栈的顺序存储之静态分配
*/
#include<stdio.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 20
typedef int ElementType;
typedef int Status;
typedef struct stack {
	ElementType data[Maxsize];  //静态分配数组的长度
	int top; //栈顶指针
}sqStack;

/*
栈的各种操作
*/
//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
int main() {
	int x;  //用于辅助获取栈顶元素
	int elem; //用于给栈中元素赋值
	sqStack S;
	InitStack(S); //初始化栈
	//入栈操作
	printf("请输入要入栈的元素，以-1结束\n");
	scanf("%d", &elem);
	while (elem != -1) {
		push(S, elem);
		scanf("%d", &elem);
	}

	printf("下面开始打印栈顶元素\n");
	GetTop(S, x);
	printf("栈顶元素为:%d\n", x);
	printf("下面开始出栈操作\n");
	while (!StackEmpty(S)) {
		pop(S, x);
		printf("出栈的元素值为:%d\t", x);
	}
	return 0;
}

//初始化一个空栈
void InitStack(sqStack & S) {
	S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
}
//栈判空
Status StackEmpty(sqStack S) {
	if (S.top == -1) {
		return True;
	}
	else {
		return False;
	}
}
//进栈
Status push(sqStack & S, ElementType x) {
	//首先要判断栈是否满了，即可不可能发生溢出
	if (S.top == Maxsize - 1) {
		printf("栈满了，无法进行入栈操作\n");
		return False;
	}
	else {
		S.data[++S.top] = x;  //这里相当于两句，即先将栈顶指针+1，然后再进行栈顶元素赋值操作
		return True;
	}

}
//出栈
Status pop(sqStack & S, ElementType & x) {
	//首先要判断栈是否为空
	if (StackEmpty(S)) {
		printf("栈为空，无法进行出栈操作\n");
		return False;
	}
	else {
		x = S.data[S.top--]; //先将值取出，然后栈顶指针进行-1操作。
		return True;
	}

}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
	if (StackEmpty(S)) {
		printf("栈为空，无法获取栈顶元素\n");
		return False;
	}
	else {
		x = S.data[S.top]; //将栈顶元素的值赋值给变量x
		return True;
	}
};
2.1.5 动态分配的完整代码：—注意看MAXSIZE全局变量！
/**
author:Calarqiang
date:2020-8-15
message:栈的顺序存储之动态分配
*/
#include<stdio.h>
#include<malloc.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 5
typedef int ElementType;
typedef int Status;
typedef struct stack {
	ElementType *data;  //动态分配数组的指针
	int top; //栈顶指针
}sqStack;

/*
栈的各种操作
*/
//初始化一个空栈
void InitStack(sqStack & S);
//栈判空
Status StackEmpty(sqStack S);
//进栈
Status push(sqStack & S, ElementType x);
//出栈
Status pop(sqStack & S, ElementType & x);
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x);
//定义一个全局变量，用于记录扩容前后的最大容量大小
int MAXSIZE = Maxsize;
int main() {
	int x;  //用于辅助获取栈顶元素
	int elem; //用于给栈中元素赋值
	int flag=0; //用于记录是否需要扩充内存
	int size; //用于记录扩容的大小
	sqStack S;
	InitStack(S); //初始化栈
	//入栈操作
	printf("请输入要入栈的元素，以-1结束\n");
	scanf("%d", &elem);
	while (elem != -1) {
		if (!push(S, elem)) {
			break; //如果栈满了就停止输入值，退出循环
		}
		scanf("%d", &elem);
	}
	printf("是否继续进行入栈操作，是输入1，不是输入0\n");
	scanf("%d", &flag);
	if (flag) {
		//重新分配存储空间，继续入栈
		printf("下面开始重新扩容空间,请输入要扩容的大小\n");
		scanf("%d", &size);
		//扩容后，MAXSIZE就从define的Maxsize为5变为size
		MAXSIZE = size;
		S.data = (ElementType *)realloc(S.data, sizeof(ElementType)*size);
		printf("请输入要入栈的元素，以-1结束\n");
		scanf("%d", &elem);
		while (elem != -1) {
			if (!push(S, elem)) {
				break; //如果栈满了就停止输入值，退出循环
			}
			scanf("%d", &elem);
		}
	}
	else {
		;
	}
	

	printf("下面开始打印栈顶元素\n");
	GetTop(S, x);
	printf("栈顶元素为:%d\n", x);
	printf("下面开始出栈操作\n");
	while (!StackEmpty(S)) {
		pop(S, x);
		printf("出栈的元素值为:%d\t", x);
	}
	return 0;
}

//初始化一个空栈
void InitStack(sqStack & S) {
	S.top = -1; //将栈顶指针初始化为-1,使其始终指向栈顶元素
	S.data = (ElementType *)malloc(sizeof(ElementType) *  MAXSIZE);
}
//栈判空
Status StackEmpty(sqStack S) {
	if (S.top == -1) {
		return True;
	}
	else {
		return False;
	}
}
//进栈
Status push(sqStack & S, ElementType x) {
	//首先要判断栈是否满了，即可不可能发生溢出
	if (S.top == MAXSIZE -1) {
		printf("栈满了，无法进行入栈操作\n");
		return False;
	}
	else {
		S.data[++S.top] = x;  //这里相当于两句，即先将栈顶指针+1，然后再进行栈顶元素赋值操作
		return True;
	}

}
//出栈
Status pop(sqStack & S, ElementType & x) {
	//首先要判断栈是否为空
	if (StackEmpty(S)) {
		printf("栈为空，无法进行出栈操作\n");
		return False;
	}
	else {
		x = S.data[S.top--]; //先将值取出，然后栈顶指针进行-1操作。
		return True;
	}

}
//读取栈顶元素,并返回该值
Status GetTop(sqStack S, ElementType & x) {
	if (StackEmpty(S)) {
		printf("栈为空，无法获取栈顶元素\n");
		return False;
	}
	else {
		x = S.data[S.top]; //将栈顶元素的值赋值给变量x
		return True;
	}
};

总结：
动态分配和静态分配唯一不同的就是在初始化的地方和在于它可以在动态分配的内存不足的情况下，可以继续追加内存，分别使用malloc函数和realloc函数！
注意：动态分配要巧妙地运用Maxsize，起初Maxsize是预定义的大小，即开始数组分配的长度，然后如果追加空间时， 此时的Maxsize就要变大，因此必须使用一个全局变量MAXSIZE来动态改变大小，达到扩容！

链表的顺序存储总结：

  1. 一般都是初始化栈时，规定其top指针的值为-1
  2. 入栈是先将top指针的值+1，然后再插入指定的值
  3. 出栈是先将值赋值给一个变量，然后再将top指针的值-1

灵活变通： 此操作考研不用考虑
对于如果top指针的初始值为0的情况：此时初始化下top指针指向栈顶的下一个元素
入栈：先将值存入，然后再将top指针值+1
出栈：先将top指针值-1,然后再将此时指针指向的值赋值。

3.栈的基本操作—栈的链式存储

基本操作函数声明：

//初始化一个链栈，即构造一个头结点
void InitStack(LiStack & S);
//栈判空
Status StackEmpty(LiStack S);
//进栈  什么时候用void,什么时候用Status?因为链栈不会存在栈满情况，除非电脑内存崩溃
void push(LiStack & S, ElementType x);
//出栈
Status pop(LiStack & S, ElementType & x);
//读取栈顶元素,并返回该值
void PrintStack(LiStack S);
//销毁栈
Status DestoryStack(LiStack & S);

链栈的结构体结构：

typedef struct stack {
	ElementType data; //数据域
	struct stack * next;//保存下一个节点的指针域
}sqStack ,*LiStack;

基本操作函数实现：

//初始化一个空栈
void InitStack(LiStack & S) {
	S = (LiStack)malloc(sizeof(sqStack));
	S->next = NULL;
}
//栈判空
Status StackEmpty(LiStack S) {
	if (S->next == NULL) {
		return True;
	}
	else {
		return False;
	}
}
//入栈 头插法 为什么要用头插法？因为头插法正好模拟了栈的先进后出的特点
void push(LiStack & S, ElementType x) {
	LiStack node = (LiStack)malloc(sizeof(sqStack)); //给新结点分配内存，第一个结点为栈顶元素
	node->data = x;
	node->next = S->next;
	S->next = node;
}
//出栈
Status pop(LiStack & S, ElementType & x) {
	//首先判断栈是否为空
	if (S->next == NULL) {
		return False;
	}
	else {
		LiStack p = S->next; //建立一个结点，用于指向栈顶元素，即第一个有效结点
		x = p->data;//将栈顶元素返回
		S->next = p->next; //让头结点的next指向新的栈顶元素
		free(p); //释放栈顶元素
	}
	


}
//读取栈顶元素,并返回该值  打印栈中元素
void PrintStack(LiStack S) {
	LiStack p = S->next;//建立工作打印指针
	int count = 1; //记录栈中元素个数
	while (p!= NULL) {
		printf("栈中的第%d个元素为：%d\n",count, p->data);
		p = p->next;
		count++;
	}
};

//销毁栈
Status DestoryStack(LiStack & S) {
	if (S->next == NULL) {
		free(S);
		S = NULL;
		return Ok;  //这里的return Ok和return True无法用于判断是空栈还是有元素的栈
	}
	else {
		LiStack p = S->next;//建立工作指针
		LiStack q = p; //建立跟班指针
		while (p != NULL) {
			p = p->next;
			free(q);
			q = p;
		}
		return True;
	}
	
}

完整代码：

/**
author:Calarqiang
date:2020-8-15
message:栈的链式存储 链栈
*/
#include<stdio.h>
#include<malloc.h>
#define True 1
#define False 0
#define Ok 1
#define Error 0
#define Maxsize 20
typedef int ElementType;
typedef int Status;
typedef struct stack {
	ElementType data; //数据域
	struct stack * next;//保存下一个节点的指针域
}sqStack ,*LiStack;

/*
栈的各种操作
*/
//初始化一个链栈，即构造一个头结点
void InitStack(LiStack & S);
//栈判空
Status StackEmpty(LiStack S);
//进栈  什么时候用void,什么时候用Status?因为链栈不会存在栈满情况，除非电脑内存崩溃
void push(LiStack & S, ElementType x);
//出栈
Status pop(LiStack & S, ElementType & x);
//读取栈顶元素,并返回该值
void PrintStack(LiStack S);
//销毁栈
Status DestoryStack(LiStack & S);
int main() {
	int x;  //用于辅助获取栈顶元素
	int elem; //用于给栈中元素赋值
	LiStack S = NULL;
	InitStack(S); //初始化栈
	//入栈操作
	//入栈操作
	printf("请输入要入栈的元素，以-1结束\n");
	scanf("%d", &elem);
	while (elem != -1) {
		push(S, elem);
		scanf("%d", &elem);
	}
	printf("下面开始打印栈的元素\n");
	PrintStack(S);
	printf("下面开始销毁栈结构\n");
	//因为True和Ok均是1，所以这里不能这样判断，除非设置为不同的值！
	/*if (DestoryStack(S) == True) {
		printf("空栈销毁成功!\n");
	}
	else {
		printf("有元素的栈销毁成功\n");
	}*/
	if (DestoryStack(S)) {
		printf("栈销毁成功！\n");
	}
	return 0;
}

//初始化一个空栈
void InitStack(LiStack & S) {
	S = (LiStack)malloc(sizeof(sqStack));
	S->next = NULL;
}
//栈判空
Status StackEmpty(LiStack S) {
	if (S->next == NULL) {
		return True;
	}
	else {
		return False;
	}
}
//入栈 头插法 为什么要用头插法？因为头插法正好模拟了栈的先进后出的特点
void push(LiStack & S, ElementType x) {
	LiStack node = (LiStack)malloc(sizeof(sqStack)); //给新结点分配内存，第一个结点为栈顶元素
	node->data = x;
	node->next = S->next;
	S->next = node;
}
//出栈
Status pop(LiStack & S, ElementType & x) {
	//首先判断栈是否为空
	if (S->next == NULL) {
		return False;
	}
	else {
		LiStack p = S->next; //建立一个结点，用于指向栈顶元素，即第一个有效结点
		x = p->data;//将栈顶元素返回
		S->next = p->next; //让头结点的next指向新的栈顶元素
		free(p); //释放栈顶元素
	}
	


}
//读取栈顶元素,并返回该值  打印栈中元素
void PrintStack(LiStack S) {
	LiStack p = S->next;//建立工作打印指针
	int count = 1; //记录栈中元素个数
	while (p!= NULL) {
		printf("栈中的第%d个元素为：%d\n",count, p->data);
		p = p->next;
		count++;
	}
};

//销毁栈
Status DestoryStack(LiStack & S) {
	if (S->next == NULL) {
		free(S);
		S = NULL;
		return Ok;  //这里的return Ok和return True无法用于判断是空栈还是有元素的栈
	}
	else {
		LiStack p = S->next;//建立工作指针
		LiStack q = p; //建立跟班指针
		while (p != NULL) {
			p = p->next;
			free(q);
			q = p;
		}
		return True;
	}
	
}

总结：

  1. 栈的链式存储巧妙运用了单链表的头插法，让插入元素的顺序和最后链表的顺序相反，即实现了栈的先进后出特点！
  2. 区分链栈的插入为何返回值为void?因为它很难出现内存分配不够的情况！所以不用判断内存分配失败的情况。
  3. 所有链栈的操作都只能在表头进行操作（插入和删除元素），它就像单链表每次删除和添加元素都是从第一个有数据的结点进行操作！

明天会继续学习栈的具体应用举例！加油每一天！！！前面的线性表的基本操作和应用也会尽快整理出来！

Calarqiang
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言findelem函数,数据结构——顺序表操作集（C语言）
weixin_29466397的博客
05-20 829
数据结构——顺序表操作集(C语言)本题要求实现顺序表的操作集。函数接口定义：List MakeEmpty();Position Find( List L, ElementType X );bool Insert( List L, ElementType X, Position P );bool Delete( List L, Position P );其中List结构定义如下：typedef in...
数据结构简单要点总结（转）
weixin_30872499的博客
08-11 123
第三章 栈、队列和数组 一、栈 栈是只能在一端进行插入和删除的线性表。 （别看只是个定义，非常重要，已经道出了运算方法：只能在一端插入和删除。) 栈的特征：后进先出，先进后出。 插入和删除元素的一端称为栈顶。（说明了我们在栈顶操作） 另一端称为栈底。 插入元素和删除元素的操作称为入栈和出栈。 1.顺序栈 结构：(...
数据结构第三章总结
一只想高飞的小鸟
10-10 169
栈队列
数据结构-栈（考研篇）
Weightlessly的博客
02-19 463
栈 定义 栈是只允许在一端进行插入或删除的线性表 特点：后进先出（LIFO） PS： 逻辑结构：与普通线性表相同 数据的运算：插入、删除操作有区别 基本操作 n个不同元素进栈，出栈元素不同的排列个数为： 顺序栈（数组） 如果是top指向下一个将要插入的结点的存储位置，则push操作先插入再top++ 如果是top表示当前栈顶元素，则先top++再插入 下例是第一种情况： #include <stdio.h> #include <stdlib.h> #define MA
数据结构课件 队列是只允许在一端删除，在另一端插入的线性表。
01-07
数据结构课件 队列是只允许在一端删除，在另一端插入的线性表。
22考研数据结构ppt
07-15
这份"22考研数据结构ppt"提供了丰富的学习资源，帮助考生全面了解和掌握这一领域的重要概念、算法和应用。 首先，我们要理解数据结构是什么。数据结构是组织和存储数据的方式，它不仅包括数据的物理存储方式，还...
408考研数据结构思维导图
最新发布
01-02
这个“408考研数据结构思维导图”集合了王道课程中的关键概念，帮助考生以一种更直观、有条理的方式理解和复习数据结构的知识。 第一章：绪论 在这一章，通常会介绍数据结构的基本概念，包括数据、数据元素、数据...
数据结构考研习题集.rar
07-20
"数据结构考研习题集"是一个专门为考研者设计的资源，包含了大量的练习题和答案，旨在帮助考生深入理解和熟练运用数据结构的各种概念。 该习题集可能包含了以下关键知识点： 1. **线性结构**：如数组、链表、队列...
考研数据结构算法总结
02-06
本资源“考研数据结构算法总结”正是为了帮助考生全面理解和掌握这一领域的关键知识。 首先，数据结构主要包括数组、链表、栈、队列、树（二叉树、平衡树、堆）、图以及哈希表等。每种数据结构都有其特定的应用场景...
考研王道数据结构代码.zip
11-26
这些代码可能包括链表、数组、栈、队列、树、图、散列表等各种经典数据结构的实现，同时也可能包含排序和查找算法。 1. 链表：链表是一种动态数据结构，可以高效地插入和删除元素，但随机访问效率较低。链表包括...
顺序栈的基本操作(C语言实现，简单易懂！)
若丶尘的博客
10-04 4387
一、学习内容 1、 顺序栈初始化 2、 顺序栈的入栈 3、 顺序栈的出栈 4、 顺序栈取栈顶 5、 顺序栈的清空 6、 顺序栈的销毁 7、 顺序栈的判空 8、 顺序栈的判满 9、所有元素出栈 10、求栈元素个数
线性表-顺序表
weixin_43789078的博客
07-12 103
数据结构-顺序表-线性表线性表静态数组动态数组顺序表的操作插入操作删除操作查找操作 线性表 逻辑相邻的元素和在物理结构上也是相邻的 一般使用数组来存储顺序表，数组可以是多维，顺序表只能是一维的 sizeof(Element Type)计算某个数据类型的存储空间 可以使用Loc(A)+index*sizeof(Element Type)定位元素 静态数组 //静态分配数组 #define ElementType int #define Maxsize 50 typedef struct { Ele
数据结构与算法（五）—— 栈及其实现和应用
小羽毛的博客
12-16 2412
注：本篇内容参考了《Java常用算法手册》、《大话数据结构》和《Java编程（第四版）》三本书籍。 本人水平有限，文中如有错误或其它不妥之处，欢迎大家指正！ 目录 1.栈的概述 2.栈的操作 2.1入栈(Push) 2.2出栈(Pop) 2.3返回栈项(Peek) 3.进出栈的变化形式 3.1 示例 3.2规则 4. 栈的存储结构及其实现 4.1栈的存...
Status StackEmpty(SqStack S)
qq_41787953的博客
06-25 4042
Status StackEmpty(SqStack S) { if (S.base == S.top) return OK; else return ERROR; }
数据结构实验之栈八：栈的基本操作
wangsimiao118的博客
08-09 258
这道题主要是考察栈的进栈和出栈操作，需要注意的是输出是要注意输出的格式，看清题目要求。 代码如下： #include #include #define maxsize 100 using namespace std; typedef struct{/*栈的定义*/     int data[maxsize];     int top; }Seqstack; Seqstack
栈的基本操作（初始化、判断栈是否为空、数制转换、出入栈、求栈中元素个数、获得栈顶元素值）
weixin_45220224的博客
10-27 5521
#include<stdio.h> //若用printf,scanf,getchar,putchar,gets,puts函数需包含该头文件 #include<stdlib.h> #include<malloc.h> //用malloc,free,realloc函数需包含该头文件 #include<conio.h> //若用getch()使得屏幕暂停，需包含该头文件 #define OVERFLOW 0; #define STACK_INIT_...
数据结构-栈的灵活表示方式(栈顶指针和栈底指针)
10-22 9507
在前面的文章中我们已经学习过基本栈的概念和操作，我们是通过“标准方式”数组的形式模拟了一个栈；本篇文章我将通过一种更灵活的方式定义栈以及实现栈的基本操作，废话不多说，直接上代码（注释都有说明哦） //栈的灵活表示法，通过定义栈顶指针和栈底指针的方式 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define ElementType ...
陈越姥姥 数据结构 线性表 实现
Dev-L的博客
10-19 745
顺序表 typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; };/* 初始化 */ List MakeEmpty() { List L; L = (List)malloc(sizeof(struct LNode
C语言学习（九）——栈
cainiao000001的博客
01-07 592
栈是一个特殊的线性表，只能在一端操作； 栈顶（top）：允许操作 的一端； 栈底（bottom）：不允许操作的一端 堆栈的定义 1.栈：是限定仅在表尾进行插入和删除操作的线性表；又称后进先出的线性表。LIFO结构。      栈顶top：允许插入和删除的一端；      栈底bottom：另外一端； 2. 空栈：不含任何数据元素的栈；top=-1; 3. 栈的操作：
数据结构经典算法
05-24
数据结构经典算法实现集合了很多经典的考研题目，并给出了相应的C语言实现，为学习者提供了实践的机会。 其中，顺序表是数据结构中最基本的一种。顺序表是一种线性结构，是由一组连续的存储单元组成的数据结构，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值