五种编程语言解释数据结构与算法—链式栈

目录

  • 五种编程语言解释数据结构与算法—链式栈

    • 1、栈的链式存储结构介绍

      • 1.1、逻辑结构示意图
    • 2、栈的应用
      • 2.1、括号匹配问题
      • 2.2、表达式求值问题
    • 3、栈和递归的关系
    • 4、C语言实现链式栈
      • 4.1、LinkStack.h文件的内容
      • 4.2、LinkStack.c文件中的内容
      • 4.3、main.c文件中的内容
      • 4.4、输出结果
    • 5、C++语言来实现链式栈
      • 5.1、LinkStack.h文件中的内容
      • 5.2、LinkStack.cpp文件中的内容
      • 5.3、main.cpp文件中的内容
      • 5.4、输出结果
    • 6、java语言来实现链式栈
      • 6.1、LinkStack.java文件中的内容
      • 6.2、LinkStackImpl.java文件中的内容
      • 6.3、Main.java文件中的内容
      • 6.4、输出结果
    • 7、JavaScript语言来实现链式栈
      • 7.1、LinkStack.js文件中的内容
      • 7.2、LinkStack.html文件中的内容
      • 7.3、输出结果
    • 8、Python语言来实现链式栈
      • 8.1、LinkStack.py文件中的内容
      • 8.2、main.py文件中的内容
      • 8.3、输出结果

五种编程语言解释数据结构与算法—链式栈

1、栈的链式存储结构介绍

1.1、逻辑结构示意图

==栈的链式存储结构与单链表相似，并且所有的操作都在表头进行==

对于链式栈的操作与单链表基本一致，就不再一一叙述了。

2、栈的应用

2.1、括号匹配问题

2.2、表达式求值问题

2.2.1、三缀表达式介绍

2.2.2、中缀表达式转换成前缀表达式

将运算符提前

2.2.3、中缀表达式转换成后缀表达式

将运算符置后

算法思想

3、栈和递归的关系

==因为递归算法有着许多问题，因此如果要将递归算法转化成非递归算法，往往需要借助栈来解决==

4、C语言实现链式栈

4.1、LinkStack.h文件的内容

#ifndef XGP_STUDY_DEMO49_LINKSTACK_H
#define XGP_STUDY_DEMO49_LINKSTACK_H

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

//链式栈的结点
typedef struct LINKNODE {
    struct LINKNODE* next;
}LinkNode;

//链式栈
typedef struct LINKSTACK {
    LinkNode head;
    int size;
}LinkStack;

//1，初始化函数
LinkStack* Init_LinkStack();
//2，入栈
void Push_LinkStack(LinkStack* stack,LinkNode* data);
//3，出栈
LinkNode* Pop_LinkStack(LinkStack* stack);
//4，返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);
//5，返回栈元素的个数
int Size_LinkStack(LinkStack* stack);
//6，清空栈
void Clear_LinkStack(LinkStack* stack);
//7，销毁栈
void FreeSpace_LinkStack(LinkStack* stack);

#endif //XGP_STUDY_DEMO49_LINKSTACK_H

4.2、LinkStack.c文件中的内容

#include "LinkStack.h"

//1，初始化函数
LinkStack* Init_LinkStack() {
    LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
    stack->head.next = NULL;
    stack->size = 0;
    return stack;
}
//2，入栈
void Push_LinkStack(LinkStack* stack,LinkNode* data) {
    if(stack == NULL || data == NULL) return;

    data->next = stack->head.next;
    stack->head.next = data;
    stack->size++;
}
//3，出栈
LinkNode* Pop_LinkStack(LinkStack* stack) {
    if(stack == NULL) return  NULL;
    if(stack->size == 0) return NULL;

    LinkNode* save = stack->head.next;
    stack->head.next = save->next;
    save->next = NULL;

    stack->size--;
    return save;
}
//4，返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack) {
    if(stack == NULL) return  NULL;
    if(stack->size == 0) return NULL;

    return stack->head.next;
}
//5，返回栈元素的个数
int Size_LinkStack(LinkStack* stack) {
    if(stack == NULL) return  -1;
    return stack->size;
}
//6，清空栈
void Clear_LinkStack(LinkStack* stack) {
    if(stack == NULL) return;

    stack->head.next = NULL;
    stack->size = 0;

}
//7，销毁栈
void FreeSpace_LinkStack(LinkStack* stack) {
    if(stack == NULL) return;

    free(stack);
}

4.3、main.c文件中的内容

#include "LinkStack.h"

typedef struct PERSON {
    LinkNode node;
    char name[64];
    int age;
}Person;

int main() {
    LinkStack* stack = Init_LinkStack();

    Person p1,p2,p3,p4,p5;
    strcpy(p1.name,"aaa");
    strcpy(p2.name,"bbb");
    strcpy(p3.name,"ccc");
    strcpy(p4.name,"ddd");
    strcpy(p5.name,"eee");

    p1.age = 18;
    p2.age = 19;
    p3.age = 20;
    p4.age = 21;
    p5.age = 22;

    Push_LinkStack(stack,(LinkNode*)&p1);
    Push_LinkStack(stack,(LinkNode*)&p2);
    Push_LinkStack(stack,(LinkNode*)&p3);
    Push_LinkStack(stack,(LinkNode*)&p4);
    Push_LinkStack(stack,(LinkNode*)&p5);

    while (Size_LinkStack(stack) > 0) {
        //取出栈顶元素
        Person* p = (Person*)Pop_LinkStack(stack);
        printf("Name:%s\tAge:%d\n",p->name,p->age);
    }

    FreeSpace_LinkStack(stack);

    return 0;
}

4.4、输出结果

Name:eee        Age:22
Name:ddd        Age:21
Name:ccc        Age:20
Name:bbb        Age:19
Name:aaa        Age:18

Process finished with exit code 0

5、C++语言来实现链式栈

5.1、LinkStack.h文件中的内容

#ifndef XGP_STUDY_DEMO51_LINKSTACK_H
#define XGP_STUDY_DEMO51_LINKSTACK_H

#include <iostream>
using namespace std;

class LinkNode {
public:
    LinkNode* next;
};

class LinkStack {
public:
    LinkNode head;
    int size;

    //1，初始化函数
    LinkStack* Init_LinkStack();
//2，入栈
    void Push_LinkStack(LinkNode* data);
//3，出栈
    LinkNode* Pop_LinkStack();
//4，返回栈顶元素
    LinkNode* Top_LinkStack();
//5，返回栈元素的个数
    int Size_LinkStack();
//6，清空栈
    void Clear_LinkStack();
//7，销毁栈
    void FreeSpace_LinkStack();
};

#endif //XGP_STUDY_DEMO51_LINKSTACK_H

5.2、LinkStack.cpp文件中的内容

#include "LinkStack.h"

LinkStack *LinkStack::Init_LinkStack() {
    this->head.next = NULL;
    this->size = 0;
    return this;
}

void LinkStack::Push_LinkStack(LinkNode *data) {
    if(this == NULL || data == NULL) return;

    data->next = this->head.next;
    this->head.next = data;
    this->size++;
}

LinkNode *LinkStack::Pop_LinkStack() {
    if(this == NULL) return  NULL;
    if(this->size == 0) return NULL;

    LinkNode* save = this->head.next;
    this->head.next = save->next;
    save->next = NULL;

    this->size--;
    return save;
}

LinkNode *LinkStack::Top_LinkStack() {
    if(this == NULL) return  NULL;
    if(this->size == 0) return NULL;

    return this->head.next;
}

int LinkStack::Size_LinkStack() {
    if(this == NULL) return  -1;
    return this->size;
}

void LinkStack::Clear_LinkStack() {
    if(this == NULL) return;

    this->head.next = NULL;
    this->size = 0;
}

void LinkStack::FreeSpace_LinkStack() {
    if(this == NULL) return;

    delete(this);
}

5.3、main.cpp文件中的内容

#include <ostream>
#include "LinkStack.h"

class Person {
public:
    LinkNode node;
    string name;
    int age;

    Person(const string &name, int age) : name(name), age(age) {}

    friend ostream &operator<<(ostream &os, const Person &person) {
        os << "name: " << person.name << " age: " << person.age;
        return os;
    }
};

int main() {

    LinkStack* stack = new LinkStack();

    Person p1("aaa",18);
    Person p2("bbb",19);
    Person p3("ccc",20);
    Person p4("ddd",21);
    Person p5("eee",22);

    stack->Push_LinkStack((LinkNode*)&p1);
    stack->Push_LinkStack((LinkNode*)&p2);
    stack->Push_LinkStack((LinkNode*)&p3);
    stack->Push_LinkStack((LinkNode*)&p4);
    stack->Push_LinkStack((LinkNode*)&p5);

    while (stack->Size_LinkStack() > 0) {
        //取出栈顶元素
        Person* p = (Person*)stack->Pop_LinkStack();
        cout<<*p<<endl;
    }

    stack->FreeSpace_LinkStack();

    return 0;
}

5.4、输出结果

name: eee age: 22
name: ddd age: 21
name: ccc age: 20
name: bbb age: 19
name: aaa age: 18

Process finished with exit code 0

6、java语言来实现链式栈

6.1、LinkStack.java文件中的内容

package com.xgp.栈的链式存储;

public interface LinkStack {
    //1，初始化函数
    LinkStack Init_LinkStack();
    //2，入栈
    void Push_LinkStack(LinkNode data);
//3，出栈
    LinkNode Pop_LinkStack();
//4，返回栈顶元素
    LinkNode Top_LinkStack();
    //5，返回栈元素的个数
    int Size_LinkStack();
    //6，清空栈
    void Clear_LinkStack();
    //7，销毁栈
    void FreeSpace_LinkStack();
}

6.2、LinkStackImpl.java文件中的内容

package com.xgp.栈的链式存储;

public class LinkStackImpl implements LinkStack {
    public LinkNode head = new LinkNode();
    public int size;

    @Override
    public LinkStack Init_LinkStack() {
        this.head.next = null;
        this.size = 0;
        return this;
    }

    @Override
    public void Push_LinkStack(LinkNode data) {
        if(data == null) return;

        data.next = this.head.next;
        this.head.next = data;
        this.size++;
    }

    @Override
    public LinkNode Pop_LinkStack() {
        if(this.size == 0) return null;

        LinkNode save = this.head.next;
        this.head.next = save.next;
        save.next = null;

        this.size--;
        return save;
    }

    @Override
    public LinkNode Top_LinkStack() {
        if(this.size == 0) return null;

        return this.head.next;
    }

    @Override
    public int Size_LinkStack() {
        return this.size;
    }

    @Override
    public void Clear_LinkStack() {
        this.head.next = null;
        this.size = 0;
    }

    @Override
    public void FreeSpace_LinkStack() {
        Clear_LinkStack();
        this.head = null;
        System.gc();
    }
}

class LinkNode {
    LinkNode next;
}

6.3、Main.java文件中的内容

package com.xgp.栈的链式存储;

public class Main {
    public static void main(String[] args) {
        LinkStack stack = new LinkStackImpl();

        Person p1 = new Person("aaa",18);
        Person p2 = new Person("bbb",19);
        Person p3 = new Person("ccc",20);
        Person p4 = new Person("ddd",21);
        Person p5 = new Person("eee",22);

        stack.Push_LinkStack(p1);
        stack.Push_LinkStack(p2);
        stack.Push_LinkStack(p3);
        stack.Push_LinkStack(p4);
        stack.Push_LinkStack(p5);

        while (stack.Size_LinkStack() > 0) {
            //取出栈顶元素
            Person p = (Person)stack.Pop_LinkStack();
            System.out.println(p);
        }

        stack.FreeSpace_LinkStack();
    }
}

class Person extends LinkNode {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

6.4、输出结果

Person{name='eee', age=22}
Person{name='ddd', age=21}
Person{name='ccc', age=20}
Person{name='bbb', age=19}
Person{name='aaa', age=18}

进程完成，退出码 0

7、JavaScript语言来实现链式栈

7.1、LinkStack.js文件中的内容

class LinkNode {

}

class LinkStack {
    Init_LinkStack() {
        this.head = new LinkNode();
        this.head.next = null;
        this.size = 0;
        return this;
    }

    Push_LinkStack(data) {
        if(this == null || data == null) return;

        data.next = this.head.next;
        this.head.next = data;
        this.size++;
    }

    Pop_LinkStack() {
        if(this == null || this.size == 0) return null;

        var save = this.head.next;
        this.head.next = save.next;
        save.next = null;

        this.size--;
        return save;
    }

    Top_LinkStack() {
        if(this == null || this.size == 0) return null;

        return this.head.next;
    }

    Size_LinkStack() {
        if(this == null) return -1;
        return this.size;
    }

    Clear_LinkStack() {
        if(this == null) return;
        this.head.next = null;
        this.size = 0;
    }

    FreeSpace_LinkStack() {
        if(this == null) return;
        this.Clear_LinkStack();
        this.head = null;
    }
}

7.2、LinkStack.html文件中的内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="LinkStack.js"></script>
</head>
<body>
    <script>
        class Person {
            constructor(name,age) {
                this.name = name;
                this.age = age;
            }

            print() {
                console.log("Name:" + this.name + "\t" + "Age:" + this.age);
            }
        }

        var stack = new LinkStack();
        stack.Init_LinkStack();

        var p1 = new Person("aaa",18);
        var p2 = new Person("bbb",19);
        var p3 = new Person("ccc",20);
        var p4 = new Person("ddd",21);
        var p5 = new Person("eee",22);

        stack.Push_LinkStack(p1);
        stack.Push_LinkStack(p2);
        stack.Push_LinkStack(p3);
        stack.Push_LinkStack(p4);
        stack.Push_LinkStack(p5);

        while (stack.Size_LinkStack() > 0)
            stack.Pop_LinkStack().print();

        stack.FreeSpace_LinkStack();
    </script>
</body>
</html>

7.3、输出结果

Name:eee    Age:22 LinkStack.html:18:25
Name:ddd    Age:21 LinkStack.html:18:25
Name:ccc    Age:20 LinkStack.html:18:25
Name:bbb    Age:19 LinkStack.html:18:25
Name:aaa    Age:18 LinkStack.html:18:25

8、Python语言来实现链式栈

8.1、LinkStack.py文件中的内容

class LinkNode:
    pass

class LinkStack:

    def Init_LinkStack(self):
        self.head = LinkNode()
        self.head.next = None
        self.size = 0
        return self

    def Push_LinkStack(self,data):
        if(self == None or data == None):
            return
        data.next = self.head.next
        self.head.next = data
        self.size += 1

    def Pop_LinkStack(self):
        if(self == None or self.size == 0):
            return None
        save = self.head.next
        self.head.next = save.next
        save.next = None
        self.size -= 1
        return save

    def Top_LinkStack(self):
        if(self == None or self.size == 0):
            return None
        return self.head.next

    def Size_LinkStack(self):
        if(self == None):
            return -1
        return self.size

    def Clear_LinkStack(self):
        if(self == None):
            return
        self.head.next = None
        self.size = 0

    def FreeSpace_LinkStack(self):
        if(self == None):
            return
        self.Clear_LinkStack()
        self.head = None

8.2、main.py文件中的内容

from LinkStack import *

class Person:

    def __init__(self,name,age) -> None:
        self.name = name
        self.age = age

    def __str__(self) -> str:
        return "Name:" + self.name + "\t" + "Age:" + str(self.age)

stack = LinkStack()
stack.Init_LinkStack()

p1 = Person("aaa", 18)
p2 = Person("bbb", 19)
p3 = Person("ccc", 20)
p4 = Person("ddd", 21)
p5 = Person("eee", 22)

stack.Push_LinkStack(p1)
stack.Push_LinkStack(p2)
stack.Push_LinkStack(p3)
stack.Push_LinkStack(p4)
stack.Push_LinkStack(p5)

while(stack.Size_LinkStack() > 0):
    print(stack.Pop_LinkStack())

stack.FreeSpace_LinkStack()

8.3、输出结果

Name:eee    Age:22
Name:ddd    Age:21
Name:ccc    Age:20
Name:bbb    Age:19
Name:aaa    Age:18

Process finished with exit code 0

原文地址：https://www.cnblogs.com/xgp123/p/12427410.html

时间： 2024-10-06 04:44:36

五种编程语言解释数据结构与算法—链式栈的相关文章

1321 扎实的基础：即编程语言、数据结构和算法

编程语言: Q:如果写的函数需要传入一个指针,则是否需要为该指针加上const?把const加在指针不同的位置是否有区别? A:const是用来声明一个常量的,如果不想让一个值改变就应该加上const.首先来看如下的一段代码: int a = 100; const int *b = &a; // 1 int const *b = &a; // 2 int *const b = &a; // 3 const int *const b = &a; // 4 区分常量指针和指针常

redis中的五种基本的数据结构

1 String 基本的数据类型. 2 list 2.1 将元素放入一个list中 rpush mylist A rpush mylist B rpush mylist A 如果mylist本来是不存在的,这样的话,就会创建一个新的list,名字是mylist,它是一个linked list有三个元素A .B.A. 2.2 获取这些元素 lrange mylist 0 -1 其中-1就是从后往前的第一个,即最后一个元素的index. 3 set 3.1 将元素加入一个set sadd myset

Redis5种常用的数据结构

一.数据结构 五种常用的数据结构:string.hash.list.set.zse,以及三种不常用的:hyperloglog.geospatial.streams. 二.常用数据结构的使用 1.String键 字符串键的使用场景:如分布式锁.计数器.分布式全局序列ID 2.Hash键        存在的最主要的意义就是:减少内存的占用,原因在于比如对key的过期时间的扫描,只需要扫描第一层key即可 Redis采用的数据分配方案是预分配16384个hash槽,Hash键可以理解成是通过用第一层

《数据结构与算法之美》 &lt;03&gt;数组：为什么很多编程语言中数组都从0开始编号？

提到数组,我想你肯定不陌生,甚至还会自信地说,它很简单啊. 是的,在每一种编程语言中,基本都会有数组这种数据类型.不过,它不仅仅是一种编程语言中的数据类型,还是一种最基础的数据结构.尽管数组看起来非常基础.简单,但是我估计很多人都并没有理解这个基础数据结构的精髓. 在大部分编程语言中,数组都是从 0 开始编号的,但你是否下意识地想过,为什么数组要从 0 开始编号,而不是从 1 开始呢? 从 1 开始不是更符合人类的思维习惯吗? 你可以带着这个问题来学习接下来的内容. 如何实现随机访问? 什么是数

数据结构与算法系列研究五——树、二叉树、三叉树、平衡排序二叉树AVL

树.二叉树.三叉树.平衡排序二叉树AVL 一.树的定义 树是计算机算法最重要的非线性结构.树中每个数据元素至多有一个直接前驱,但可以有多个直接后继.树是一种以分支关系定义的层次结构.    a.树是n(≥0)结点组成的有限集合.{N.沃恩}     (树是n(n≥1)个结点组成的有限集合.{D.E.Knuth})      在任意一棵非空树中:        ⑴有且仅有一个没有前驱的结点----根(root).        ⑵当n>1时,其余结点有且仅有一个直接前驱.         ⑶所有结

五种常用的算法设计技巧之二：分治算法

一,介绍 分治算法主要包含两个步骤:分.治.分,就是递归地将原问题分解成小问题:治则是:在解决了各个小问题之后(各个击破之后)合并小问题的解,从而得到整个问题的解 二,分治递归表达式 分治算法一般都可以写出一个递归表达式:比如经典的归并排序的递归表达式:T(N)=2T(N/2)+O(N) T(N)代表整个原问题,采用了分治解决方案后,它可以表示成: ①分解成了两个规模只有原来一半(N/2)的子问题:T(N/2) ②当解决完这两个子问题T(N/2)之后,再合并这两个子问题需要的代价是 O(N) 递

数据结构与算法JavaScript (五) 串(经典KMP算法)

数据结构与算法JavaScript (五) 串(经典KMP算法) KMP算法和BM算法 KMP是前缀匹配和BM后缀匹配的经典算法,看得出来前缀匹配和后缀匹配的区别就仅仅在于比较的顺序不同 前缀匹配是指:模式串和母串的比较从左到右,模式串的移动也是从 左到右 后缀匹配是指:模式串和母串的的比较从右到左,模式串的移动从左到右. 通过上一章显而易见BF算法也是属于前缀的算法,不过就非常霸蛮的逐个匹配的效率自然不用提了O(mn),网上蛋疼的KMP是讲解很多,基本都是走的高大上路线看的你也是一头雾水,我试

LeetCode算法题-Find the Difference（Java实现-五种解法）

这是悦乐书的第214次更新,第227篇原创 01 看题和准备 今天介绍的是LeetCode算法题中Easy级别的第82题(顺位题号是389).给定两个字符串s和t,它们只包含小写字母.字符串t由随机混洗字符串s生成,然后在随机位置再添加一个字母.找到t中添加的字母.例如: 输入:s ="abcd", t ="abcde" 输出:'e' 说明:'e'是添加的字母. 本次解题使用的开发工具是eclipse,jdk使用的版本是1.8,环境是win7 64位系统,使用Jav

我的软考之路（五）——数据结构与算法（3）之图

图跟树一样,也是非线性结构,咋看起来有点复杂,其实它很简单.树具有层次关系,上层元素可以与下一个多个元素连接,但是只能和上层的一个元素连接.在图结构中,节点间的连接是任意的,任何一个元素都可以与其他元素连接. 图相对而言很简单,我们只介绍的图的遍历和最小生成树,现在我们开始. 遍历 1.概念 从图中某一个顶点出发,访问图中的每一个结点,并要求只能访问一次,不能重复访问. 2.方法 (1)广度优先遍历 基本思想:首先访问顶点,再访问顶点的全部未访问的邻结点,再访问邻结点的所有结点即可(类似树的层次