数据结构03-顺序栈(用C++、C#、lua实现)

目录

  • 1、C#实现
  • 2、C++实现
  • 3、lua实现

本文为数据结构-顺序栈的代码实现。
作者水平比较差,有错误的地方请见谅。

1、C#实现

栈接口
IStack.cs

    /// <summary>
    /// 栈接口
    /// </summary>
    public interface IStack<T>
    {
        int GetLength(); //求栈的长度
        bool IsEmpty(); //判断栈是否为空
        void Clear(); //清空
        void Push(T item); //入栈
        T Pop(); //出栈
        T Peek(); //取栈顶元素
        void ShowAllElem(); //显示栈中所有元素
    }

顺序栈
SeqStack.cs

class SeqStack<T> : IStack<T>
    {
        private T[] mData;
        /// <summary>
        /// 指向栈顶的索引下标
        /// </summary>
        private int mTop;
        /// <summary>
        /// 栈最大容量
        /// </summary>
        private int mMaxSize;

        public SeqStack(int length)
        {
            mData = new T[length];
            mTop = -1;
            mMaxSize = length;
        }
        //默认栈容量为10
        public SeqStack() : this(10)
        {
        }

        public void Push(T item)
        {
            if (mMaxSize == GetLength())
            {
                Console.WriteLine("栈中元素已满,无法入栈。");
                return;
            }
            mTop++;
            mData[mTop] = item;
        }

        public T Pop()
        {
            if (mTop == -1)
            {
                Console.WriteLine("栈中无元素,无法出栈。");
                return default(T);
            }
            mTop--;
            return mData[mTop+1];
        }

        public void Clear()
        {
            mTop = -1;
        }

        public int GetLength()
        {
            return mTop + 1;
        }

        public bool IsEmpty()
        {
            if (mTop != -1)
            {
                return false;
            }
            return true;
        }

        public T Peek()
        {
            return mData[mTop];
        }

        public void ShowAllElem()
        {
            for (int i = 0; i <= mTop; i++)
            {
                Console.WriteLine(mData[i]);
            }
        }
    }

Program.cs

    class Program
    {
        static void Main(string[] args)
        {
            SeqStack<string> strStack = new SeqStack<string>(4);

            strStack.Push("111");
            strStack.Push("222");
            strStack.Push("333");
            strStack.Push("444");

            strStack.Clear();
            strStack.Push("111");
            strStack.Push("222");
            strStack.Push("333");
            strStack.Push("444");

            //Console.WriteLine(strStack.IsEmpty());
            //Console.WriteLine(strStack.GetLength());
            //Console.WriteLine(strStack.Pop());
            //Console.WriteLine(strStack.Peek());
            strStack.ShowAllElem();

            Console.ReadKey();
        }
    }

2、C++实现

栈接口
IStack.cpp

#include <iostream>
using namespace std;

typedef int ElemType;

class IStack
{
public :
    ///求栈的长度
    virtual int GetLength() = 0;

    ///判断栈是否为空
    virtual bool IsEmpty() = 0;

    ///清空操作
    virtual void Clear() = 0;

    ///入栈操作
    virtual void Push(ElemType item) = 0;

    ///出栈操作
    virtual ElemType Pop() = 0;

    ///取栈顶元素
    virtual ElemType Peek() = 0;

    ///显示所有元素
    virtual void ShowAllElem() = 0;
};

顺序栈
SeqStack.cpp

#include <iostream>
#include "IStack.cpp"

using namespace std;
typedef int ElemType;

typedef struct{
    ///栈顶指针(指向最上面元素的上一个)、栈底指针(指向最下面的元素)、最大容量
    ElemType* top;
    ElemType* base;
    int maxSize;
}MyStack;

class SeqStack : public IStack
{
private :
    MyStack mStack;

public :
    ///默认栈容量设置为10
    SeqStack();
    SeqStack(int stackSize);

    ~SeqStack();

    int GetLength();

    bool IsEmpty();

    void Clear();

    void Push(ElemType item);

    ElemType Pop();

    ElemType Peek();

    void ShowAllElem();
};

SeqStack::SeqStack()
{
    mStack.base = new ElemType[10];
    if(mStack.base==NULL){
        cout<<"分配空间失败!"<<endl;
        return;
    }
    mStack.top = mStack.base;
    mStack.maxSize = 10;
}

SeqStack::SeqStack(int stackSize)
{
    mStack.base = new ElemType[stackSize];
    if(mStack.base==NULL){
        cout<<"分配空间失败!"<<endl;
        return;
    }
    mStack.top = mStack.base;
    mStack.maxSize = stackSize;
}

SeqStack::~SeqStack()
{
    delete []mStack.base;
    mStack.base = NULL;
    mStack.top = NULL;
}

int SeqStack::GetLength()
{
    return mStack.top - mStack.base;
}

bool SeqStack::IsEmpty()
{
    if(mStack.top == mStack.base){
        return true;
    }
    return false;
}

void SeqStack::Clear()
{
    mStack.top = mStack.base;
}

void SeqStack::Push(ElemType item)
{
    if(GetLength() == mStack.maxSize){
        cout<<"入栈失败,空间已满。"<<endl;
        return;
    }
    *mStack.top = item;
    mStack.top++;
}

ElemType SeqStack::Pop()
{
    if(mStack.top == mStack.base){
        cout<<"出栈失败,空间中无元素。"<<endl;
        return 0;
    }

    mStack.top--;
    return *mStack.top;
}

ElemType SeqStack::Peek()
{
    if(mStack.top == mStack.base){
        cout<<"空间中无元素。"<<endl;
        return 0;
    }
    return *(mStack.top-1);
}

void SeqStack::ShowAllElem()
{
    ElemType* temp = mStack.base;
    while(temp!=mStack.top){
        cout<<*temp<<endl;
        temp++;
    }
}

main.cpp

#include <iostream>
#include "SeqStack.cpp"

using namespace std;

int main()
{
    SeqStack myStack(10);

    myStack.Push(111);
    myStack.Push(222);
    myStack.Push(333);
    myStack.Push(444);

    myStack.Clear();
    myStack.Push(111);
    myStack.Push(222);
    myStack.Push(333);
    myStack.Push(444);

    //cout<<myStack.GetLength()<<endl;
    //cout<<myStack.IsEmpty()<<endl;
    //cout<<myStack.Pop()<<endl;
    //cout<<myStack.Peek()<<endl;

    myStack.ShowAllElem();

    return 0;
}

3、lua实现

--顺序栈和栈顶指针
seqStack = {}
top = 0

--初始化
function seqStack:Init()

end

--销毁
function seqStack:Destory()
    self = nil
    top = nil
end

--清空
function seqStack:Clear()
    top = 0
end

--是否为空
function seqStack:IsEmpty()
    if(top==0) then
        return true
    else
        return false
    end
end

--长度
function seqStack:GetLength()
    return top
end

--入栈
function seqStack:Push(value)
    top = top + 1
    self[top] = value
end

--出栈
function seqStack:Pop()
    if(self:IsEmpty()) then
        print("出栈失败,空间中无元素。");
    else
        top = top - 1
        return self[top+1]
    end
end

--获取栈顶元素
function seqStack:Peek()
    if(self:IsEmpty()) then
        print("空间中无元素。");
    else
        return self[top]
    end
end

--显示所有元素
function seqStack:ShowAllElem()
    for i=1,top,1 do
        print(self[i])
    end
end

--主运行函数
function main()
    seqStack:Init()
    seqStack:Push(111)
    seqStack:Push(222)
    seqStack:Push(333)
    seqStack:Push(444)

    seqStack:Clear();
    seqStack:Push(111);
    seqStack:Push(222);
    seqStack:Push(333);
    seqStack:Push(444);

    --print(seqStack:GetLength())
    --print(seqStack:IsEmpty())
    --print(seqStack:Pop())
    --print(seqStack:Peek())

    seqStack:ShowAllElem()
end

main()

原文地址:https://www.cnblogs.com/Fflyqaq/p/11792930.html

时间: 2024-10-26 07:16:22

数据结构03-顺序栈(用C++、C#、lua实现)的相关文章

浅谈数据结构之顺序栈(三)

栈:是限定仅在表尾进行插入与删除操作的线性表.我们把允许插入与删除的一端称为栈顶,另一端称为栈底,不含任何数据元素的称为空栈.栈的插入操作,叫作进栈,也叫压栈.入栈,类似于子弹入弹夹:栈的删除操作,叫作出栈,也叫弹栈,如同弹夹中的子弹出夹.注意:栈的定义中的"表尾"指的是"栈顶",而不是"栈底". 首先,栈是一个线性表,也就是说:栈具有线性结构,即前驱后继关系:只不过它是一个特殊的线性表而已,它的特殊之处在于限制了这个线性表的插入与删除位置,它始

数据结构之顺序栈基本操作SqStack

顺序栈SqStack 基本操作 1 Status InitStack()//构造一个空栈S 2 Status DestroyStack()//销毁栈S,S不再存在 3 Status ClearStack()//把S置为空栈 4 Status StackEmpty()//若S为空栈,则返回true,否则返回false 5 int StackLength()//返回S的元素个数,即栈的长度 6 Status GetTop(SElemType &e)//若栈不空,则用e返回S的栈顶元素,并返回OK,否

【数据结构之顺序栈的基本运算】

//顺序栈 public class OrderStack { //(1)置空栈 void InitStack(SeqStack *S){ S->top = -1; } //(2)判断栈空 int StackEmpty(SeqStack *S){ return S->top == -1; } //(3)判断栈满 int StackFull(SeqStack *S){ return S->top == StackSize-1; } //(4)进栈 void push(S,x){ if(St

数据结构之顺序栈(C++版)

#include <iostream>#include <stdlib.h>#define MAXLISTSIZE 100 //预设的存储空间最大容量using namespace std; typedef string ElemType;typedef struct{ ElemType *base; //存储空间基址 int top; //栈顶指针 int stacksize; //允许的最大存储空间以元素为单位}Stack; void InitStack(Stack &

数据结构库——顺序栈的概念及实现

1,栈的定义: 1,栈是一种特殊的线性表: 2,栈仅能在线性表的一端进行操作: 1,栈顶(Top):允许操作的一端: 2,栈底(Bottom):不允许操作的一端: 2,栈的特性: 1,后进先出(Last In First Out)(只有一个特性): 3,栈的操作(创销进出顶大清): 1,创建栈(Stack()): 2,销毁栈(~Stack()): 3,进栈(push()): 4,出栈(pop()): 5,获取栈顶元素(top()): 6,获取栈的大小(size()): 7,清空栈(clear()

数据结构:顺序栈

这是严蔚敏吴伟民版本的算法,感觉没<大话数据结构>里面的简单易懂 这个版本里面的top指针指向下一个空单元格,这个其实是有些问题的,因为栈满的时候,top是指向栈外的,有些不安全. 1 #ifndef SQ_STACK_HEAD 2 #define SQ_STACK_HEAD 3 #include <stdio.h> 4 #include <stdlib.h> 5 #define Status int 6 #define OVERFLOW -1 7 #define OK

【数据结构】顺序栈的实现(c++)

头文件: #pragma once #include <iostream> #include <assert.h> using namespace std; template<class Type> class SeqStack { public: SeqStack(size_t sz = INIT_SZ); ~SeqStack(); public: bool empty()const; bool full()const; void show()const; bool

【数据结构】顺序栈

#include <STDIO.H> #include <STRING.H> #include <STDLIB.H> typedef struct SeqStack { int length; int top; char *data; }seqstack; seqstack* CreatStack(seqstack *s,int n) { s=(seqstack *)malloc(sizeof(seqstack)+n*sizeof(char)); if(s==NULL)

顺序栈的总结

基本数据结构之-顺序栈 栈是一种先进后出的数据结构,我们可以使用一个数组来模拟栈的这种结构,将数组的尾部当做栈的栈顶似乎是一个不错的选择(插入和移除元素是不涉及到数据的移动),也可以很好的控制数组的长度,和数据的进栈和出栈! 首先先解析一下顺序栈的数据结构 1 需要一个数据域来存储数据 考虑到可能存储自定义的数据类型,所以我们选择存储每个数据的开始的地址 (void **stack) 2 需要一个值来记录当前的数据域的长度 (size) 3 需要一个值来记录当前的容器的长度 typedef st