目录

• 五种编程语言解释数据结构与算法—链式栈
  • 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