Five programming languages to interpret the data structures and algorithms - chain stack

Five programming languages ​​to interpret the data structures and algorithms - chain stack

1, Introduction stack Storage Structure

1.1, a schematic diagram of the logical structure

== stack Storage Structure and similar single chain, and all operations are performed in the header ==

For chain stacks on a single list with basically the same, it is not going to describe.

2, the stack of applications

2.1, matching brackets

2.2, expression evaluation problem

2.2.1 three infix expression introduced

2.2.2, infix expression into prefix expression

The operator advance

2.2.3, infix expression into postfix notation

The operator post

ALGORITHM

3, the relationship between stacks and recursion

== Because the recursive algorithm has many problems, so if you want to convert to a non-recursive algorithm recursive algorithm, often require a stack to solve ==

4, C language Chain stack

4.1, the contents of the file 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

Content 4.2, LinkStack.c file

#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);
}

Content 4.3, main.c file

#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, output

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 ++ language to stack chain

5.1, LinkStack.h file contents

#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

Content 5.2, LinkStack.cpp file

#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);
}

Content 5.3, main.cpp file

#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, ​​output

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 language to realize stack chain

Content 6.1, LinkStack.java file

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();
}

Content 6.2, LinkStackImpl.java file

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;
}

Content 6.3, Main.java file

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, output

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 language to achieve chain stack

7.1, LinkStack.js file contents

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;
    }
}

Content 7.2, LinkStack.html file

<!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, output

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 language to stack chain

Content 8.1, LinkStack.py file

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

Content 8.2, main.py file

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, output

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