数据结构之栈

栈

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

用数组实现一个顺序栈

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 中没有数据，那就说明没有页面可以点击前进按钮浏览了。