数据结构之栈的实现

最新推荐文章于 2022-09-05 21:58:33 发布
最新推荐文章于 2022-09-05 21:58:33 发布
阅读量306 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 栈 双端链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_33736971/article/details/51011278
版权

利用双端链表实现栈的基本操作

栈的结构体及接口定义：

#ifndef STACK_H_
#define STACK_H_

#include "dlist.h"
#include "tools.h"

typedef struct Stack{
    Dlist *dlist;
}Stack;

Stack *init_stack(void);    //栈的初始化
void  destroy_stack(Stack **stack);   //栈的销毁
Boolean push_stack(Stack *stack, void *value);  //入栈
Boolean pop_stack(Stack *stack);  //出栈
Boolean is_empty(Stack *stack);   //判空
int get_stack_count(Stack *stack);  //得到栈的元素个数
Boolean get_stack_top(Stack *stack, void **value);  //得到栈顶元素


#endif

栈的接口实现：

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "stack.h"
#include "tools.h"
#include "dlist.h"

Stack *init_stack(void)    //栈的初始化
{
     Stack *stack = NULL;
     stack = (Stack *)Malloc(sizeof(Stack));
     stack->dlist = init_dlist();
#if 0
     //不需要，程序退出时，stack会自动释放
     if(stack->dlist == NULL){
         free(stack);
         fprintf(stderr, "the memory is full!\n");
         exit(1);
     }
     bzero(stack->dlist, sizeof(Stack));
#endif
     return stack;
}

void  destroy_stack(Stack **stack)   //栈的销毁
{
    if(stack == NULL || *stack == NULL){
        return ;
    }
    destroy_dlist(&((*stack)->dlist));
    free(*stack);
    *stack = NULL;
}

Boolean push_stack(Stack *stack, void *value)  //入栈
{
    if(stack == NULL || value == NULL){
        return FALSE;
    }
    push_front(stack->dlist, value);
}

Boolean pop_stack(Stack *stack)  //出栈
{
    if(stack == NULL || is_empty(stack)){
        return FALSE;
    }
    return pop_front(stack->dlist);
}

Boolean is_empty(Stack *stack)   //判空
{
    return stack->dlist->count == ZERO;
}

int get_stack_count(Stack *stack)  //得到栈的元素个数
{
    if(stack == NULL){
        return -1;
    }
    return get_dlist_count(stack->dlist);
}

Boolean get_stack_top(Stack *stack, void **value)  //得到栈顶元素
{
    if(stack == NULL || value == NULL){
        return FALSE;
    }
    if(value != NULL){
        return get_front(stack->dlist, value);
    }
    return FALSE;
}

实现栈所需的包裹函数和双端链表的接口及其实现：

包裹函数：

#ifndef _TOOLS_H_
#define _TOOLS_H_

//定义布尔类型
#define TRUE  (1)
#define FALSE (0)

typedef unsigned char Boolean;

//定义接口
void *Malloc(size_t size);

#endif

#include <stdio.h>
#include <stdlib.h>
#include "tools.h"

void *Malloc(size_t size)
{
    void *result = malloc(size);
    if(result == NULL){
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    }

    return result;
}

栈所需的双端链表的接口及其实现：

#ifndef _DLIST_H_
#define _DLIST_H_
#include "tools.h"

#define ZERO   (0)
#define ONE    (1)

typedef void (*Print_func)(void *value);   //回调函数

//链表节点类型
typedef struct Dlist_node{
    struct Dlist_node *prev;  //前驱
    struct Dlist_node *next;  //后继
    void              *data;  //可以接收任意类型的指针（达到通用的效果）
}Dlist_node;

//链表控制信息
typedef struct Dlist{
    struct Dlist_node *head; //头结点
    struct Dlist_node *tail; //尾节点
    int               count; //数量

    //data所指向内容的释放策略
    void (*free)(void *ptr); //释放任意指针的空间（函数指针）
    //data所指向内容的相等策略
    Boolean (*match)(void *value1, void *value2);
    //data所指向内容的拷贝策略
    void *(*copy_node)(void *value);
}Dlist;

//通用链表的接口定义
Dlist   *init_dlist(void)                                       ;  //双端链表初始化
void    destroy_dlist(Dlist **dlist)                            ;  //双端链表的销毁
Boolean push_front(Dlist *dlist, void *value)                   ;  //头部插入
Boolean push_back(Dlist *dlist, void *value)                    ;  //尾部插入
Boolean pop_front(Dlist *dlist)                                 ;  //头部删除
Boolean pop_back(Dlist *dlist)                                  ;  //头部删除

Dlist_node *find_node(Dlist *dlist, void *value)                ;
Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value);  //插入到指定节点前边
Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value);  //插入到指定节点后边
Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node)       ;  //删除指定节点
void    print_dlist(Dlist *dlist, Print_func print)             ;  //链表的打印
Boolean get_front(Dlist *dlist, void **value)                   ;  //得到头结点的data
//Boolean get_front(Dlist *dlist, void *value)                  ;  //得到头结点的data
Boolean get_tail(Dlist *dlist, void **value)                     ;  //得到尾节点的data
int     get_dlist_count(Dlist *dlist)                           ;   //得到链表的数量


#endif

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "dlist.h"

static Dlist_node *create_node(void);   //生成链表节点
static Dlist_node *create_node(void)
{
    Dlist_node *result = NULL;

    result = (Dlist_node *)Malloc(sizeof(Dlist_node));
    bzero(result, sizeof(Dlist_node));

    return result;
}

Dlist   *init_dlist(void)                                         //双端链表初始化
{
    Dlist *dlist = NULL;

    dlist = (Dlist *)Malloc(sizeof(Dlist));
    bzero(dlist, sizeof(Dlist));

    return dlist;
}


void    destroy_dlist(Dlist **dlist)                              //双端链表的销毁
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || *dlist == NULL){
        return ;
    }

#if 0
    p_node = (*dlist)->head;

    while((*dlist)->head != NULL){
        (*dlist)->head = p_node->next;
        if((*dlist)->free != NULL){
            (*dlist)->free(p_node->data);
        }
        free(p_node);
        p_node = (*dlist)->head;
    }
#endif

    while((*dlist)->count){
        pop_front(*dlist);
    }
    free(*dlist);
    *dlist = NULL;
}


Boolean push_front(Dlist *dlist, void *value)                     //头部插入
{
    //*value记录数据的地址
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        return FALSE;
    }

    //生成链表节点
    p_node = create_node();
    p_node->data = value;

    if(dlist->count == ZERO){     //插入前无元素
        dlist->head = dlist->tail = p_node;
    }else{      //插入前有元素
        p_node->next = dlist->head;
        dlist->head->prev = p_node;
        dlist->head = p_node;
    }

    dlist->count++;
    return TRUE;
}

Boolean push_back(Dlist *dlist, void *value)                      //尾部插入
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        p_node->prev = dlist->tail;
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    if(dlist->count == ZERO){     //插入前无元素
        dlist->head = dlist->tail = p_node;
    }else{    //插入前有元素
        dlist->tail->next = p_node;
        p_node->prev = dlist->tail;
        dlist->tail = p_node;
    }

    dlist->count++;
    return TRUE;
}

Boolean pop_front(Dlist *dlist)                                   //头部删除
{
    Dlist_node *p_node = NULL; 

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->head;

    if(dlist->count == ONE){
        dlist->head = dlist->tail = NULL;
    }else{
        dlist->head = p_node->next;
        dlist->head->prev = NULL;
    }

    //释放节点，要对free指针作判断（data指向为堆还是栈）
    if(dlist->free != NULL){   //堆上（才可用free函数）
        dlist->free(p_node->data);
    }

    free(p_node);   //栈上
    dlist->count--;
    return TRUE;
}

Boolean pop_back(Dlist *dlist)                                    //头部删除
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || dlist->count == ZERO){
        return FALSE;
    }

    p_node = dlist->tail;

    if(dlist->count == ONE){   //只有一个元素
        dlist->head = dlist->tail = NULL;
    }else{    //多个元素
        dlist->tail = p_node->prev;
        dlist->tail->next = NULL;
    }

    if(dlist->free != NULL){
        dlist->free(p_node->data);
    }

    free(p_node);
    dlist->count--;

    return TRUE;
}

Dlist_node *find_node(Dlist *dlist, void *value)
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || value == NULL){
        return NULL;
    }

#if 0
    for(p_node = dlist->head; p_node; p_node = p_node->next){
        if(dlist->match){     //用户指定相等条件
            if(!dlist->match(p_node->data, value)){
                return p_node;
            }
        }else{
            if(p_node->data == value){
                return p_node;
            }
        }
    }
#endif

    if(dlist->match){
        for(p_node = dlist->head; p_node; p_node = p_node->next){
            if(!dlist->match(p_node->data, value)){
                return p_node;
            }
        }
    }else{ 
        for(p_node = dlist->head; p_node; p_node = p_node->next){
            if(p_node->data == value){
                return p_node;
            }
        }
    }

    return p_node;
}

Boolean insert_prev(Dlist *dlist, Dlist_node *node, void *value)  //插入到指定节点前边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value == NULL){
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    p_node->next = node;
    p_node->prev = node->prev;

    if(node->prev == NULL){
        dlist->head = p_node;
    }else{
        node->prev->next = p_node;
    }

    node->prev = p_node;
    dlist->count++;

    return TRUE;
}

Boolean insert_next(Dlist *dlist, Dlist_node *node, void *value)  //插入到指定节点后边
{
    Dlist_node *p_node = NULL;

    if(dlist == NULL || node == NULL || value == NULL){
        return FALSE;
    }

    p_node = create_node();
    p_node->data = value;

    p_node->prev = node;
    p_node->next = node->next;

    if(node->next == NULL){
        dlist->tail = p_node;
    }else{
        node->next->prev = p_node;
    }

    node->next = p_node;
    dlist->count++;

    return TRUE;
}

Boolean remove_dlist_node(Dlist *dlist, Dlist_node *node)         //删除指定节点
{   //被删除节点的位置1.头删2.尾删3.中间删
    if(dlist == NULL || node == NULL ){
        return FALSE;
    }

    if(node->next == NULL){   //尾删
        pop_back(dlist);
    }else if(node->prev == NULL){  //头删
        pop_front(dlist);
    }else{   //中间删
        node->prev->next = node->next;
        node->next->prev = node->prev;

        if(dlist->free != NULL){
            dlist->free(node->data);
        }
        free(node);
        dlist->count--;
    }

    return TRUE;
}

void    print_dlist(Dlist *dlist, Print_func print)               //链表的打印
{
    Dlist_node *p_node = NULL;   

    if(dlist == NULL || print == NULL || dlist->count == ZERO){
        return ;
    }

    p_node = dlist->head;

    while(p_node){
        print(p_node->data);    //print由使用者选择是哪种类型
        p_node = p_node->next;
    }

    printf("\n");
}

Boolean get_front(Dlist *dlist, void **value)                     //得到头结点的data
{
    if(dlist == NULL || value == NULL || dlist->count == ZERO){
        return FALSE;
    }

    *value = dlist->head->data;

    return TRUE;
}

Boolean get_tail(Dlist *dlist, void **value)                       //得到尾节点的data
{
     if(dlist == NULL || dlist->count == ZERO || value == NULL){
         return FALSE;
     }

     *value = dlist->tail->data;

     return TRUE;
}

int     get_dlist_count(Dlist *dlist)                             //得到链表的数量
{
    if(dlist == NULL){
        return -1;
    }

    return dlist->count;
}

栈的测试代码：

#include <stdio.h>
#include "stack.h"
#include "dlist.h"
#include "tools.h"

int main(int argc, char **argv)
{
    Stack *stack = NULL;
    int array[] = {12, 23, 34, 4, 1, 33, 24};
    int arr_len = sizeof(array) / sizeof(array[0]);
    int i  = 0;   
    int *value = NULL;

    stack = init_stack();   //双端链表的初始化
    //初始化完成后，如果有需要，应修改free、match和dup的指向

    for(i = 0; i < arr_len; ++i){
        push_stack(stack, &array[i]);               //尾部插入数组元素       
    }

    for(i = 0; i < arr_len; ++i){
        get_stack_top(stack, (void **)&value);
        pop_stack(stack);
        printf("%d ", *value);
    }
    printf("\n");

    destroy_stack(&stack);    //双端链表的销毁
    return 0;
}

栈的测试结果：

[root@localhost stack_dlist]# ls
dlist.c  dlist.h  main.c  stack  stack.c  stack.h  tools.c  tools.h
[root@localhost stack_dlist]# ./stack 
24 33 1 4 34 23 12 
[root@localhost stack_dlist]#
lm_123_456
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之——栈
WenJieya的博客
03-27 6876
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
java数据结构之java实现栈
09-04
主要介绍了java数据结构实现栈,需要的朋友可以参考下
数据结构——栈的详解
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
数据结构之栈
jiaomubai的博客
01-30 2295
什么是栈 栈是一种常用的数据结构，其数据存储使用的是逻辑结构。逻辑结构是一个比较抽象的概念，它依赖于物理结构而存在。逻辑结构又分为线性结构和非线性结构。比如顺序表表、栈和队列等就是典型的线性结构，而树和图等就是非线性结构。 栈（Stack）是一种线性数据结构，它就像一个单通道的容器，其中的元素只能先进后出（First In Last Out，简称 FILO）。由于其是单通道的，所以决定了最早进入容器的元素只能最晚出。最早进入的元素存放的位置叫做栈底，最后进入的元素存放的位置叫做栈顶。像栈这种线性结构既可
线性数据结构之栈(Stack)
刘跃辉的博客
09-05 9万+
栈是一种用于存储数据的简单数据结构(与链表类似) , 栈的关键就是入栈的次序 , 比如我们在交作业的时候 , 最先交的永远都在最后面 , 而老师检查的时候是从最上面开始拿 , 所以第一个交的作业老师最后一个看完栈是一个有序的线性表 , 只能在表的一端(称为栈顶 , top)执行插入和删除操作 , 最后插入的元素将被第一个删除 , 所以栈也被称为后进先出(Last In First Out : LIFO)或者是先进后出(First In Last Out : FILO)线性表。
数据结构之栈结构
weixin_45641191的博客
03-08 1473
认识栈结构 栈是一种非常常见的数据结构，并且在程序中的应用非常广泛. 数组 我们知道数组是一种线性结构，并且可以在数组的任意位置插入和删除数据. 但是有时候，我们为了实现某些功能，必须对这种任意性加以限制. = 而栈和队列就是比较常见的受限的线性结构，我们先来学习栈结构. 栈结构示意图 栈( stack)，它是一种受限的线性表后进先出(LIFO) 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 LIFO(last in first out)表示就是后进入
C++数据结构——栈
GeekZW的博客
06-25 16万+
C++数据结构——栈 最近计划再复习一遍数据结构，看到一篇博客：https://www.cnblogs.com/QG-whz/p/5170418.html#_label0。 1、栈(Stack)是一种线性存储结构，它具有如下特点： ...
数据结构之栈实验
// 在校菜鸟大学生的日常学习博客
09-01 1810
栈实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握栈这种数据结构特性及其主要存储结构，并能在现实生活中灵活运用。 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.掌握栈的顺序存储结构—顺序栈的定义、构造、获得栈顶元素、入栈、出栈等基本操作； 实验内容 完成栈的定义、构造、获得栈顶元素、进栈、出栈等函数的编写。要求在主函数中实现对以上操作的调用，编写一个算法判断给定的字符向量是否为回文。回文是指正读与反读均相同的字符序列，如“abba”和“abdba”均是回文，但“
Java数据结构-栈的实现
算法萌新一枚
03-19 1476
一步到位,把栈实现了
数据结构：栈实现简易计算器
又蠢又笨的懒羊羊程序猿的博客
08-07 6531
文章目录栈实现简易计算器思路代码实现栈结构运算方法测试 栈实现简易计算器 之前的博客已经介绍了栈数据结构，栈有着数据先进后出的特点，因此用于实现简易计算器时相当方便。本博文中将介绍如何用栈实现一个可以进行简单四则运算不含括号的简易计算器（中缀表达式） 思路 首先创建两个栈，一个用于存储数而另一个用于存储运算符号。 首先需要一个index索引来遍历表达式 遍历到数字时直接入数栈 遍历到运算符时需要分情况讨论 如果当前符号栈为空直接入栈 如果当前符号栈不为空需要分情况讨论 当前遍历到的运算符的运算优先级小
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C++实现数据结构-栈
最新发布
11-10
C++实现数据结构-栈
Java数据结构之栈的基本定义与实现方法示例
08-29
主要介绍了Java数据结构之栈的基本定义与实现方法,简单描述了数据结构中栈的功能、原理,并结合java实例形式分析了栈的基本定义与使用方法,需要的朋友可以参考下
C语言 数据结构中栈的实现代码
09-01
主要介绍了C语言 数据结构中栈的实现代码的相关资料,需要的朋友可以参考下
数据结构-栈的C语言实现
01-20
数据结构-栈的C语言实现，随手笔记
数据结构之栈的实现.rar
07-29
数据结构之栈的实现，借鉴数据结构严蔚敏版，略有修改。基于VS2010实现，可直接运行
数据结构之栈的定义及实现
09-29
数据结构之栈的定义及实现。
简单计算器C语言数据结构栈实现
10-31
C语言数据结构栈的较高级应用
C++数据结构之栈模版实现
09-28
栈中的元素遵守“先进后出”的原则(LIFO,Last In First Out) 　只能在栈顶进行插入和删除操作 　压栈（或推入、进栈）即push，将数据放入栈顶并将栈顶指针加一 　出栈（或弹出）即pop，将数据从栈顶删除并将栈顶...
数据结构用栈实现回文
09-24
用栈实现回文的方法是将字符串的一半字符入栈，然后逐个出栈与原来顺序的字符进行比较。如果出现不相同的字符，则不是回文；如果全部字符比较完毕都相同，则是回文。 以下是实现回文的算法代码： ``` int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值