堆栈之链表实现

#include<iostream>
using namespace std;
struct LinktackNode
{
     LinktackNode* lastIn;
     int value;
};
struct LinkStack
{
     LinktackNode* top;
     LinktackNode* bottom;
     bool isEmpty;
     int cnt;
};
LinkStack* createLinkStack()
{
     LinkStack* st = (LinkStack*)malloc(sizeof(LinkStack));
     LinktackNode* temp = (LinktackNode*)malloc(sizeof(LinktackNode));
     temp->lastIn=NULL;
     st->top=temp;
     st->bottom=temp;
     st->cnt=0;
     st->isEmpty=true;
     return  st;
}

bool isEmpty(LinkStack* st)
{
    return st->isEmpty;
}

void push(LinkStack* st,int value)
{
    LinktackNode* inNode = (LinktackNode*)malloc(sizeof(LinktackNode));
    inNode->lastIn=st->top;
    inNode->value=value;
    st->top=inNode;
    st->isEmpty =((++st->cnt)==0);
}
bool pop(LinkStack* st,int* ans)
{
    if(!st->isEmpty)
    {
        *ans=st->top->value;
        st->top=st->top->lastIn;
        st->isEmpty =((--st->cnt)==0);
        return 1;
    }
    return 0;
}
bool top(LinkStack* st,int* ans)
{
    if(!st->isEmpty)
    {
        *ans=st->top->value;
        return 1;
    }
    return 0;
}
void clearStack(LinkStack* st)
{
    int x;
    while(!st->isEmpty)
    {
        pop(st,&x);
        cout<<x<<" ";
    }
    cout<<endl;
}

void outPut(LinkStack* st)
{
    LinktackNode* p = st->top;
    while(p!=st->bottom)
    {
        cout<<p->value<<" ";
        p=p->lastIn;
    }
    cout<<endl;
}

void main()
{
    int len=10;
    LinkStack* st = createLinkStack();
    int v;
    for(int i=0;i<len;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         push(st,v);

    }
    cout<<endl;
    outPut(st);
    clearStack(st);

    for(int i=0;i<len;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         push(st,v);

    }
    cout<<endl;
    outPut(st);

    pop(st,&v);
    cout<<v<<endl;
    outPut(st);

    top(st,&v);
    cout<<v<<endl;
    outPut(st);

    pop(st,&v);
    cout<<v<<endl;
    outPut(st);

    pop(st,&v);
    cout<<v<<endl;
    outPut(st);

    for(int i=0;i<5;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         push(st,v);

    }
    cout<<endl;
    outPut(st);
    if(!top(st,&v))
        cout<<"fail"<<endl;
    else outPut(st);

    clearStack(st);

    if(!top(st,&v))
        cout<<"fail"<<endl;
    else outPut(st);

    if(!top(st,&v))
        cout<<"fail"<<endl;
    else outPut(st);

    cin>>len;
}
时间: 2024-08-24 07:13:17

堆栈之链表实现的相关文章

C语言---堆栈(链表实现)

一:堆栈的引入 堆栈可以比较好的解决后缀表达式的问题. 拓展一: 中缀表达式:运算符号位于两个运算数之间:例如a + b * c - d/c; 后缀表达式:运算符号位于两个运算数之后:例如ab * + de -; 这个时候就需要一种存储办法,能够顺序存储运算数,并在需要的时候倒序输出,这就需要堆栈. 二.堆栈的概念 堆栈是一个特定的存储区或寄存器,它的一端是固定的,另一端是浮动的 .对这个存储区存入的数据,是一种特殊的数据结构.所有的数据存入或取出,只能在浮动的一端(称栈顶)进行,严格按照“先进

堆栈二链表实现堆栈

用链表来实现堆栈的优点是随时可以动态改变链表的长度,能够有效利用内存资源,缺点就是设计的算法比较复杂 class Node: #堆栈链结节点的声明 def __init__(self): self.data=0 #堆栈数据的声明 self.next=None #堆栈中用来指向下一个节点 top=None 判断链表是否为空 def isEmpty(): global top if(top==None): return 1 else: return 0 将指定的数据压入堆栈 #将指定的数据压入堆栈

c语言基础----堆栈队列链表

堆 堆则是一种经过排序的树形数据结构,常用来实现优先队列,他的特点在于形成某种优先的结构.在计算机经常用到,比如优先队列,或者是优先进程管理. 堆(也叫二叉堆)的性质: 1.任何一个节点,都不大于他的父亲节点. 2.必须是一颗完全二叉树 栈 在数据结构中,栈是一种可以实现“先进后出”(或者称为“后进先出”)的存储结构.假设给定栈 S=(a0,a1,…,an-1),则称 a0 为栈底,an-1 为栈顶.进栈则按照 a0,a1,…,an-1 的顺序进行进栈:而出栈的顺序则需要反过来,按照“后存放的先

下压堆栈(链表实现)

import java.util.Iterator; public class Stack<Item> { private Node first; //栈顶 private int N; //元素数量 private class Node { //定义节点的嵌套类 Item item; Node next; } public boolean isEmpty() { return first == null; } // 或: N == 0 public int size() { return N

数据结构学习---堆栈的动态数组实现及链表实现

堆栈 [链表实现堆栈] 优点:可以无限增添元素,只要内存足够, 缺点:内存中存储位置不连续 typedef int ElementType; //只能向头部插入元素,因为如果在尾部插入,删除时,找不到上一个节点/ //因为链表是单向的 //所以 push pop 操作在头结点进行 class Stack{ public: Stack(){ S=(Stack*)malloc(sizeof(Stack)); //建立一个不存数据的头结点,方便增删节点 S->Next=NULL; sz=0; } bo

Java版——堆栈

1.堆栈是一种线性数据结构,先进后出. 2.应用一:在程序中匹配分隔符(在 java程序中读取一个字符,如果它是左分隔符就将他压入堆栈.如果它是右分隔符,就将他和栈中弹出的一个分隔符相比较,如果匹配,就继续处理,否则就发出了一个错误信号,停止处理) 应用二:执行一些非常大的数字的加法. 应用三:java中的jvm是基于堆栈的. 3.堆栈的数组链表实现 1 package sequence_stack; 2 3 public class sq_Stack { 4 private java.util

堆栈应用(二):汉诺塔

1.问题描述 汉诺塔( Towers of Hanoi)问题来自一个古老的传说:在世界刚被创建的时候有一座钻石宝塔(塔1 ),其上有6 4个金碟(如图 5 - 4所示).所有碟子按从大到小的次序从塔底堆放至塔顶.紧挨着这座塔有另外两个钻石宝塔(塔 2和塔3).从世界创始之日起,婆罗门的牧师们就一直在试图把塔 1 上的碟子移动到塔 2上去,其间借助于塔 3的帮助.由于碟子非常重,因此,每次只能移动一个碟子.另外,任何时候都不能把一个碟子放在比它小的碟子上面.按照这个传说,当牧师们完成他们的任务之后

堆栈应用(五):离线等价类

1.问题描述 例子:假定 n= 1 4, R= { ( 1 , 11 ), ( 7 , 11 ), ( 2 , 1 2 ), ( 1 2 , 8 ), ( 11 , 1 2 ), ( 3 , 1 3 ), ( 4 , 1 3 ), ( 1 3 , 1 4 ),( 1 4 , 9 ), ( 5 , 1 4 ), ( 6 , 1 0 ) }.我们忽略了所有形如 ( a , a )的关系,因为按照反身属性,这些关系是隐含的.同样也忽略了所有的对称关系.比如 ( 1 , 11) € R,按对称属性应有

堆栈应用(六):迷宫搜索

1.问题描述 迷宫( m a z e)是一个矩形区域,它有一个入口和一个出口.在迷宫的内部包含不能穿越的墙或障碍.在图 5 - 8所示的迷宫中,障碍物沿着行和列放置,它们与迷宫的矩形边界平行.迷宫的入口在左上角,出口在右下角.图5-8 迷宫假定用 n× m的矩阵来描述迷宫,位置 ( 1 , 1 )表示入口, (n,m) 表示出口, n和m分别代表迷宫的行数和列数.迷宫中的每个位置都可用其行号和列号来指定.在矩阵中,当且仅当在位置(i,j)处有一个障碍时其值为 1 ,否则其值为 0.图 5 - 9