基础数据结构之顺序栈与链栈

已于 2022-11-05 01:22:21 修改
阅读量157 收藏
点赞数
分类专栏： 基础数据结构 文章标签： 数据结构 算法 c语言
于 2022-11-05 01:13:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55703811/article/details/127698783
版权

文章目录

一、栈

1.栈的定义

在这里插入图片描述

二、顺序栈

1.顺序栈的定义

在这里插入图片描述
注意：书上关于顺序栈top是指针类型，但是我们这里使用 int 类型，但含义都是一样的
在这里插入图片描述

2.顺序栈代码实现

.h头文件声明

#pragma once


typedef int ELEM_TYPE;

typedef struct Stack {
	ELEM_TYPE* base;//存储空间基址（用来接收malloc返回在堆上申请的连续空间块的起始地址）
	int top;//当前有效长度，且可以表示下一个待插入位置的下标
	int stacksize;//当前总空间大小（以格子数为单位）
}Stack, *Pstack;

//初始化

void Init_stack(struct Stack *st);

//入栈

bool Push(struct Stack* st,ELEM_TYPE val);

//出栈

bool Pop(struct Stack* st);

//获取栈顶元素值

ELEM_TYPE Top(struct Stack* st);

//判空

bool Is_full(struct Stack* st);

//判满

bool Is_empty(struct Stack* st);

//扩容*2

void Inc(struct Stack* st);

//搜索

int Search(struct Stack* st, ELEM_TYPE val);

//清空

void Clear(struct Stack* st);

//销毁

void Destory(struct Stack* st);

//打印

void Show(struct Stack* st);

//获取有效值个数

int Get_length(struct Stack* st);

.cpp功能实现代码

#include<stdio.h>
#include<stdlib.h>
#include"Stack.h"
#include <cassert>
#define STACK_INIT_SIZE 100

//初始化
void Init_stack(struct Stack* st) {
	assert(st != NULL);
	st->base = (ELEM_TYPE*)malloc(STACK_INIT_SIZE * sizeof(ELEM_TYPE));
	assert(st->base != NULL);
	st->top = 0;  //即代表下一个合适的插入位置下标为0，也代表当前有效位置为0
	st->stacksize = STACK_INIT_SIZE;
}

//入栈(队尾插入)
bool Push(struct Stack* st, ELEM_TYPE val) {
	//0.安全性处理
	assert(st!=NULL);//保证顺序表的头结点存在

	//1.如果站还有空间，则将之val插入到top指向的格子里面
	if (Is_full(st)) {
		Inc(st);
	}
	st->base[st->top] = val;
	st->top++;
	return true;
}

//出栈（队尾删除）
bool Pop(struct Stack* st) {
	assert(st != NULL);
	if (Is_empty(st)) {
		return false;
	}
    st->top--;
	return true;
}

//获取栈顶元素值
ELEM_TYPE Top(struct Stack* st) {
	assert(st != NULL);
	if (Is_empty(st)) {
		return NULL;
	}
	ELEM_TYPE val = st->base[st->top-1];
	return val;
}

//判空
bool Is_full(struct Stack* st) {
	assert(st != NULL);
	if (st->top == 0) {
		return true;
	}
	return false;
}

//判满
bool Is_empty(struct Stack* st) {
	assert(st != NULL);
	//当前有效格子数等于当前总格子数，则满
	if (st->top == st->stacksize) {
		return true;
	}
	return false;
}

//扩容*2
void Inc(struct Stack* st) {
	assert(st != NULL);
	ELEM_TYPE *tmp = (ELEM_TYPE*)realloc(st->base,2 * STACK_INIT_SIZE * sizeof(ELEM_TYPE));
	if (tmp == NULL) {
		printf("error\n");
		return;
	}
	st->base=tmp;
	assert(st->base != NULL);

	//扩容成功，有效长度不变，总长度变为两倍
	st->stacksize= 2 * STACK_INIT_SIZE;
}

//搜索
int Search(struct Stack* st, ELEM_TYPE val) {
	assert(st != NULL);
	for (int i = 0; i <st->top; i++) {
		if (val == st->base[i]) {
			return i;
		}
	}
	return -1;
}

//清空
void Clear(struct Stack* st) {
	assert(st != NULL);
	/*while (st->top != 0) {
		st->top--;
	}*/
	st->top = 0;
}

//销毁
void Destory(struct Stack* st) {
	assert(st != NULL);
	free(st->base);
	st->stacksize = st->top = 0;
}

//打印
void Show(struct Stack* st) {
	assert(st!= NULL);
	for (int i = 0; i < st->top; i++) {
		printf("%d", st->base[i]);
	}
	printf("\n");
}

//获取有效值个数
int Get_length(struct Stack* st) {
	assert(st != NULL);
	int count = 0;
	for (int i = 0; i < st->top; i++) {
		count++;
	}
	return count;
}

main 测试代码

int main() {
	struct Stack head;
	Init_stack(&head);
	for (int i = 1; i <= 10; i++) {
		Push(&head,i);
	}
	Show(&head);
	Pop(&head);
	Show(&head);
	ELEM_TYPE n= Top(&head);
	printf("%d\n", n);
	int a=Search(&head, 5);
	printf("%d\n", a);
	for (int i = 11; i <= 100; i++) {
		Push(&head,i);
	}
	Show(&head);
	Inc(&head);
	for (int i = 0; i <= 10; i++) {
		Push(&head,i);
	}
	Show(&head);
	
}

3.顺序栈的常见形态

在这里插入图片描述

三、链栈

1.链栈的定义

这里要注意，链栈一定是头插和头删，因为时间复杂度为O(1),而尾插时间复杂度为O(n),我们不选择
在这里插入图片描述
头部插入：入栈
头部删除：出栈

2.代码实现

.h头文件

#pragma once


typedef int ELEM_TYPE;
typedef struct LStack {
	//数据域
	ELEM_TYPE data;
	//指针域
	struct LStack* next;
}Lstack,Pstack;

//链式操作实现
//初始化
void Init_LStack(struct LStack* pstack);

//入栈（相当于单链表的头插）
bool push(struct LStack* pstack, ELEM_TYPE val);

//出栈（相当于单链表头删）
bool Pop(struct LStack* pstack);

//获取栈顶元素值 //不能删除
ELEM_TYPE Top(struct LStack* pstack);

//判空
bool Is_Empty(struct LStack* pstack);

//搜索
struct LStack* reserch(struct LStack* pstack, ELEM_TYPE val);

//清空
void Clear(struct LStack* pstack);

//销毁1
void Destory1(struct LStack* pstack);

//销毁2
void Destory2(struct LStack* pstack);

//打印
void Show(struct LStack* pstack);

//获取有效值个数
int Get_length(struct LStack* pstack);

.cpp功能代码实现

#include "list_stack.h"
#include<stdio.h>
#include<stdlib.h>
#include <cassert>


//初始化
void Init_LStack(struct LStack* pstack) {
	assert(pstack != NULL);
	pstack->next = NULL;
}

//入栈（相当于单链表的头插）
bool push(struct LStack* pstack, ELEM_TYPE val) {
	assert(pstack != NULL);
	struct LStack* snewnode = (struct LStack*)malloc(sizeof(LStack));
	snewnode->data=val;
	snewnode->next = pstack->next;
	pstack->next = snewnode;
	return true;
}

//出栈（相当于单链表头删）
bool Pop(struct LStack* pstack) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	pstack->next = p->next;
	free(p);
	return true;
}

//获取栈顶元素值 //不能删除
ELEM_TYPE Top(struct LStack* pstack) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	ELEM_TYPE temp = p->data;
	return temp;
}

//判空
bool Is_Empty(struct LStack* pstack) {
	assert(pstack != NULL);
	if (pstack->next = NULL) {
		return true; 
	}
	return false;
}

//搜索
struct LStack* reserch(struct LStack* pstack, ELEM_TYPE val) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	for (; p != NULL; p=p->next) {
		if (val == p->data) {
			return p;
		}
	}
	return NULL;
}

//清空
void Clear(struct LStack* pstack) {
	assert(pstack != NULL);
	Destory1(pstack);
}

//销毁1
void Destory1(struct LStack* pstack) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	for (; p!= NULL;p=p->next) {
		Pop(p);
	}
}

//销毁2
void Destory2(struct LStack* pstack) {
	assert(pstack != NULL);
	
	struct LStack* p = pstack->next;
	struct LStack* q = p;
	pstack->next = NULL;
	while (p != NULL) {
		q = p->next;
		free(p);
		p = q;
	}
}

//打印
void Show(struct LStack* pstack) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	for (; p != NULL; p = p->next) {
		printf("%d ", p->data);
	}
	printf("\n");
}

//获取有效值个数
int Get_length(struct LStack* pstack) {
	assert(pstack != NULL);
	int count = 0;
	struct LStack* p = pstack->next;
	for (; p != NULL; p = p->next) {
		count++;
	}
	return count;
}

.main测试代码

int main() {
	struct LStack head;
	Init_LStack(&head);
	for (int i = 1; i <= 10; i++) {
		push(&head,i);
	}
	Show(&head);
	Pop(&head);
	Show(&head);
	ELEM_TYPE res= Top(&head);
	printf("%d", res);
}
淡蓝色的经典
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构课程：顺序栈和链栈的实现
10-16
数据结构课程中顺序栈和链栈的操作实现，实现语言为C语言
数据结构-栈的应用：顺序栈与链栈的应用
03-22
数据结构-栈的应用：顺序栈与链栈的应用
数据结构：顺序栈与链栈
WangGarrison的博客
09-02 2336
栈
C语言实现数据结构——顺序栈与链栈
chfens的博客
04-02 2085
C语言实现顺序栈与链栈的基本功能。
【数据结构】顺序栈和链栈（带图详解）
Z1tai的博客
11-11 1421
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
数据结构-顺序栈和链栈
LWJLWJ_的博客
05-27 482
一、栈 1. stack 基本概念 概念：stack是一种先进后出的数据结构，它只有一个出口。 栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为 栈中进入数据称为 — 入栈 push 栈中弹出数据称为 — 出栈 pop
【数据结构】顺序栈和链栈的实现
qq_51639901的博客
03-18 2305
目录 顺序栈 链栈 栈是限定仅在表尾进行插入或者删除操作的线性表。表尾端称为“栈顶（top）”，表头端称为栈底（bottom）。不含元素的空表称为空栈。 栈的修改按后进先出的原则进行，即后进先出（last in first out）如下图所示 顺序栈 下面看顺序栈的结构体定义 typedef struct { SElemType *base;//栈底指针 SElemType *top;//栈顶指针 int stacksiz...
【严蔚敏版数据结构】你分得清顺序栈和链栈吗
kokunka的博客
04-11 1025
顺序栈是由两个指针，即栈顶top指针、栈底base指针来掌控大局的。同时，还有栈长度stacksize这个辅助。链栈是爱盯梢的头指针大哥S。
【数据结构】顺序栈和链栈
Jacky_Feng的博客
09-14 835
文章目录 一、栈的定义 二、栈的顺序存储结构及实现 1.顺序栈的定义 2.顺序栈的进栈和出栈操作 （1）进栈操作 （2）出栈操作 三、栈的链式存储结构及实现 1.链栈的定义 2.链栈的进栈和出栈操作 （1）进栈操作 （2）出栈操作 前言 栈是一种特殊的线性表，其特殊在于栈的基本操作是线性表操作的一个子集。栈按“后进先出”的规则进行操作，故称其为操作受限的线性表。 一、栈的定义 栈（stack）是限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除一端为线性表的表尾..
顺序栈与链栈的实现与区别
qq_44750091的博客
06-02 7867
顺序栈 顺序栈是指利用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时设有指针top指示栈顶元素在顺序栈中的位置；另设指针base指示栈底元素在顺序栈中的位置。当top和base的值相等时，表示空栈。 顺序栈的存储实现 #define MAXSIZE 100 typedef struct { SElemType *base;//栈底指针 SElemType *top;//栈顶指针 int stacksize;//栈可用的最大容量 }SqStack; 顺序栈的初始
数据结构：顺序栈和链栈
qq_41962968的博客
01-16 303
/* * 程序名：seqstack1.c，此程序演示顺序栈的实现，数据元素是整数。 * */ #include <stdio.h> #include <string.h> #define MAXSIZE 10 // 顺序栈的最大长度。 typedef int ElemType; // 自定义顺序栈的数据元素为整数。 typedef struct { ElemType data[MAXSIZE]; // 用数组存储顺序栈中的元素。 int...
数据结构《顺序栈和链栈》
AsUs.的博客
11-26 322
有关顺序栈和链栈的基本操作：创建栈，入栈，出栈，取栈顶元素，求栈的长度，清空栈，释放栈 顺序栈： #include<bits/stdc++.h> using namespace std; #define MAXSIZE 200000 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int ElemType; typed.
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
注：分为四个内容：顺序栈、链栈、循环队列、链队列。代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求...
顺序栈、链栈将10进制转为2、8、16进制源码
03-25
采用C++语言实现利用顺序栈、链栈将10进制数转为2、8、16进制数。 通过本编程实例，可以进一步了解到顺序栈和链栈之间区别和联系，体会两者的异同，进一步加深知识印象，是不错的练习素材哦。
数据结构链栈与顺序栈
01-26
基于严蔚敏数据结构第二版，其中的链栈与顺序栈的代码，经本人调试通过，操作平台为VS2010WIN32应用台程序，详情见附件代码！
浙江大学数据结构MOOC-课后习题-第十讲-排序4 统计工龄
最新发布
chan1ee的博客
05-28 223
题目汇总。
二叉树顺序结构实现【堆的实现】【详细图解】
LiU11e的博客
05-28 677
二叉树（堆）顺序结构的实现，并带有堆排序拓展
二叉树的链式结构（二叉树）与顺序结构（堆）---数据结构
Zjxbxv11的博客
05-28 457
下面是树的示意图：注意：在树形结构中，子树之间不能有交集，否则就不是树形结构！！！例如下面的这几棵树就不是树形结构：1->结点的度：一个结点所含的子树的个数称为该结点的度； 如上图：A的有6颗子树，故A的度为6。2->叶结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I、P、Q、....等结点都为叶结点。3->非终端结点或分支结点：度不为0的结点； 如上图：A、D、E、F、G...等结点为分支结点。4->双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的
希尔排序法
qq_24946843的博客
05-28 222
gap=2，从a[2]开始，a[2]和a[0]进行插入排序，a[3]和a[1]插入排序，a[4]和a[2]、a[0]插入排序......上面gap=2，即5，14，18，27，68为一组；13，20，36，39，51为一组。可以发现左边都是较小的数据，右边都是较大的数据，更方便把分成的每一个组进行插入排序。为什么 要采取上面分组的方法呢（gap），换一种方法也可以吗？
数据结构顺序栈和链栈
10-14
顺序栈和链栈都是栈的两种实现方式，它们的主要区别在于底层数据结构不同。 顺序栈使用数组作为底层数据结构，实现简单，但容量固定，需要预先分配一定的空间。当栈满时，需要进行扩容操作，这会导致时间复杂度为 O...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

淡蓝色的经典

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

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

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

打赏作者

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

抵扣说明：

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

余额充值