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

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

1、栈的介绍

1.1、栈的基本概念

==栈只允许一端进行插入或者删除操作的线性表==

特点：后进先出

1.2、栈的基本操作

2、栈的顺序存储结构

2.1、栈的逻辑示意图

2.2、判断栈空、栈满和求栈长

2.3、特殊的顺序栈—共享栈

3、使用C语言来实现顺序栈

3.1、SeqStack.h文件中的内容

#ifndef XGP_STUDY_DEMO47_SEQSTACK_H
#define XGP_STUDY_DEMO47_SEQSTACK_H

//数组去模拟栈的顺序存储

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

#define MAX_SIZE 1024

typedef struct SEQSTACK {
    void* data[MAX_SIZE];
    int size;
}SeqStack;

//1，初始化栈
SeqStack* Init_SeqStack();
//2，入栈
void Push_SeqStack(SeqStack* stack,void* data);
//3，返回栈顶元素
void* Top_SeqStack(SeqStack* stack);
//4，出栈
void* Pop_SeqStack(SeqStack* stack);
//5，判断是否为空
int IsEmpty(SeqStack* stack);
//6，返回栈中元素的个数
int Size_SeqStack(SeqStack* stack);
//7，销毁
void FreeSpace_SeqStack(SeqStack* stack);
//8，清空栈
void Clear_SeqStack(SeqStack* stack);
#endif //XGP_STUDY_DEMO47_SEQSTACK_H

3.2、SeqStack.c文件中的内容

#include "SeqStack.h"

//1，初始化栈
SeqStack* Init_SeqStack() {
    SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));
    for(int i = 0;i < MAX_SIZE;i++) {
        stack->data[i] = NULL;
    }

    stack->size = 0;

    return stack;
}
//2，入栈
void Push_SeqStack(SeqStack* stack,void* data) {
    if(stack == NULL) return;
    if(data == NULL) return;
    if(stack->size == MAX_SIZE) return;

    stack->data[stack->size] = data;
    stack->size++;

}
//3，返回栈顶元素
void* Top_SeqStack(SeqStack* stack) {
    if(stack == NULL) return NULL;
    if(stack->size == 0) return NULL;

    return stack->data[stack->size - 1];
}
//4，出栈
void* Pop_SeqStack(SeqStack* stack) {
    if(stack == NULL) return NULL;
    if(stack->size == 0) return NULL;

    void* save = stack->data[stack->size - 1];

    stack->data[stack->size - 1] = NULL;
    stack->size--;
    return save;
}
//5，判断是否为空
int IsEmpty(SeqStack* stack) {
    if(stack == NULL) return -1;
    if(stack->size == 0) return 1;
    return 0;
}
//6，返回栈中元素的个数
int Size_SeqStack(SeqStack* stack) {
    if(stack == NULL) return -1;
    return stack->size;
}
//7，销毁
void FreeSpace_SeqStack(SeqStack* stack) {
    if(stack == NULL) return;

    free(stack);
}
//8，清空栈
void Clear_SeqStack(SeqStack* stack) {
    if(stack == NULL) return;

    for(int i = 0;i < stack->size;i++) {
        stack->data[i] = NULL;
    }
    stack->size = 0;
}

3.3、main.c文件中的内容

#include "SeqStack.h"

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

int main() {
    //创建栈
    SeqStack* stack = Init_SeqStack();
    //创建数据
    Person p1 = {"aaa",18};
    Person p2 = {"bbb",19};
    Person p3 = {"ccc",20};
    Person p4 = {"ddd",21};
    Person p5 = {"eee",22};

    //入栈
    Push_SeqStack(stack,&p1);
    Push_SeqStack(stack,&p2);
    Push_SeqStack(stack,&p3);
    Push_SeqStack(stack,&p4);
    Push_SeqStack(stack,&p5);

    //输出
    while (Size_SeqStack(stack) > 0) {
        //出栈
        Person* person = (Person *) Pop_SeqStack(stack);
        printf("Name:%s Age:%d\n",person->name,person->age);
    }

    printf("%d\n",IsEmpty(stack));

    FreeSpace_SeqStack(stack);

    return 0;
}

3.4、输出结果

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

Process finished with exit code 0

4、使用C++语言来实现顺序栈

4.1、SeqStack.h文件中的内容

#ifndef XGP_STUDY_DEMO47_SEQSTACK_H
#define XGP_STUDY_DEMO47_SEQSTACK_H

//数组去模拟栈的顺序存储

#include <iostream>
using namespace std;

#define MAX_SIZE 1024

template <class T>
class SeqStack {
public:
    T* data[MAX_SIZE];
    int size;

    //1，初始化栈
    SeqStack* Init_SeqStack();
//2，入栈
    void Push_SeqStack(T* data);
//3，返回栈顶元素
    T* Top_SeqStack();
//4，出栈
    T* Pop_SeqStack();
//5，判断是否为空
    bool IsEmpty();
//6，返回栈中元素的个数
    int Size_SeqStack();
//7，销毁
    void FreeSpace_SeqStack();
//8，清空栈
    void Clear_SeqStack();
};

#endif //XGP_STUDY_DEMO47_SEQSTACK_H

4.2、SeqStack.cpp文件中的内容

#include "SeqStack.h"

template<class T>
SeqStack<T> *SeqStack<T>::Init_SeqStack() {
    for(int i = 0;i < MAX_SIZE;i++) {
        this->data[i] = NULL;
    }

    this->size = 0;

    return this;
}

template<class T>
void SeqStack<T>::Push_SeqStack(T *data) {
    if(this == NULL) return;
    if(data == NULL) return;
    if(this->size == MAX_SIZE) return;

    this->data[this->size] = data;
    this->size++;
}

template<class T>
T *SeqStack<T>::Top_SeqStack() {
    if(this == NULL) return NULL;
    if(this->size == 0) return NULL;

    return this->data[this->size - 1];
}

template<class T>
T *SeqStack<T>::Pop_SeqStack() {
    if(this == NULL) return NULL;
    if(this->size == 0) return NULL;

    T* save = this->data[this->size - 1];

    this->data[this->size - 1] = NULL;
    this->size--;
    return save;
}

template<class T>
bool SeqStack<T>::IsEmpty() {
    if(this == NULL) return false;
    if(this->size == 0) return true;
    return false;
}

template<class T>
int SeqStack<T>::Size_SeqStack() {
    if(this == NULL) return -1;
    return this->size;
}

template<class T>
void SeqStack<T>::FreeSpace_SeqStack() {
    if(this == NULL) return;

    delete this;
}

template<class T>
void SeqStack<T>::Clear_SeqStack() {
    if(this == NULL) return;

    for(int i = 0;i < this->size;i++) {
        this->data[i] = NULL;
    }
    this->size = 0;
}

4.3、main.cpp文件中的内容

#include "SeqStack.cpp"

class Person {
public:
    string name;
    int age;

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

int main() {
    //创建栈
    SeqStack<Person>* stack = new SeqStack<Person>();
    //创建数据
    Person p1("aaa",18);
    Person p2("bbb",19);
    Person p3("ccc",20);
    Person p4("ddd",21);
    Person p5("eee",22);

    //入栈
    stack->Push_SeqStack(&p1);
    stack->Push_SeqStack(&p2);
    stack->Push_SeqStack(&p3);
    stack->Push_SeqStack(&p4);
    stack->Push_SeqStack(&p5);

    //输出
    while (stack->Size_SeqStack() > 0) {
        //出栈
        Person* person = (Person *) stack->Pop_SeqStack();
        cout<<"Name:"<<person->name<<"\t"<<"Age:"<<person->age<<endl;
    }

    cout<<stack->IsEmpty()<<endl;

    stack->FreeSpace_SeqStack();

    return 0;
}

4.4、输出结果

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

Process finished with exit code 0

5、使用java语言来实现顺序栈

5.1、SeqStack.java文件中的内容

package com.xgp.队列的顺序存储;

public interface SeqStack<T> {

    //1，初始化栈
    void Init_SeqStack();
    //2，入栈
    void Push_SeqStack(T data);
    //3，返回栈顶元素
    T Top_SeqStack();
    //4，出栈
    T Pop_SeqStack();
    //5，判断是否为空
    boolean IsEmpty();
    //6，返回栈中元素的个数
    int Size_SeqStack();
    //7，销毁
    void FreeSpace_SeqStack();
    //8，清空栈
    void Clear_SeqStack();
}

5.2、SeqStackImpl.java文件中的内容

package com.xgp.队列的顺序存储;

public class SeqStackImpl<T> implements SeqStack<T> {

    public final static int MAX_SIZE = 1024;

    public Object  data[] = new Object[MAX_SIZE];
    public int size;

    @Override
    public void Init_SeqStack() {
        for(int i = 0;i < MAX_SIZE;i++) {
            this.data[i] = null;
        }

        this.size = 0;
    }

    @Override
    public void Push_SeqStack(T data) {
        if(data == null) return;
        if(this.size == MAX_SIZE) return;

        this.data[this.size] = data;
        this.size++;
    }

    @Override
    public T Top_SeqStack() {
        if(this.size == 0) return null;

        return (T) this.data[this.size - 1];
    }

    @Override
    public T Pop_SeqStack() {
        if(this.size == 0) return null;

        T save = (T) this.data[this.size - 1];

        this.data[this.size - 1] = null;
        this.size--;
        return save;
    }

    @Override
    public boolean IsEmpty() {
        if(this.size == 0) return true;
        return false;
    }

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

    @Override
    public void FreeSpace_SeqStack() {
        Clear_SeqStack();
        System.gc();
    }

    @Override
    public void Clear_SeqStack() {

        for(int i = 0;i < this.size;i++) {
            this.data[i] = null;
        }
        this.size = 0;
    }
}

5.3、Main.java文件中的内容

package com.xgp.队列的顺序存储;

public class Main {
    public static void main(String[] args) {
        SeqStack<Person> stack = new SeqStackImpl<>();
        stack.Init_SeqStack();

        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_SeqStack(p1);
        stack.Push_SeqStack(p2);
        stack.Push_SeqStack(p3);
        stack.Push_SeqStack(p4);
        stack.Push_SeqStack(p5);

        while (!stack.IsEmpty())
            System.out.println(stack.Pop_SeqStack());

        System.out.println(stack.IsEmpty());

        stack.FreeSpace_SeqStack();
    }
}

class Person {
    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 +
                '}';
    }
}

5.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}
true

进程完成，退出码 0

6、使用JavaScript语言来实现顺序栈

6.1、SeqStack.js文件中的内容

class SeqStack {

    Init_SeqStack() {
        this.MAX_SIZE = 1024;
        this.data = [];

        for(var i = 0;i < this.MAX_SIZE;i++) {
            this.data[i] = null;
        }

        this.size = 0;
    }

    Push_SeqStack(data) {
        if(this == null) return;
        if(data == null) return;
        if(this.size == this.MAX_SIZE) return;

        this.data[this.size] = data;
        this.size++;
    }

    Top_SeqStack() {
        if(this == null) return null;

        if(this.size == 0) return null;

        return this.data[this.size - 1];
    }

    Pop_SeqStack() {
        if(this == null) return -1;

        if(this.size == 0) return null;

        var save = this.data[this.size - 1];

        this.data[this.size - 1] = null;
        this.size--;
        return save;
    }

    IsEmpty() {
        if(this == null) return true;
        if(this.size == 0) return true;
        return false;
    }

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

    FreeSpace_SeqStack() {
        if(this == null) return;
        this.Clear_SeqStack();
    }

    Clear_SeqStack() {
        if(this == null) return;
        for(var i = 0;i < this.size;i++) {
            this.data[i] = null;
        }
        this.size = 0;
    }
}

6.2、SeqStack.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="SeqStack.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 SeqStack();
        stack.Init_SeqStack();

        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_SeqStack(p1);
        stack.Push_SeqStack(p2);
        stack.Push_SeqStack(p3);
        stack.Push_SeqStack(p4);
        stack.Push_SeqStack(p5);

        while (!stack.IsEmpty())
            stack.Pop_SeqStack().print();

        console.log(stack.IsEmpty());

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

6.3、输出结果

Name:eee    Age:22 SeqStack.html:18:25
Name:ddd    Age:21 SeqStack.html:18:25
Name:ccc    Age:20 SeqStack.html:18:25
Name:bbb    Age:19 SeqStack.html:18:25
Name:aaa    Age:18 SeqStack.html:18:25
true SeqStack.html:40:17

7、使用Python语言来实现顺序栈

7.1、SeqStack.py文件中的内容

class SeqStack:

    def Init_SeqStack(self):
        self.MAX_SIZE = 1024
        self.data = [None]*self.MAX_SIZE
        self.size = 0

    def Push_SeqStack(self,data):
        if(self is None):
            return
        if(data is None):
            return
        if(self.size == self.MAX_SIZE):
            return
        self.data[self.size] = data
        self.size += 1

    def Top_SeqStack(self):
        if(self is None):
            return None
        if(self.size == 0):
            return None
        return self.data[self.size - 1]

    def Pop_SeqStack(self):
        if(self is None):
            return -1
        if(self.size == 0):
            return None
        save = self.data[self.size -1]
        self.data[self.size - 1] = None
        self.size -= 1
        return save

    def IsEmpty(self):
        if(self == None):
            return True
        if(self.size == 0):
            return True
        return False

    def Size_SeqStack(self):
        if(self is None):
            return -1
        return self.size

    def FreeSpace_SeqStack(self):
        if(self is None):
            return
        self.Clear_SeqStack()

    def Clear_SeqStack(self):
        if(self is None):
            return
        for i in range(0,self.size):
            self.data[i] = None
        self.size = 0

7.2、main.py文件中的内容

from SeqStack 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 = SeqStack()
stack.Init_SeqStack()

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

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

while(stack.IsEmpty() == False):
    print(stack.Pop_SeqStack())

print(stack.IsEmpty())

stack.FreeSpace_SeqStack()

7.3、输出结果

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

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