数据结构--链式栈、顺序栈的基本实现与简单应用：进制转换

最新推荐文章于 2023-04-23 18:25:38 发布
最新推荐文章于 2023-04-23 18:25:38 发布
阅读量2.4k 收藏 21
点赞数 1
分类专栏： Data Structure and Algorithm 文章标签： 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Apollon_krj/article/details/53587290
版权

一、栈的基本概念：

1、栈（Stack），是基本数据结构中比较重要的一种，其遵循的基本原则是：先进后出（First In Last Out，FILO）；我们编程时操作系统为函数参数压栈，其系统内核栈的实现就是基于该数据结构。我们以顺序栈来介绍起基本结构。下图为一个基本的栈的结构（这是一个顺序栈）：

这里写图片描述

我们所建的栈以及内核中实现，在结构上其实并非该图所示，因为内存地址从高到低分配，所以栈应该是“口朝下”的，但是为了方便理解（现实中我们认为“底”应该在下面）所以我们用这种图来表示。栈有两个指针来标识其“头”与“尾”，其中，栈的高地址指针叫栈底指针（pBottom），栈的低地址指针叫做栈顶指针（pTop）。数据存入栈中称为数据入栈（或者压栈），数据从栈中取出来称为出栈（或者推栈）。在该图中，入栈的顺序是num1->num2->num3->num4，而出栈顺序是num4->num3->num2->num1;最先入栈的数据最后才能被推栈出来，所以叫先入后出式存储结构。

2、关于栈的口朝下还是口朝上问题，我们用一个小例子来测试一下：

# include<stdio.h>

int add(int x,int y)/*函数传参压栈顺序为从右向左*/
{
    printf("address_x = %p\naddress_y = %p\n",&x,&y);
    return (x+y);
}
int main(void)
{
    int sum = add(3,5);
    printf("sum = %d\n",sum);
}

我们将x和y的地址打印输出：

这里写图片描述

由于y先压栈，x后压栈，我们打印输出的结果显示，address_y为高地址，而address_x为低地址，所以由此我们可以得出，操作系统在栈的实现中是高地址为栈底，低地址为栈顶。因此我们还是将栈的结构图再翻过来吧：

这里写图片描述

3、满“栈”与空“栈”，听到这两个名字，也许你会认为，“满栈”就是栈已经存满了数据，而“空栈”则是栈中没有数据，那你就大错特错了。首先，我们画出两张栈的结构图：

这里写图片描述

在该图中，我们发现满栈与空栈中都没有存放数据，但是满栈pTop指针并没有指向第一块栈内存，而空栈的pTop指针指向了第一块栈内存。所以，这就是满栈与空栈的区别：
满栈：满栈的栈顶指针指向栈顶数据（没有数据时，和pBottom都指向NULL），对于满栈的操作则是，先移动栈顶指针，然后在栈顶指针所指向的内存中存入数据；
空栈：空栈的栈顶指针指向一块空内存（没有数据时，pBottom指向NULL，pTop不指向NULL），该内存的上一块内存才是最顶层的数据，对于空栈的操作则是，先在栈顶指针所指向的内存中存入数据，然后移动栈顶指针；
今天我们采用满栈来进行一系列操作。

二、顺序栈（借助数组）的实现与操作：

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

# define MAX_STACK_LEN 5    /*栈最大元素个数*/

/*顺序栈的结构体定义*/
typedef struct stack_arr
{
    int data[MAX_STACK_LEN];
    int top;//数组下标作为栈顶指针，而栈底指针不需要指定
}STACKARR;

void init_stack(STACKARR *);//初始化栈
int empty_stack(STACKARR * pS);//栈判空
int full_stack(STACKARR * pS);//栈判满
void push_stack(STACKARR *);//压栈
void traverse_stack(STACKARR *);//遍历
void pop_stack(STACKARR *);//出栈
void clear_stack(STACKARR * pS);//栈清空

int main(void)
{
    STACKARR Stack;/*创建了一个含有MAX_STACK_LEN个数据的顺序栈*/
    init_stack(&Stack);/*对该栈初始化*/

    push_stack(&Stack);
    printf("压栈完毕，栈中元素依次为（栈顶->栈底）：\n");
    traverse_stack(&Stack);

    pop_stack(&Stack);
    printf("出栈完毕，栈中元素依次为（栈顶->栈底）：\n");
    traverse_stack(&Stack);

    clear_stack(&Stack);
    printf("栈已清空");
    traverse_stack(&Stack);

    return 0;
}

void init_stack(STACKARR * pS)
{
    memset(pS->data, 0, sizeof(pS->data));
    pS->top = -1;/*满栈让栈定指针初始化在第一个地址的前一个地址*/
}

int empty_stack(STACKARR * pS)
{
    return ( (pS->top == - 1) ? (-1) : (0) );
}

int full_stack(STACKARR * pS)
{
    return ( (pS->top == MAX_STACK_LEN - 1) ? (-1) : (0) );
}

void push_stack(STACKARR * pS)
{
    int num = 0;
    int choose = 0;
    while(1){
        if(full_stack(pS) == -1){
            printf("栈已满，不能压栈!\n");
            exit(EXIT_FAILURE);
        }
        printf("请输入要压栈的数据：");
        scanf("%d",&num);
        pS->top++;/*满栈先移动指针，再存储*/
        pS->data[pS->top] = num;    
        printf("入栈成功，继续入栈？（继续输入1，结束输入2）：");
        scanf("%d",&choose);
        if(choose != 1){
            break;
        }
    }
}

void traverse_stack(STACKARR * pS)
{
    int i = 0;
    if(empty_stack(pS) == -1){
        printf("栈为空!\n");
        exit(EXIT_FAILURE);
    }
    /*从栈顶部开始遍历*/
    for(i = pS->top; i >= 0; i-- ){
        printf("%d\t",pS->data[i]);
    }
    printf("\n");
}

void pop_stack(STACKARR * pS)
{
    int choose = 0;
    while(1){
        if(empty_stack(pS) == -1){
            printf("栈为空!\n");
            exit(EXIT_FAILURE);
        }
        printf("出栈元素为：%d\n",pS->data[pS->top]);/*先出栈栈顶指针再自减1*/
        pS->top--;
        printf("出栈成功，继续出栈？（继续输入1，结束输入2）：");
        scanf("%d",&choose);
        if(choose != 1){
            break;
        }
    }
}

void clear_stack(STACKARR * pS)
{
    memset(pS->data, 0, sizeof(pS->data));
    pS->top = -1;
}

测试结果：
这里写图片描述

三、链式栈（借助链表）的实现与操作：

我们今天使用双向链表来实现（单向链表更简单，但是双向链表的复杂会使我们对栈这种结构认识更加清晰），基本结构如下：

这里写图片描述

测试代码：

/**
    *2016年12月13日10:52:39
    *Create Stack of Link
**/
#include <stdio.h>
#include <stdlib.h>

#ifndef bool
#define bool int

typedef struct stack_node{
    int data;
    struct stack_node * pDown;
    struct stack_node * pUp;
}STACKNODE;/*栈的节点结构体*/

typedef struct stack_link{
    STACKNODE * pTop;
    STACKNODE * pBottom;
}STACKLINK; /*栈顶指针与栈底指针结构体*/

enum{false,true};

void init_stack(STACKLINK *);/*初始化*/
void push_stack(STACKLINK *);/*压栈*/
void travsal_stack(STACKLINK *);/*遍历*/
void pop_stack(STACKLINK *);/*出栈*/
bool empty_stack(STACKNODE * pS);/*栈判空，链式栈不存在满栈情况，无需判满*/

int main(void)
{
    STACKLINK Stack;
    init_stack(&Stack);/*初始化栈*/

    push_stack(&Stack);/*压栈*/
    travsal_stack(&Stack);/*从栈顶开始遍历*/

    pop_stack(&Stack);/*出栈*/
    travsal_stack(&Stack);

    return 0;
}

void init_stack(STACKLINK * pS)
{
    pS->pTop = NULL;
    pS->pBottom = NULL;/*初始化将栈顶指针与栈底指针均赋空*/
    printf("初始化成功!\n");
}

void push_stack(STACKLINK * pS)
{
    int num, choose;
    STACKNODE * pNew = NULL;
    while(1){
        printf("请输入压栈数据:");
        scanf("%d",&num);

        pNew = (STACKNODE *)malloc(sizeof(STACKNODE));
        if(NULL == pNew){
            printf("内存分配失败!\n");
            exit(EXIT_FAILURE);
        }
        pNew->data = num;
        pNew->pUp = NULL;
        pNew->pDown = NULL;/*入栈元素初始化*/

        if(empty_stack(pS->pTop) == -1){/*栈为空*/
            pS->pBottom = pS->pTop = pNew;
        }
        else{/*栈不为空*/
            pS->pTop->pUp = pNew;/*上一个为新元素*/
            pNew->pDown = pS->pTop;/*新元素的下一个为原有栈顶元素*/
            pS->pTop = pNew;/*栈顶指针向上移到*/
        }

        printf("继续压栈？（继续请选1，结束请选2）:");
        scanf("%d",&choose);
        if(choose != 1){
            break;
        }
    }
}

void travsal_stack(STACKLINK * pS)
{
    STACKNODE * pMove;
    pMove = pS->pTop;

    while(1){
        if(pMove == NULL){
            break;
        }
        printf("%d\t",pMove->data);
        pMove = pMove->pDown;
    }
    printf("\n");
}

void pop_stack(STACKLINK * pS)
{
    STACKNODE * pDelete;
    int choose = 0;
    while(1){
        pDelete = pS->pTop;
        if(empty_stack(pDelete) == -1){
            printf("栈为空，出栈失败!\n");
            exit(EXIT_FAILURE);
        }
        printf("出栈元素为：%d\n",pDelete->data);
        pS->pTop = pDelete->pDown;/*栈顶指针向下移*/
        if(pS->pTop != NULL)/*注意当pS->pTop为空，即栈为空时，无pS->pTop->pUp，若不判断会出现段错误*/
            pS->pTop->pUp = NULL;/*栈顶指针的上一个（前驱指针）为空*/
        free(pDelete);

        printf("继续出栈？（继续请选1，结束请选2）:");
        scanf("%d",&choose);
        if(choose != 1){
            break;
        }
    }
}

bool empty_stack(STACKNODE * pN)
{
    return ((pN == NULL) ? -1 : 0);
}
#endif

四、栈的应用——借助栈实现进制转换：

/*用数组创建一个栈*/
# include<stdio.h>
# include<string.h>
# include<stdlib.h>

# define SIZE 32

typedef struct Stack{
    int sta_arr[SIZE];
    int top;
}STACK;

void init_stack(STACK *);

void init_stack(STACK * pS)
{
    memset(pS->sta_arr, 0, sizeof(pS->sta_arr));
    pS->top = -1;
}

int is_full(STACK * pS)
{
    return ((pS->top == SIZE-1) ? 0 : 1);
}
int is_empty(STACK * pS)
{
    return ((pS->top == -1) ? 0 : 1);
}

void input_stack(STACK * pS, int value)
{
    if(is_full(pS)){
        pS->top++;
        pS->sta_arr[pS->top] = value;
    }
}
void output_stack(STACK * pS)
{
    if(is_empty(pS))
        printf("%d",(pS->sta_arr)[pS->top]);
}

void invert(STACK * pS, int value, int type)
{
    int tmp,num = value;
    init_stack(pS);
    while(num)
    {
        /*进制转化：取余之后压栈，再取整，低位就在栈底，自然最后输出*/
        tmp = num % type;   
        input_stack(pS,tmp);    
        num = num / type;
    }
    /*出栈*/
    while(pS->top != -1)
    {
        output_stack(pS);
        pS->top--;
    }
    printf("\n");

}
int main (void)
{
    STACK S;
    int value, type;
    init_stack(&S);
    printf("请输入你要转换的十进制数字：\n");
    scanf("%d",&value);
    printf("请选择你要转换成的进制格式（2~9,如：2代表二进制）：\n");
    scanf("%d",&type);
    if(type > 9 || type < 2){
        printf("选择的进制格式暂时无法处理！\n");
        exit(EXIT_FAILURE);
    }
    invert(&S,value,type);
    return 0;
}

测试：

这里写图片描述

Apollon_krj
关注
  • 1
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-顺序栈实现十进制转换为二进制-八进制-十六进制
12-28
C语言-顺序栈实现十进制转换为二进制-八进制-十六进制
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
括号配对
期待
11-10 404
#include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define BUFFERSIZE 1010 typedef int Status; //函数返回状态
C语言实现任意栈之间的进制转换
qq_42680327的博客
03-22 1872
利用栈，将十进制数组N转换为D进制（D=2,8,16），其中16进制对应的符号是0~9，A~F。要求：十进制数字和N进制从键盘输入获得，从屏幕显示进制转换后的数字。
数据结构之顺序栈实现进制转换
xuelanga000的博客
08-30 24
栈的应用 进制转换 1.需要用到前面博文顺序栈基本操作 示例： #include <iostream> #include <stdio.h> using namespace std; #define STACK_INT_SIZE 10 //存储空间初始分配量 #define STACK_INTCREMENT 2 //存储空间分配增量 #define N 16 ...
数据结构C语言版：栈和队列之栈
l5j12138的博客
01-28 295
本文基于严微敏数据结构C语言版的笔记，附带栈基本操作
利用栈和递归实现进制转换——数据结构实验报告
热门推荐
qq_40878980的博客
11-12 1万+
一、实验名称：栈的应用——进制转换 二、实验目的 熟练掌握栈的两种存储方式的具体实现过程，并分别使用递归和非递归两种方式，实现进制转换。 三、实验要求 顺序栈和链栈两种存储方式任选一种，实现从十进制到八进制的转换。 用递归的方法实现上述功能。 改进算法，实现从十进制到N进制的转化（0&lt;N&lt;10，由用户输入确定。） 四、实验环境 (1) 硬件环境：微机一台； (2) 软件...
数据结构——利用栈来实现进制转换
m0_73417372的博客
04-23 3149
【代码】数据结构——利用栈来实现进制转换。
C语言顺序栈的实现以及进制转换
m0_51415606的博客
10-31 7767
栈是 仅限定在表尾插入或输出的一种链表形式，它不能像链表一样随便输出、随便插入，是一种“先进后出”的形式，可以理解为逆序输出。 1.写顺序栈，我们需要先在头文件部分定义一个存储空间初始分配量和一个存储空间分配增量 #include<stdio.h> #include<stdlib.h> #define MAX 100//第一次分配内存空间时分配100 #define ADD 10//当我们输入的数据大于初始空间时就增加内存空间，每次增加10 2.然后是定义结构体变量，定义三个，栈
数据结构c语言-顺序栈（实现进制转换）
zerlina_May的博客
10-09 8158
数据结构c语言-顺序栈（实现进制转换） 文章目录数据结构c语言-顺序栈（实现进制转换）前言一、顺序栈数据结构定义二、创建空的顺序栈三、判断栈是否为空四、判断栈满五、入栈六、弹栈七、取栈顶八、销毁顺序栈九、实现数值转换 前言 一个菜鸡写出来的顺序栈，写篇文章记录一下 最后是顺序栈实现任意进制转换的代码 提示：以下是本篇文章正文内容，下面案例可供参考 一、顺序栈数据结构定义 typedef int DataType; struct seqStack {//有3个数据成员 int MAXNUM;//用于记
数据结构：采用链式栈实现十进制转二进制输出，代码详细
weixin_57535837的博客
08-22 3672
本文章用链式栈实现十进制转二进制后输出，有需要的可以参考下。
数据结构，用C语言实现顺序栈和链式队列的源码
最新发布
04-02
定义顺序栈，完成栈的基本操作：空栈、入栈、出栈、取栈顶元素；...实现十进制数与八进制数的转换，十进制数与十六进制数的转换和任意进制之间的转换； 定义链式队列，完成队列的基本操作：入队和出队；
c++数据结构-实验.zip
07-17
c++数据结构--实验 线性表的基本操作 1.实验内容与要求 1）理解线性表的概念 2）设计一个线性表，分别用顺序存储结构和链式存储结构实现，完成线性表的构造、查找、插入、删除、输出等基本操作。 3）掌握两种存储...
C语言实现常用的数据结构.rar
04-22
C代码实现，适合初学者。BF算法、KMP算法、矩阵图、链表、链式存储队列、求素数算法、树、顺序存储队列、顺序存储结构、线性表、循环队列、约瑟夫环、栈、栈进行进制转换等
精心整理史上最全的数据结构flash演示动画，共5个版本，祝大家考研成功！
03-10
\数据结构flash演示\版本1\3-2-1栈的应用举例-进制转换.swf \数据结构flash演示\版本1\3-3-10链队列.swf \数据结构flash演示\版本1\3-3-11链队列-入队.swf \数据结构flash演示\版本1\3-3-12-1链队列出队.swf \...
算法实例：枚举的魅力
Apollon_krj的博客
04-21 6483
两道“奥数题”说说枚举法： ①如何找到一个整数ABCDE（A、B、C、D、E分别为万位、千位、百位、十位、个位，A不为0）乘以A，得到结果为EEEEE。 ②A？B？C？D？E = F（A、B、C、D、E、F均为整数），在ABCDE之间填入四个运算符（+、-、*、/四种中随意组合），使得等式成立，求出所有组合。 枚举法本质：从所有的候选答案中去搜索正确的解必须满足条件： ①可以预先确定
AVL树的插入与旋转算法解析
Apollon_krj的博客
04-05 5136
1、AVL树的基本概念：AVL树又称为平衡二叉排序（搜索）树，AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 “An algorithm for the organization of information” 中发表了它。分解开来看：AVL树是一棵二叉树进一步是一棵二叉排序树、并且AVL树涉及平衡因子这个概念。节点的平衡因子
随机数生成器与线性同余法产生随机数
Apollon_krj的博客
12-05 4973
1、随机数生成器与/dev/random：随机数生成器，顾名思义就是能随机产生数字，不能根据已经产生的数预测下次所产生的数的“器”（器存在软件与硬件之分），真正的随机数生成器其产生的随机数具有随机性、不可预测性、不可重现性。什么是真正的随机数生成器？指的是由传感器采集设备外部温度、噪声等不可预测的自然量产生的随机数。比如Linux的/dev/random设备文件其根据设备中断（键盘中断、鼠标中断等）
黑白棋算法简单实现与基于Qt的GUI编程的综合应用
Apollon_krj的博客
06-28 4435
一、序言：最近学习了Qt的界面编程，包括了QObject、QWidget、QIODevice、QMessageBox、QTcpSockt、QTcpServer、QFile、QFileInfo、QDataStream、QTextStream、QBuff、QPixmap、QImage、QBitmap、QPicture、QTimer定时器…等基本类的使用；基本事件的处理与过滤的学习、信号与槽的学习、QCr
数据结构顺序栈与链式栈基本操作
12-30
顺序栈和链式栈是两种常见的栈的实现方式。顺序栈是用一组地址连续的存储单元依次存储栈中的元素，每个元素占用一个存储单元。链式栈是用一组节点指针来存储栈中的元素，每个节点中包含数据和指向下一个节点的指针。顺序栈和链式栈都有入栈、出栈、查看栈顶元素等基本操作。其中，顺序栈的插入和删除操作方便高效，但存储空间受限；链式栈则可以动态扩容，但插入和删除操作需要移动节点指针。 顺序栈的基本操作包括：初始化、判空、入栈、出栈、存取栈顶元素、清空栈等。 链式栈的基本操作包括：初始化、判空、入栈、出栈、存取栈顶元素、清空栈等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值