数据结构之栈

Posted hrnn

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构之栈相关的知识,希望对你有一定的参考价值。

  • 用数组实现一个顺序栈
  • 用链表实现一个链式栈
  • 编程模拟实现一个浏览器的前进、后退功能

用数组实现一个顺序栈

class Stack(object):
    def __init__(self):
        self.stack=[]
    
    def push(self,item):
        self.stack.append(item)
        
    def pop(self):
        return self.stack.pop()
    
    def peek(self):
        if len (self.stack)>=1:
            return self.stack[-1]
        else :
            return ‘栈空‘
#测试用例
if __name__==‘__main__‘:
    st=Stack()
    st.push(1)
    st.push(2)
    print(st.pop())
    print(st.peek())
    print(st.pop())

 

#include <iostream>


const int StackSize=100;

//

template <class Datatype>

class SeqStack {

private:

    Datatype data[StackSize];

    int top;

public:

    SeqStack(){top=-1;};    //将项顶指针置为-1

    ~SeqStack(){}

    void Push(Datatype x);

    Datatype Pop();

    Datatype GetTop();//取栈顶元素实现

    int Empty(); //判断是否为空

    void printlist(); //打印

};


template <class Datatype>

int SeqStack<Datatype>::Empty()

{

    if (top==-1) {

        return 1;

    }

    else return 0;

}

//入栈操作

template <class Datatype>

void SeqStack<Datatype>::Push(Datatype x)

{

    if (top==StackSize-1) throw "栈空间已满,无法再添加";

        data[++top]=x;

}

//出栈操作

template <class Datatype>

Datatype SeqStack<Datatype>::Pop()

{

    if (top==-1) throw "栈已经为空";

    

        Datatype x;

       x=data[top--];

        return x;

    

}


template <class Datatype>

Datatype SeqStack<Datatype>::GetTop()

{

    if (top==-1) throw "这是空栈";

    return data[top];

        

}

template <class Datatype>

void  SeqStack<Datatype>::printlist()

{

    if (top==-1) throw "这是空栈";

    for (int i=0; i<=top; i++) {

        std::cout<<data[i]<<" ";

    }

}


int main(int argc, const char * argv[]) {

    SeqStack<int> Student = SeqStack<int>();

    std::cout<<"is empty?"<<Student.Empty();

    for (int i=0; i<10; i++) {

        Student.Push(i);

    }

    std::cout<<"is empty?"<<Student.Empty();

    std::cout<<"The top word is"<<Student.GetTop();

    Student.printlist();

    std::cout<<"Pop the pop word,and it‘s "<<Student.Pop()<<" ";

 std::cout<<"The top word is"<<Student.GetTop()<<" ";

    return 0;

}
主要操作函数如下:

        InitStack(SqStack &s) 参数:顺序栈s 功能:初始化  时间复杂度O(1)
        Push(SqStack &s,SElemType e) 参数:顺序栈s,元素e 功能:将e入栈 时间复杂度:O(1)
        Pop(SqStack &s,SElemType &e) 参数:顺序栈s,元素e 功能:出栈,e接收出栈元素值 时间复杂度O(1)
        GetTop(SqStack s,SElemType &e) 参数:顺序栈s,元素e 功能:得到栈顶元素 时间复杂度O(1)
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
#define Status int
#define SElemType int
#define MaxSize 100
//栈数据结构
typedef struct Stack
{
    SElemType *base;//栈底指针 不变
    SElemType *top;//栈顶指针 一直在栈顶元素上一个位置
    int stacksize;//栈可用的最大容量
}SqStack;
//**************************************基本操作函数************************************//
//初始化函数
Status InitStack(SqStack &s)
{
    s.base=new SElemType[MaxSize];//动态分配最大容量
    if(!s.base)
    {
        printf("分配失败 ");
        return 0;
    }
    s.top=s.base;//栈顶指针与栈底相同 王道上top起初在base下面,感觉很别扭,top应该高于或等于base
    s.stacksize=MaxSize;
    return 1;
}
//入栈
Status Push(SqStack &s,SElemType e)
{
    if(s.top-s.base==s.stacksize) return 0;//栈满
    *(s.top++)=e;//先入栈,栈顶指针再上移 注意与王道上的不同,具体问题具体分析
    return 1;    
}
//出栈 用e返回值
Status Pop(SqStack &s,SElemType &e)
{
    if(s.top==s.base) return 0;//栈空
    e=*--s.top;//先减减 指向栈顶元素,再给e
    return 1;    
}
//得到栈顶元素,不修改指针
bool GetTop(SqStack s,SElemType &e) //严蔚敏版59页有问题,应该用e去获得,函数返回bool类型去判断
{
    if(s.top==s.base) return false;//栈空            
    else e=*--s.top;
    return true;
        
}
//********************************功能实现函数**************************************//
//菜单
void menu()
{
   printf("********1.入栈      2.出栈********* ");
   printf("********3.取栈顶    4.退出********* ");
}
//入栈功能函数 调用Push函数
void PushToStack(SqStack &s)
{
    int n;SElemType e;int flag;
    printf("请输入入栈元素个数(>=1): ");
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
     printf("请输入第%d个元素的值:",i+1);
     scanf("%d",&e);
     flag=Push(s,e);
     if(flag)printf("%d已入栈 ",e);
     else {printf("栈已满!!! ");break;}
    }
}
//出栈功能函数 调用Pop函数
void PopFromStack(SqStack &s)
{
    int n;SElemType e;int flag;
    printf("请输入出栈元素个数(>=1): ");
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
     flag=Pop(s,e);
     if(flag)printf("%d已出栈 ",e);
     else {printf("栈已空!!! ");break;}
    }
}
//取栈顶功能函数 调用GetTop
void GetTopOfStack(SqStack &s)
{
    SElemType e;bool flag;
    flag=GetTop(s,e);
    if(flag)printf("栈顶元素为:%d ",e);
    else printf("栈已空!!! ");
}
//主函数
int main()
{
 SqStack s;int choice;
 InitStack(s);
 while(1)
 {
  menu();
  printf("请输入菜单序号: ");
  scanf("%d",&choice);
  if(choice==4) break;
  switch(choice)
  {
  case 1:PushToStack(s);break;
  case 2:PopFromStack(s);break;
  case 3:GetTopOfStack(s);break;
  default:printf("输入错误!!! ");
  }
 }
 return 0;
}

用链表实现一个链式栈

链式栈

基于链表实现链式栈,对栈做以下操作:

  • 出栈
  • 入栈
  • 取栈顶元素
  • 初始化
  • 销毁

基于栈后进先出的结构,入栈可以用头插来实现,出栈用头删来实现即可。

初始化

void LinkStackInit(LinkStack** phead)
{
    if(phead==NULL)
    {
        return;//非法输入
    }
    *phead=NULL;
}



void LinkStackDestroy(LinkStack** phead)
{
    if(phead==NULL)
    {
        return;
    }
    LinkStack* cur=*phead;
    for(;cur!=NULL;cur=cur->next)
    {
        free(cur);
    }
    *phead=NULL;
}

void LinkStackPush(LinkStack** phead,LinkStackType value)
{
    if(phead==NULL)
    {
        return;//非法输入
    }
    LinkStack* new_node=CreatNode(value);
    new_node->next=*phead;
    *phead=new_node;
}
出栈

void LinkStackPop(LinkStack** phead)
{
    if(phead==NULL)
    {
        return;
    }
    if(*phead==NULL)
    {
        return;//空栈
    }
    LinkStack* to_delete=*phead;
    *phead=(*phead)->next;
    free(to_delete);
}

package stack;

public class StackByLinkedlist {

    ListNode popNode;

    public boolean push(String item) {
        ListNode temp = popNode;
        popNode = new ListNode(item);
        popNode.next = temp;
        return true;
    }

    public String pop() {
        if (popNode == null) {
            return null;
        }
        String result = popNode.val;
        popNode = popNode.next;
        return result;
    }

    public String peek() {
        if (popNode == null) {
            return null;
        }
        String result = popNode.val;

        return result;
    }

    public boolean empty() {
        return popNode == null;
    }


    class ListNode {
        String val;
        ListNode next;

        ListNode(String x) {
            val = x;
        }
    }

}

编程模拟实现一个浏览器的前进、后退功能
#include<iostream>
#include<string>
#include<stack>
using namespace std;
int main(){
 stack<string> backward,forward;
 string now,b,c="csw.jlu.edu.cn";
 while(1){
  cin>>b;
  if(b=="VISIT"){
   cin>>now;
   cout<<now<<endl;
   backward.push(c);
   while(!forward.empty()){
    forward.pop();
   }
  }
  if(b=="BACK"){
   if(backward.size()!=0){
    c=backward.top();
    backward.pop();
    cout<<c<<endl;
    forward.push(now);
    now=c;
   }
   else{
    cout<<"Ignored"<<endl;
    c="csw.jlu.edu.cn";
   }
  }
  if(b=="FORWARD"){
   if(forward.size()!=0){
    c=forward.top();
    forward.pop();
    cout<<c<<endl;
    backward.push(now);
    now=c;
   }
   else{
    cout<<"Ignored"<<endl;
   }
  }
  if(b=="QUIT"){
   break;
  }
  if(b!="VISIT"&&b!="BACK"&&b!="FORWARD"&&b!="QUIT"){
   cout<<"输入错误!"<<endl;
  }
 }
}
我们浏览网页,会发现“前进”和“后退”是 Web 浏览器的常用功能,实现该功能的一种方式是使用两个栈(backward 栈和forward 栈)来存储用户访问的网址,用户的不同操作对应的具体实现方法如下:

    后退(BACK):如果backward 栈为空,则该命令被忽略。否则,将当前页面压入forward栈,并从backward 栈中弹出一个页面作为当前页面。
    前进(FORWARD):如果forward 栈为空,则该命令被忽略。否则,将当前页面压入backward 栈,并从forward 栈中弹出一个页面作为当前页面。
    访问某网址(VISIT <URL>):将当前页面压入backward 栈,并将此次访问的网页作为当前页面,清空forward 栈。

二、整体思路

根据栈结构后进先出的顺序,我们很容易想到,可以把用户当前浏览的网页入栈,当用户在新界面点击回退按钮的时候,直接让栈顶元素出栈,让浏览器加载,不就实现了后退功能了吗?前进的功能也类似,于是乎,我们想到用两个栈分别存储在用户当前浏览网页之前/之后的所有页面地址。理想的结构(BackStack回退栈,ForwardStack前进栈),如下图所示:

技术图片

 

 四、页面按钮实现的前进后退

    <input type=button value=刷新 onclick="window.location.reload()">
    <input type=button value=前进 onclick="window.history.go(1)">
    <input type=button value=后退 onclick="window.history.go(-1)">
    <input type=button value=前进 onclick="window.history.forward()">
    <input type=button value=后退 onclick="window.history.back()">
    <input type=button value=后退并刷新  onclick="window.history.go(-1);window.location.reload()">

下面是history源码,有没有什么发现呢?

    interface History {
        readonly length: number;
        scrollRestoration: ScrollRestoration;
        readonly state: any;
        back(distance?: any): void;
        forward(distance?: any): void;
        go(delta?: any): void;
        pushState(data: any, title?: string, url?: string | null): void;
        replaceState(data: any, title?: string, url?: string | null): void;
    }

我们浏览网页,经常会用到前进,后退的功能。比如依次浏览了a-b-c 三个页面,这时点后退,可以回到 b 页面,再次点击回到 a 页面。如果这时,又进入 新页面d ,那就无法通过前进,后退功能回到b、c页面了。

这样一个功能,要如何实现呢?

其实这样一个功能,可以借助栈来实现。

什么是栈?它是一个数据结构,数据先进后出,后进先出。打一个比方,放一叠盘子,放的时候,都放最上面,取的时候也从最上面取。典型的后进先出。

栈,可以用数组来实现,也可以用链表来实现。前者叫顺序栈,后者是链式栈。

为什么会有栈这种数据结构,直接用数组或是链表不就好了么?栈有严格的限制,只能从栈顶压入数据,从栈顶取数据,可以满足特定场景的需求,而链表或是数组暴露了太多的接口,容易出错。
如何实现一个栈

public class ArrayStack{
    private String [] items; // 数组
    private int count; // 栈中元素个数
    private int n; //栈的大小
    
    // 初始化数组,申请一个大小为 n 的数组空间
    public ArrayStack(int n){
        items = new String [n];
        this.n = n;
        count = 0;
    }
    // 入栈操作
    public boolean push(String item){
        if(count == n){
            return false;
        }
        items[count-1] = item;
        count++;
        return true;
    }
    // 出栈操作
    public String pop(){
    if(count == 0){
        return null;
    }
    String temp = items[count-1];
    count--;
    return temp;
    }
}


栈的实际应用

栈作为一个基础的数据结构,经典的应用场景是函数调用。

我们知道,操作系统,为每个线程分配了独立的内存空间,这些内存空间组织成栈的结构,来存储函数调用产生的临时变量。每次进入一个函数,将临时变量作为栈桢入栈,当函数调用完成,有结果返回时,函数对应的栈桢出栈。便于理解,我们看一看下面的一段代码

int main() {
    int a = 1;
    int ret = 0;
    int res = 0;
    ret = add(3, 5);
    res = a+ret;
    printf("%d", res);
    return 0;
}
int add(int x, int y){
    int sum = 0;
    sum = x + y;
    return sum;
}



为了清晰地看到这个函数调用的过程中,出栈、入栈的操作,贴一张图
在这里插入图片描述
栈在表达式求值中的应用

再看一个常见的应用场景,编译器如何利用栈来实现表达式求值。

我们用一个简单的四则运算来说明这个问题,比如3+5*8-6,对于计算机来说,如何理解这个表达式,是个不太容易的事儿。

事实上,编译器是通过两个栈来实现的,其中一个保存数字,暂且叫A,一个保存运算符暂且叫B。从左到右遍历表达式,当遇到数字,直接压入A栈,当遇到运符时,就与B栈中栈顶元素进行比较。

如果比栈顶元素的优先级高,就将运算符压入栈,如果相同或者低,从B栈中取出栈顶元素,从A栈的栈顶取出两个数字,进行计算,再把计算结果压入A栈,继续比较。如下图在这里插入图片描述

解答开篇的那个问题

我们使用两个栈,X和Y,首次浏览的页面,依次压入栈X。当点击回退时,依次从X栈中取出数据,并依次放入Y栈。点击前进时,从Y栈中取出数据,并依次放入X栈。当X栈中没有数据时,就说明不能再回退了;当Y中没有数据时,就说明不能再前进了。

比如你依次浏览了a b c 三个页面,我们依次把 a b c 压入栈,这时两个栈是这个样子
在这里插入图片描述
浏览器通过后退按钮,回退到页面 a 时,我们把 c b 依次压入Y栈,这时两个栈是这个样子
在这里插入图片描述
这时候,你又通过前进按钮,又回到 b 页面,这时两个栈的数据是这个样子
在这里插入图片描述

这时,你由 b 页面打开新的页面 d,那么你就不能再通过后退回到 c 页面,Y栈数据要清空。这时两个栈是这个样子
https://blog.csdn.net/every__day/article/details/83753385

实现浏览器的前进后退功能

使用两个栈 X 和 Y,把首次浏览的页面依次压入栈 X,当点击后退按钮时,再依次从栈 X 中出栈,并将出栈的数据依次放入栈 Y。当点击前进按钮时,依次从栈 Y 中取出数据,放入栈 X 中。当栈 X 中没有数据时,那就说明没有页面可以继续后退浏览了。当栈 Y 中没有数据,那就说明没有页面可以点击前进按钮浏览了。

 

以上是关于数据结构之栈的主要内容,如果未能解决你的问题,请参考以下文章

数据结构之栈

数据结构之栈

数据结构之栈

数据结构之栈

python数据结构之栈

数据结构之栈