栈练习之Example003-用不带头结点的单链表存储链栈并实现栈相关算法

最新推荐文章于 2023-04-03 16:19:16 发布
最新推荐文章于 2023-04-03 16:19:16 发布
阅读量1.5k 收藏 16
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 栈 链栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/124357883
版权

Example003

题目

用不带头结点的单链表存储链栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应的算法。

分析

不带头结点的单链表 list 为空的条件是 list==NULL，进栈和出栈操作都是在表头进行的。

在入栈的时候，由于没有头结点，所以空栈和非空栈的入栈操作需要分情况处理。

图解

不带头结点的空栈和非空栈如图所示：

在这里插入图片描述

入栈，如果是空栈则如下图所示：

在这里插入图片描述

入栈，如果是非空栈则如下图所示：

在这里插入图片描述

出栈，操作如图所示：

在这里插入图片描述

C实现

完整代码：

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

/**
 * 栈结点结构体定义
 */
typedef struct LNode {
    /**
     * 结点数据域
     */
    int data;
    /**
     * 结点指针域，指向后继结点
     */
    struct LNode *next;
} LNode;

/**
 * 初始化不带头结点的链栈
 * @param stack 未初始化的链栈
 */
void init(LNode **stack) {
    // 即置为 NULL，没有头结点
    *stack = NULL;
}

/**
 * 判断链栈是否为空
 * @param stack 不带头结点的链栈
 * @return 如果链栈为空则返回 1，否则返回 0 表示非空
 */
int isEmpty(LNode *stack) {
    if (stack == NULL) {
        return 1;
    } else {
        return 0;
    }
}

/**
 * 将元素入栈。注意，链栈不需要校验栈是否满的问题
 * @param stack 不带头结点的链栈
 * @param ele 元素值
 */
void push(LNode **stack, int ele) {
    // 1.创建新结点并为其指定数据域和初始化指针域
    LNode *newNode = (LNode *) malloc(sizeof(LNode));
    newNode->data = ele;
    newNode->next = NULL;

    // 2.但需要判断栈是否为空的问题，如果栈为空，则新结点是链栈的第一个结点；如果栈非空，则新结点成为链栈新的栈顶结点
    if (stack == NULL) {
        // 新结点直接称为栈顶结点
        *stack = newNode;
    } else {
        // 将新结点入栈
        newNode->next = *stack;
        *stack = newNode;
    }
}

/**
 * 将元素出栈
 * @param stack 不带头结点的链栈
 * @param ele 用来存储出栈元素的值
 * @return 如果栈空则返回 0 表示出栈失败，否则返回 1 表示出栈成功
 */
int pop(LNode **stack, int *ele) {
    // 1.需要校验是否是空栈
    if (*stack == NULL) {
        return 0;
    }
    // 2.将元素出栈
    LNode *node = *stack;
    // 2.1 用 ele 保存出栈元素的数据值
    *ele = node->data;
    // 2.2 删除栈顶结点
    *stack = node->next;
    // 2.3 释放结点空间
    free(node);
    // 2.4 返回 1 表示出栈成功
    return 1;
}

/**
 * 获取栈顶元素，但不出栈
 * @param stack 不带头结点的链栈
 * @param ele 用来存储出栈元素的值
 * @return 如果栈空则返回 0 表示出栈失败，否则返回 1 表示出栈成功
 */
int getTop(LNode *stack, int *ele) {
    // 1.如果栈空则返回 0 表示获取失败
    if (stack == NULL) {
        return 0;
    }
    // 2.用 ele 保存栈顶元素值
    *ele = stack->data;
    return 1;
}

/**
 * 获取链栈中结点个数
 * @param stack 不带头结点的链栈
 * @return 结点个数
 */
int size(LNode *stack) {
    // 变量，记录链栈结点个数
    int len = 0;
    // 从栈顶到栈底扫描链栈所有结点，统计个数
    while (stack != NULL) {
        len++;
        stack = stack->next;
    }
    return len;
}

/**
 * 打印链栈所有结点
 * @param stack 不带头结点的链栈
 */
void print(LNode *stack) {
    printf("[");
    while (stack != NULL) {
        printf("%d", stack->data);
        if (stack->next != NULL) {
            printf(", ");
        }
        stack = stack->next;
    }
    printf("]\n");
}

/**
 * 清空链栈
 * @param stack 不带头结点的链栈
 */
void clear(LNode **stack) {
    // 释放链栈中每一个结点的空间
    while (*stack != NULL) {
        LNode *node = (*stack)->next;
        free(*stack);
        *stack = node;
    }
    *stack = NULL;
}

/**
 * 销毁链栈
 * @param stack 不带头结点的链栈
 */
void destroy(LNode **stack) {
    free(*stack);
}

int main() {
    // 声明链栈
    LNode *stack;

    // 初始化链栈
    printf("初始化链栈：\n");
    init(&stack);
    print(stack);

    // 将元素入栈
    printf("将元素入栈：\n");
    push(&stack, 11);
    print(stack);
    push(&stack, 22);
    print(stack);
    push(&stack, 33);
    print(stack);
    push(&stack, 44);
    print(stack);
    push(&stack, 55);
    print(stack);

    // 将元素出栈
    printf("将元素出栈：\n");
    int ele;
    pop(&stack, &ele);
    print(stack);
    pop(&stack, &ele);
    print(stack);
    pop(&stack, &ele);
    print(stack);

    // 链栈是否为空
    printf("链栈是否为空：\n");
    int empty;
    empty = isEmpty(stack);
    printf("%d\n", empty);

    // 获取栈顶结点数据
    printf("获取栈顶结点数据：\n");
    int top;
    getTop(stack, &top);
    printf("%d\n", top);

    // 获取链栈中元素个数
    printf("获取链栈中元素个数：\n");
    int len;
    len = size(stack);
    printf("%d\n", len);

    // 清空链栈
    printf("清空链栈：\n");
    clear(&stack);
    print(stack);

    // 销毁链栈
    printf("销毁链栈：\n");
    destroy(&stack);
}

执行结果：

初始化链栈：
[]
将元素入栈：
[11]
[22, 11]
[33, 22, 11]
[44, 33, 22, 11]
[55, 44, 33, 22, 11]
将元素出栈：
[44, 33, 22, 11]
[33, 22, 11]
[22, 11]
链栈是否为空：
0
获取栈顶结点数据：
22
获取链栈中元素个数：
2
清空链栈：
[]
销毁链栈：

Java实现

完整代码：

public class LinkedStack {
    /**
     * 声明不带头结点的链栈
     */
    private LNode stack;

    /**
     * 初始化没有头结点的链栈
     */
    public void init() {
        // 即指向 null 表示空栈
        stack = null;
    }

    /**
     * 判断链栈是否为空
     *
     * @return 如果链栈为空则返回 true，否则返回 false 表示非空
     */
    public boolean isEmpty() {
        // 即判断头指针是否指向 null
        return stack == null;
    }

    /**
     * 将元素入栈
     *
     * @param ele 待入栈的元素值
     */
    public void push(int ele) {
        // 1.如果是空栈，则将新结点置为链栈的栈顶结点
        if (stack == null) {
            // 直接是栈顶结点
            stack = new LNode();
            stack.data = ele;
            stack.next = null;
        }
        // 2.如果是非空栈，则创建新结点并且将新结点与原链栈连接起来
        else {
            // 2.1 创建新结点并为其分配数据域和指针域
            LNode newNode = new LNode();
            newNode.data = ele;
            newNode.next = null;
            // 2.2 将新结点与原链栈连接起来，成为新的链栈栈顶结点
            newNode.next = stack;
            stack = newNode;
        }
    }

    /**
     * 将栈顶元素出栈
     *
     * @return 栈顶元素值
     * @throws Exception 如果栈空则抛出此异常
     */
    public int pop() throws Exception {
        // 0.参数校验，如果栈空则抛出异常
        if (stack == null) {
            throw new Exception("栈空，没有元素可出栈！");
        }
        // 1.出栈栈顶元素
        // 1.1 记录栈顶结点的值然后返回
        int top = stack.data;
        // 1.2 删除栈顶结点，让原栈顶结点的后继结点成为新的栈顶结点
        stack = stack.next;
        return top;
    }

    /**
     * 获取栈顶结点的值
     *
     * @return 栈顶结点的数据值
     * @throws Exception 如果栈空则抛出此异常
     */
    public int getTop() throws Exception {
        // 0.参数校验，如果栈空则抛出异常
        if (stack == null) {
            throw new Exception("栈空，没有元素可出栈！");
        }
        // 1.直接返回栈顶结点的数据值
        return stack.data;
    }

    /**
     * 获取链栈中的结点个数
     *
     * @return 链栈的结点个数
     */
    public int size() {
        // 变量，记录链栈结点个数
        int len = 0;
        // 变量，记录链栈，为了不修改链栈本身
        LNode node = stack;
        while (node != null) {
            len++;
            node = node.next;
        }
        return len;
    }

    /**
     * 打印链栈所有结点
     */
    public void print() {
        LNode node = stack;
        System.out.print("[");
        while (node != null) {
            System.out.print(node.data);
            if (node.next != null) {
                System.out.print(", ");
            }
            node = node.next;
        }
        System.out.print("]\n");
    }

    /**
     * 清空链栈
     */
    public void clear() {
        while (stack != null) {
            LNode node = stack.next;
            stack.next = null;
            stack = null;
            stack = node;
        }
        stack = null;
    }
}

/**
 * 链栈结点
 */
class LNode {
    /**
     * 结点数据域
     */
    int data;
    /**
     * 结点指针域
     */
    LNode next;
}

测试代码：

public class LinkedStackTest {
    public static void main(String[] args) throws Exception {
        // 声明链栈
        LinkedStack stack = new LinkedStack();

        // 初始化链栈
        System.out.println("\n初始化链栈：");
        stack.init();
        stack.print();

        // 将元素入栈
        System.out.println("\n将元素入栈：");
        stack.push(11);
        stack.print();
        stack.push(22);
        stack.print();
        stack.push(33);
        stack.print();
        stack.push(44);
        stack.print();
        stack.push(55);
        stack.print();

        // 将元素出栈
        System.out.println("\n将元素出栈：");
        int ele;
        ele = stack.pop();
        stack.print();
        ele = stack.pop();
        stack.print();
        ele = stack.pop();
        stack.print();

        // 链栈是否为空
        System.out.println("\n链栈是否为空：");
        boolean empty;
        empty = stack.isEmpty();
        System.out.println(empty);

        // 获取栈顶结点数据
        System.out.println("\n获取栈顶结点数据：");
        int top;
        top = stack.getTop();
        System.out.println(top);

        // 获取链栈中元素个数
        System.out.println("\n获取链栈中元素个数：");
        int len;
        len = stack.size();
        System.out.println(len);

        // 清空链栈
        System.out.println("\n清空链栈：");
        stack.clear();
        stack.print();
    }
}

执行结果：

初始化链栈：
[]

将元素入栈：
[11]
[22, 11]
[33, 22, 11]
[44, 33, 22, 11]
[55, 44, 33, 22, 11]

将元素出栈：
[44, 33, 22, 11]
[33, 22, 11]
[22, 11]

链栈是否为空：
false

获取栈顶结点数据：
22

获取链栈中元素个数：
2

清空链栈：
[]
二木成林
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构——链栈（不带头结点）的初始化、入栈、出栈
Prescu的博客
06-15 4293
//不带头结点的链式栈的相关操作 //注：不带头结点的链栈，其栈顶节点可以用*L表示，L==null时，栈为空，其余情况l就是栈顶节点 #include<stdio.h> #include<stdlib.h> typedef struct Linknode{ int data; struct Linknode *next; }*LiStack; //初始化栈顶节点 void InitStack(Linknode *&L){ L=NULL; } bool IsEmpty(Lin
K-means算法的Matlab实现代码（使用文档+源代码）
09-19
在这个场景中，我们有一个关于K-means算法在Matlab环境下实现的资源，包括使用文档和源代码，这意味着我们可以直接在Matlab环境中运行这些代码，无需过多的编程修改。 在Matlab中实现K-means算法，首先需要理解其...
数据结构（实现不带头结点的链栈）
DMHY123的博客
07-24 1667
数据结构中实现不带头结点的链栈
【数据结构】链栈（不带头节点）
mossfan的博客
04-21 674
#include<stdio.h> #include<stdlib.h> typedef struct SNode{ int data; struct SNode *next; }*LinkStack,SNode; //初始化栈 void InitStack(LinkStack &S){ S=NULL; } //入栈 void Push(LinkStack &S,int x){ SNode *p=(SNode*)malloc(sizeof(SNode)
（不带头结点）链栈初识
qq_51214556的博客
11-10 2078
链栈依旧遵守“后入先出”的原则，链栈指针永远指向栈顶结点，入栈时新结点“指向”栈顶结点，栈顶指针指向新结点，新结点成为新的栈顶结点。 #include <stdio.h> #include <stdlib.h> typedef struct LSNode{ ElemType data; //数据域 struct LSNode *next; //指针域 }LSNode,*LStack; //结点和链栈类型 //初始化 void InitStack_LS(LSta
【链栈】——不带头结点
wangwm_的博客
04-24 619
链栈：栈是后入先出（Last IN First Out，LIFO），其开始指针总是在栈顶的 目录 链栈：栈是后入先出（Last IN First Out，LIFO），其开始指针总是在栈顶的 类型定义 初始化 入栈 出栈 打印栈 main函数 类型定义 #include<bits/stdc++.h> using namespace std; typedef struct Linknode { int datd; struct Linknode* next; }*Lin
TCP-translator-test-example.rar_TCP/IP协议栈_C/C++_
08-11
在IT领域，TCP/IP协议栈是网络通信的基础，它定义了数据在网络中如何传输的一系列标准。本示例“TCP-translator-test-example.rar”聚焦于TCP（传输控制协议）的应用，通过C/C++编程语言来实现。下面我们将深入探讨...
Java定义栈结构，并实现入栈、出栈操作完整示例
08-25
本文主要介绍了Java定义栈结构，并实现入栈、出栈操作，结合完整实例形式分析了java数据结构中栈的定义、以及入栈、出栈、栈是否为空判断、栈大小计算、打印栈元素等相关操作技巧。 一、栈结构定义 在 Java 中，栈...
example-hftish:示例订单簿不平衡算法
05-14
它是基于订单簿不平衡的交易策略之一。 有关更多信息，请参阅或其他在线文章。 该算法每天将在同一证券上进行很多交易，因此运行该算法的任何帐户都将很快遇到PDT规则。 在实际环境中运行此脚本之前，请确保您的...
Example-b8-1.rar_Example-b8-1
09-14
"Example-b8-1.rar_Example-b8-1"这个标题暗示了这是一个与数字逻辑设计相关的示例，可能是基于Altera FPGA的。RAR是一种流行的压缩格式，用于打包和压缩多个文件到一个单一的可下载文件中，便于分享和存储。在这个...
数据结构-不带头节点链栈
qq_48736646的博客
03-08 239
数据结构-不带头节点链栈
用不带头结点的单链表存储链栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应的算法
＃两个西柚
08-03 1374
一、问题描述 用不带头结点的单链表存储链栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应的算法 二、问题分析 不带头结点的单链表lst为空的条件是lst=NULL，进栈和出栈操作都是在表头进行的 三、问题解答 void initStack(LNode *&lst){//初始化栈 lst=NULL; } int isEmptyl(LNode *lst){//判断栈是否为空 if(lst==NULL) return 1; else return 0; } void pushl(LNode *
考研数据结构之栈（2.4）——练习题之用不带头结点的单链表来存储链栈实现操作（C表示）
二木成林
05-22 2633
题目 用不带头结点的单链表存储链栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应算法。 分析 不带头结点的单链表L为空的条件是L==NULL，进栈和出栈操作都是在表头进行的。 入栈 出栈 代码 核心代码： /* 初始化栈 */ /* *&list指的是要初始化的栈 */ void initStack(LNode *&list) { // list要改变，所以要用引用型 list=NULL;// 将开始结点置为NULL } /* 判断是否栈空，如果栈空返回1
双指针不带头结点的链栈的实现（C语言）
仰望星空
09-27 3527
/* 双指针 不带头结点的链栈 VS2010 调试 */ #include #include #include #define TRUE 1 #define FALSE 0 #define ERROR -1 #define OK 1 struct Node { int data; struct Node *next; }; struct LStack { struct Nod
用链式存储来实现栈 不带头节点
Mr_atopos的博客
09-18 696
数据结构学习 用链式存储来实现栈 单链表 不带头结点 C++ #include <iostream> #include<stdlib.h> using namespace std; typedef struct lstack{ int data; struct lstack* next; }lstack, * lstackll; void init(lstackll &s) //初始化 { s=NULL; } vo
【数据结构】【王道】【栈与队列】不带头结点链栈的实现及基本操作（可直接运行）
treesorshining的博客
07-14 1437
总目录 链栈实际上与单链表极为相似，区别主要在于判断条件以及链栈的操作只能在表头进行，即就是将单链表的操作固定在了表头。此处实现的是不带头结点的链栈，与带头结点的主要差别在于带头结点的链栈栈顶指针指向以及条件判断方面。实际上，相比于单链表带头结点对于不带头结点的优势，链栈由于都是在表头进行操作，所以带头结点链表的统一操作的优势便难以表现出来了。综上，带头结点的链栈实现其实与带头结点单链表相差不大，此处便不进行实现了。 2.2 初始化 2.3 判空 2.4 入栈 2.5 出栈 2.6 获取栈顶元素
栈和队列的操作二——栈的链式存储（不带头结点）
m0_72619231的博客
04-03 498
完整代码：来吧，开始还是和之前一样，先看一下链栈的图形长什么样吧。
没有头节点的单链表实现栈
weixin_47511190的博客
08-14 184
#include<iostream> using namespace std; //没有头节点的单链表实现栈 struct LinkNode{ int data; LinkNode *next; }; //初始化栈 void InitStack(LinkNode * &S){ S=NULL; } //判断栈是否为空 void IsEmpty(LinkNode * &S){ if(S==NULL) cout<<"栈为空"<<end
使用C语言实现链栈（带头结点和不带头结点）
Keep_Trying_Go的博客
08-11 4504
使用C语言实现链栈（带头结点）
pyinstaller --name example --onefile example.py 为什么生成的是exe，而不是dll
最新发布
06-06
在使用命令 `pyinstaller --name example --onefile example.py` 时，生成的是一个单独的 .exe 文件，其中包含了所有相关的库和资源文件。 . exe 文件是 Windows 中可执行文件的一种格式，可以在 Windows 操作系统...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值