【脚踢数据结构】深入理解栈

这篇具有很好参考价值的文章主要介绍了【脚踢数据结构】深入理解栈。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  • (꒪ꇴ꒪ ),Hello我是祐言QAQ
  • 我的博客主页:C/C++语言,Linux基础,ARM开发板,软件配置等领域博主🌍
  • 快上🚘,一起学习,让我们成为一个强大的攻城狮!
  • 送给自己和读者的一句鸡汤🤔:集中起来的意志可以击穿顽石!
  • 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏

一、什么是栈?

        栈是一种重要的数据结构。它是一种特殊的线性表,特殊在只允许在表的一端进行插入和删除操作,这一端被称为栈顶,相对的,另一端被称为栈底。在这篇博客中,我们将详细地介绍栈的概念,包括顺序栈链栈的实现。   

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

         栈是一种线性数据结构,它遵循 "先入后出"(Last-In-First-Out,LIFO)的原则。这意味着最后插入栈的元素将首先被移除,而最早插入的元素将最后被移除。就像如果1先进入了栈底,你想再拿到它,那么就要先把 6 5 4 3 2依次拿出来才能拿到 1。

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

 二、顺序栈

        顺序栈是栈的一种实现方式,它是用一组连续的存储单元存储栈中的元素,并需要一个栈顶指针 *top指出栈顶元素,初始化为-1,栈的大小 size则决定了最多可以放多少数据。

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

                                                                    顺序栈结构体

1.顺序栈的管理结构体

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

typedef int Datatype;

//顺序栈结构体
typedef struct Sequent_stack
{
	Datatype *stack;		//存放数据的位置
	int size;				//栈的大小
	int top;				//栈顶偏移
}S_stack;

2.初始化

//初始化顺序栈
S_stack *init_stack(int size)
{
	S_stack *s1= malloc(sizeof(S_stack));
	if (s1 != NULL)
	{
		s1->stack = calloc(size, sizeof(Datatype));
		s1->size = size;
		s1->top = -1;
	}
	return s1;
}


3.判断栈空栈满

//是否栈空
bool isempty(S_stack *s)
{
	return (s->top == -1);
}

//是否栈满
bool isfull(S_stack *s)
{
	return (s->top == s->size-1);
}

4.压栈(入栈)

//压栈
bool push(S_stack *s, Datatype data)
{
	if (isfull(s))
	{
		return false;
	}
	//将栈顶往上偏移一个
	s->top++;
	//将数据,放到栈顶指向的位置
	s->stack[s->top] = data;  //*(s->stack+s->top) = data;
	return true;
}

5.弹栈(出栈)

//弹栈
bool pop(S_stack *s, Datatype *data)
{
	if (isempty(s))
	{
		return false;
	}
	//先拿到栈顶指向的数据
	*data = s->stack[s->top];//data = *(s->stack+s->top);
	//栈顶在往下偏移一个
	s->top--;
	return true;
}

6.遍历顺序栈

//遍历栈
void display(S_stack *s)
{
	for (int i = 0; i <= s->top; ++i)
	{
		printf("%d ", s->stack[i]);
	}
	printf("\n");
}

练习:

        输入一个大于零的十进制数,转化为八进制,转化过程中使用顺序栈结构来实现。输入: 123  输出 :转化为八进制是 0173

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

         完整代码:

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

typedef int Datatype;

//顺序栈结构体
typedef struct Secqune_stack
{
	Datatype *stack;		//存放数据的位置
	int size;				//栈的大小
	int top;				//栈顶偏移
}S_stack;

//初始化顺序栈
S_stack *init_stack(int size)
{
	S_stack *s1= malloc(sizeof(S_stack));
	if (s1 != NULL)
	{
		s1->stack = calloc(size, sizeof(Datatype));
		s1->size = size;
		s1->top = -1;
	}
	return s1;
}

//栈空
bool isempty(S_stack *s)
{
	return (s->top == -1);
}

//栈满
bool isfull(S_stack *s)
{
	return (s->top == s->size-1);
}

//压栈(入栈)
bool push(S_stack *s, Datatype data)
{
	if (isfull(s))
	{
		return false;
	}
	//将栈顶往上偏移一个
	s->top++;
	//将数据,放到栈顶指向的位置
	s->stack[s->top] = data;  //*(s->stack+s->top) = data;
	return true;
}

//弹栈(出栈)
bool pop(S_stack *s, Datatype *data)
{
	if (isempty(s))
	{
		return false;
	}
	//先拿到栈顶指向的数据
	*data = s->stack[s->top];//data = *(s->stack+s->top);
	//栈顶在往下偏移一个
	s->top--;
	return true;
}

int main(int argc, char const *argv[])
{
	//初始化顺序栈
	S_stack *s = init_stack(22);
	int num;
	scanf("%d", &num);
	while(num)
	{
		push(s, num%8);
		num/=8;
	}
	printf("十进制数转为八进制数等于:0");
	int data;
	while(!isempty(s))
	{
		pop(s, &data);
		printf("%d", data);
	}
	printf("\n");

	return 0;
}

三、链式栈

        链式栈是栈的另一种常见实现方式,它通过链表来表示栈的结构。链式栈相对于顺序栈的一个主要优势是它可以动态地调整大小,适用于栈容量需求不确定或需要频繁的插入和删除操作的情况。与之相对应的是链式栈也需要更多的内存空间用于存储节点指针。

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

        在具体的指针操作方面与单项链表相似。

1.链式栈的管理结构体


typedef int Datatype;

typedef struct Node
{
	Datatype data;			//数据
	struct Node *prev;		//指向上一个节点
}node;

//链式栈的节点
typedef struct List_stack
{
	node *stack;		//每一个节点的数据
	int size;			//长度
}Lstack;

2.初始化

//初始化链式栈
Lstack *init_list_stack()
{
	Lstack *s = malloc(sizeof(Lstack));
	if (s!=NULL)
	{
		s->stack = NULL;
		s->size = 0;
	}
	return s;
}

3.判断栈空

        由于链式栈独特的结构使之不会出现栈满的情况,而是根据需要随时动态调整栈容量,因此我们无需判断链式栈是否栈满。

//链式栈的栈空判断
bool isempty(Lstack *s)
{
	return (s->size == 0);
}

4.压栈

//压栈(入栈)
bool push(Lstack *s, Datatype data)
{
	node *new = malloc(sizeof(node));
	if (new != NULL)
	{
		//如果new不为空
		new->data = data;
		//新节点的prev指向栈原来的尾部
		new->prev = s->stack;
		//新节点现在是不是就变为现在链式栈的尾部
		s->stack = new;
		//栈的大小+1
		s->size++;
		return true;
	}
	else
	{
		return false;
	}
}

5.弹栈

//弹栈(出栈)
bool pop(Lstack *s, Datatype *data)
{
	//栈空
	if (isempty(s))
	{
		return false;
	}
	//先将栈的尾部(栈顶)的节点的地址拿到
	*data = s->stack->data;
	//将尾部(栈顶)的节点往前挪一个
	s->stack = s->stack->prev;
	//链式栈的节点个数-1
	s->size--;
	return true;
}

练习:

        输入一个大于零的十进制数,转化为十六进制,转化过程中使用链式栈结构来实现。输入: 123  输出 :转化为八进制是 0x7B  

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

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

typedef int Datatype;

typedef struct Node
{
	Datatype data;			//数据
	struct Node *prev;		//指向上一个节点
}node;

//链式栈的节点
typedef struct List_stack
{
	node *stack;		//每一个节点的数据
	int size;			//长度
}Lstack;

//初始化链式栈
Lstack *init_list_stack()
{
	Lstack *s = malloc(sizeof(Lstack));
	if (s!=NULL)
	{
		s->stack = NULL;
		s->size = 0;
	}
	return s;
}

//链式栈的栈空判断
bool isempty(Lstack *s)
{
	return (s->size == 0);
}

//压栈(入栈)
bool push(Lstack *s, Datatype data)
{
	node *new = malloc(sizeof(node));
	if (new != NULL)
	{
		//如果new不为空
		new->data = data;
		//新节点的prev指向栈原来的尾部
		new->prev = s->stack;
		//新节点现在是不是就变为现在链式栈的尾部
		s->stack = new;
		//栈的大小+1
		s->size++;
		return true;
	}
	else
	{
		return false;
	}
}

//弹栈(出栈)
bool pop(Lstack *s, Datatype *data)
{
	//栈空
	if (isempty(s))
	{
		return false;
	}
	//先将栈的尾部(栈顶)的节点的地址拿到
	*data = s->stack->data;
	//将尾部(栈顶)的节点往前挪一个
	s->stack = s->stack->prev;
	//链式栈的节点个数-1
	s->size--;
	return true;
}

int main(int argc, char const *argv[]) {
    Lstack *s = init_list_stack();
    int num;
    Datatype data;
    char hexDigits[] = "0123456789ABCDEF";  // 十六进制字符表示
    printf("请输入一个十进制数:");
    scanf("%d", &num);

    while (num > 0) {
        int num1 = num % 16;
        push(s, num1);
        num /= 16;
    }

    printf("转化为十六进制是:0x");
    while (!isempty(s)) {
        pop(s, &data);
        printf("%c", hexDigits[data]);
    }
    printf("\n");

    // 释放内存
    while (pop(s, &data)) {
        free(s->stack);
        s->stack = s->stack->prev;
    }
    free(s);

    return 0;
}

四、顺序栈和链栈的比较


        顺序栈和链栈是栈的两种不同实现方式,它们各有优点和缺点。

        1.空间分配:顺序栈需要一次性分配一整块连续的内存空间,可能导致空间浪费。而链栈则可以动态分配空间,用多少分配多少,因此在内存利用上更有优势。

        2.时间复杂度:由于顺序栈是基于数组的,因此在访问元素时可以直接通过索引进行访问,时间复杂度为O(1)。而链栈需要通过指针进行遍历,时间复杂度为O(n)。

        3.插入和删除:两者在插入和删除操作上都是O(1)的时间复杂度。顺序栈通过改变栈顶指针位置进行插入和删除,链栈通过改变指针的指向进行插入和删除。

五、栈的应用


        栈在计算机科学和日常编程中扮演着重要的角色,以下是一些常见的使用场景:

        1.函数调用:每当程序调用一个函数时,系统会将返回地址和必要的信息存入系统栈中,待函数运行完毕后再从栈中恢复这些信息。

        2.表达式求值:栈可以用于算术或逻辑表达式的求值。例如,计算机程序通常使用两个栈来处理数学表达式,一个栈用于存储操作数,另一个栈用于存储运算符。

        3.括号匹配:栈可以用于检查一段文本中的括号是否正确匹配。当遇到一个开括号时,将其压入栈中。当遇到一个闭括号时,从栈顶弹出一个开括号,如果能够匹配,则继续处理,否则就是不匹配。

        总的来说,栈是一种非常实用的数据结构,理解和掌握栈以及其操作对于深入理解计算机程序的运行机制以及编写高效的代码有着重要的作用。

        另外留一个括号匹配的题,代码会放评论区。

【脚踢数据结构】深入理解栈,脚踢数据结构,数据结构,链表,算法

 

六、总结

        学习数据结构是一个漫长的过程,但只要我们持续不断地学习和实践,就一定能够掌握它。希望这篇文章能帮助你对栈有更深的理解和应用。如果你有任何问题或者想要讨论的点,欢迎在下面的评论区留言。

       

        更多C语言Linux系统ARM板实战数据结构相关文章,关注专栏:

   手撕C语言

            玩转linux

                    脚踢数据结构

                            6818(ARM)开发板实战文章来源地址https://www.toymoban.com/news/detail-642709.html

📢写在最后

  • 今天的分享就到这啦~
  • 觉得博主写的还不错的烦劳 一键三连喔~
  • 🎉感谢关注🎉

到了这里,关于【脚踢数据结构】深入理解栈的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 深入理解Java线程池ThreadPoolExcutor实现原理、数据结构和算法(源码解析)

    什么是线程池?         线程池主要是为了解决执行新任务执行时,应用程序为减少为任务创建一个新线程和任务执行完毕时销毁线程所带来的开销。通过线程池,可以在项目初始化时就创建一个线程集合,然后在需要执行新任务时重用这些线程而不是每次都新建一个线

    2024年02月07日
    浏览(45)
  • 【脚踢数据结构】

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,Linux基础,ARM开发板,软件配置等领域博主🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏

    2024年02月13日
    浏览(42)
  • 【脚踢数据结构】查找

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,Linux基础,ARM开发板,软件配置等领域博主🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,可在评论区指正,感谢

    2024年02月11日
    浏览(49)
  • 【脚踢数据结构】图(纯享版)

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,Linux基础,ARM开发板,软件配置等领域博主🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,可在评论区指正,感谢

    2024年02月12日
    浏览(36)
  • 【脚踢数据结构】队列(顺序和链式)

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,Linux基础,ARM开发板,软件配置等领域博主🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,可在评论区指正,感谢🙏

    2024年02月12日
    浏览(38)
  • 【数据结构】带你深入理解栈

    栈是一种特殊的线性表。其只允许在固定的一端进行插入和删除元素的操作,进行数据的插入和删除的一端称作 栈顶 ,另外一端称作 栈底 。 栈不支持随机访问 ,栈的数据元素遵循 后进先出 的原则,即 LIFO(Late In First Out)。 也许有人曾经听说过 压栈 和 入栈 的术语,以

    2024年02月03日
    浏览(43)
  • 【数据结构】 顺序表详解!深入理解!

    🎥 屿小夏 : 个人主页 🔥个人专栏 : 数据结构解析 🌄 莫道桑榆晚,为霞尚满天! ​ 什么是数据结构?我们为什么要学数据结构?数据结构中的顺序表长什么样子?它是怎么运用? ​ 本期我们将对这些一一讲解,彻底明白数据结构的重要性,以及顺序表是一种什么的数据

    2024年02月08日
    浏览(42)
  • 深入理解数据结构:队列的实现及其应用场景

    队列(Queue)是一种具有先进先出(FIFO)特性的数据结构。在队列中,数据的插入和删除操作分别在队列的两端进行。插入操作在队列的尾部进行,而删除操作则在队列的头部进行。这种特性使得队列在很多实际应用中非常有用,比如任务调度、缓冲区管理等。 线性表是一种

    2024年04月28日
    浏览(53)
  • 【算法与数据结构】链表

    链表是由一串节点串联在一起的,链表的每个节点存储两个信息:数据+下一个节点的地址 分清楚两个概念:什么是内存内部,什么是程序内部 内存内部: 信息存储在内存空间里的 程序内部: 通过什么信息,去操作结构 如果想操作链表的话,我们依靠的是程序内部的信息,

    2024年02月03日
    浏览(45)
  • 【数据结构与算法】链表

    对于顺序表存在一些缺陷: 中间/头部的插入删除,时间复杂度为O(N) 。头部插入需要挪动后面的元素 增容需要申请新空间,拷贝数据,释放旧空间。会有不小的消耗。 增容一般是呈2倍的增长,势必会有一定的空间浪费。例如当前容量为100,满了以后增容到200,我们再继续插

    2023年04月09日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包