数据结构(2) -- 堆栈

1、顺序存储



//栈的顺序存储实现
//Stack.h
#ifndef STACK_H_
#define STACK_H_
#define ElementType int
#define MaxSize 100
typedef struct _Node
{
    ElementType data[MaxSize];
    int top;
}Node;
class Stack
{
private:
    Node data;
public:
    Stack();
    ~Stack();
    int IsFull();
    void Push(ElementType item);
    int IsEmpty();
    ElementType Pop();
};
#endif

//Stack.cpp
#include "Stack.h"
#include <iostream>

Stack::Stack()
{
    data.top = -1;
}
Stack::~Stack()
{
}
int Stack::IsFull()
{
    if (data.top == (MaxSize - 1))
        return 1;
    else
        return 0;
}
void Stack::Push(ElementType item)
{
    if (IsFull() == 1)
    {
        std::cout << "栈溢出" << std::endl;
        return;
    }
    data.data[++(data.top)] = item;
}

int Stack::IsEmpty()
{
    if (data.top == -1)
        return 1;
    else
        return 0;
}

ElementType Stack::Pop()
{
    if (IsEmpty())
        std::cout << "栈已空" << std::endl;
    return data.data[(data.top)--];
}

 

2、链式存储

//栈的链式存储实现
//PStack.h
#ifndef PSTACK_H_
#define PSTACK_H_
#define ElementType int
#define MaxSize 100
typedef struct _PNode
{
    ElementType data;
    _PNode* next;
}PNode;

class PStack
{
private:
    PNode *top;
public:
    PStack();
    ~PStack();
    int IsFull();
    void Push(ElementType item);
    int IsEmpty();
    ElementType Pop();
};
#endif

//PStack.cpp
#include "PStack.h"
#include <iostream>

PStack::PStack()
{
    top = new PNode();
    top->next = NULL;
}
PStack::~PStack()
{
    delete top;
}

void PStack::Push(ElementType item)
{
    PNode* s = new PNode();
    s->data = item;
    s->next = top;
    top = s;
}

int PStack::IsEmpty()
{
    if (top == NULL)
        return 1;
    else
        return 0;
}

ElementType PStack::Pop()
{
    if (IsEmpty())
        std::cout << "栈已空" << std::endl;
    PNode *s;
    s = top;
    ElementType e = s->data;
    top = top->next;
    delete s;
    return e;
}

3、测试样例

#include <iostream>
#include "PStack.h"
using namespace std;

int main()
{
    PStack st;
    st.Push(5);
    st.Push(6);
    st.Push(2);
    int a = st.Pop();
    int b = st.Pop();
    cout << "a , b" << a << " " << b << endl;
    st.Push(b / a);
    a = st.Pop();
    b = st.Pop();
    cout << "a , b" << a << " " << b << endl;
    st.Push(b + a);
    st.Push(3);
    st.Push(4);
    a = st.Pop();
    b = st.Pop();
    cout << "a , b" << a << " " << b << endl;
    st.Push(b * a);
    a = st.Pop();
    b = st.Pop();
    st.Push(b - a);
    cout << "a , b" << a << " " << b << endl;
    cout << "根据后缀表达是计算5+6/2-3*4的值为:" << st.Pop() << endl;

    system("pause");
    return 0;
}
时间: 2024-11-07 16:22:17

数据结构(2) -- 堆栈的相关文章

数据结构之堆栈C++版

/* 堆栈本身就是一种线性数据结构,说白了他与容器线性表是一种数据类型,不要认为他多高大上. 实时上他还没有线性表复杂,下面简单的实现一下堆栈. 事实上整个核心操作都是在操作指向堆栈的顶部元素的指针 */ template <class T>class BaseStack { //出栈 virtual bool pop()  = 0; //进栈 virtual bool push(T x) = 0; //获取栈顶元素 virtual T top() const = 0; //清空堆栈 virt

数据结构--------(堆栈 和 队列)

1.栈 1.定义:只允许从一端插入或删除的线性表.逻辑结构:元素相邻:物理存储结构:顺序栈 和 链式栈:运算:只能从一端操作,受限的线性表 2.栈的基本操作: InintStack.StackEmpty.pop .push .peek(GetTop).ClearStack(6个) 3.顺序栈:利用一组连续地址存储单元存储自栈底到栈顶的元素,同时附有一个指针指向当前栈顶的位置 3.1  顺序栈操作: 初始时 S.top = -1;栈顶元素值:S.data[S.top] 进栈操作:首先判断是否栈满,

Mooc数据结构-02堆栈和队列

1 堆栈 1.1 堆栈的概念 表达式求值问题 表达式 = 运算数 + 运算符号 不同的运算符号优先级不一样 一般地, 运算是见到运算符号进行运算, 但是在一般的表达式中, 运算符号前面的值我们能够知道, 但是后面的值不一定是当前运算符运算的值, 因此这个运算增加了很大的困难 中缀表达式: 运算符位于两个运算数之间 后缀表达式: 运算符位于两个运算数之后 前缀表达式, 前中后缀表达式的转换 后缀表达式的求值顺序: 从左往右依次扫描, 遇到运算符就运算, 运算的运算数是就近就近就近的两个运算数 62

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

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

数据结构之堆栈

1 # include <stdio.h> 2 # include <malloc.h> 3 # include <stdlib.h> 4 5 typedef struct Node 6 { 7 int data; 8 struct Node * pNext; 9 }NODE, * PNODE; 10 11 typedef struct Stack 12 { 13 PNODE pTop; 14 PNODE pBottom; 15 }STACK, * PSTACK; //

数据结构之堆栈java版

import java.lang.reflect.Array; /* 具体原理在c++版已经说的很清楚,这里不再赘述, 就提一点:java的泛型具有边界效应,一旦离开作用域立马被替换为object类型,在new泛型数组需要借助反射. */ interface BaseStack<T>{ boolean push(T x); boolean pop(); void clear(); T top();}public class JBStack<T> implements BaseSta

数据结构之堆栈(数组实现)

/***************************** Date   : 2015-07-20* Description: stack.h*****************************/#ifndef _STACK_H#define _STACK_H template<class T>class Stack{public: Stack(int MaxStackSize = 10); ~Stack() {delete [] stack;} bool IsEmpty() cons

使用LinkedList模拟一个堆栈或者队列数据结构

使用LinkedList模拟一个堆栈或者队列数据结构. 堆栈:先进后出  如同一个杯子. 队列:先进先出  如同一个水管. import java.util.LinkedList; public class DuiLie { private LinkedList link; public DuiLie() { link = new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object

java集合 collection-list-LinkedList 模拟一个堆栈或者队列数据结构。

/* 使用LinkedList模拟一个堆栈或者队列数据结构. 堆栈:先进后出 如同一个杯子. 队列:先进先出 First in First out FIFO 如同一个水管. */ import java.util.*; class DuiLie { private LinkedList link; DuiLie() { link = new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public O