栈机制--模拟实现原理

最新推荐文章于 2022-05-13 19:13:45 发布
最新推荐文章于 2022-05-13 19:13:45 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 数据结构 C++学习总结 文章标签： 栈机制 栈 c++ 堆栈 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35244529/article/details/52399211
版权
栈机制--模拟实现原理

知识点简要介绍：
    栈：限定在表头进行插入和删除操作的线性表，引申为仓库
一种数据结构，只能在一端进行插入和删除操作，后进先出(LIFO)原则存储数据，push入栈，pop出栈

允许插入和删除的一段为栈顶(低地址的一端)，另一端为栈底


同队列一样没有数据类型的界限


算法：
push入栈：
    1.TOP++;
    2.若Top >= n,溢出
    3.pStack[Top] = x;入栈
pop出栈：
    1.若Top <= 0;向下溢出
    2.x = pStack[Top]；
    3.Top--;
    
模拟开始：
//--------------------------------------

//--int型栈机制实现---------------------


MyStack.h
 
<span style="font-size:14px;">#ifndef MYSTACK_H
#define MYSTACK_H
//---------------
class MyStack{
public:
    MyStack(int size);//初始化栈空间，设定容量
    ~MyStack();          //回收空间
    bool stackEmpty() const;//判空
    bool stackFull() const;//判满
    void clearStack();//清空
    int stackLength() const;//栈中元素个数
    bool push(char element);//入栈
    bool pop(char& element);//出栈
    void stackTraverse();//遍历
    
private:
    char* m_pStack;//栈空间指针
    int m_iSize;//容量
    int m_iTop;//个数
};

#endif MYSTACK_H</span>


MyStack.cpp
 
<span style="font-size:14px;">#include"MyStack.h"
#include<iostream>
using namespace std;
//-------------------------
 
MyStack::MyStack(int size){
    m_iSize = size;
    m_pStack = new char[m_iSize];
    m_iTop = 0;
}
MyStack::~MyStack(){
    delete []m_pStack;
}
bool MyStack::stackEmpty() const{
    if(0 == m_iTop)
        return true;
    else return false;
}
bool MyStack::stackFull() const{
    if(m_iTop == m_iSize)
        return true;
    else return false;
}
void MyStack::clearStack(){
    m_iTop = 0;
}
int MyStack::stackLength() const{
    return m_iTop;
}

bool MyStack::push(char element){
    if(stackFull()){
        return false;    
    }
    else{
        m_pStack[m_iTop] = element;
        m_iTop++;
        return true;
    }
}
bool MyStack::pop(char& element){
    if(stackEmpty()){
        return false;
    }
    m_iTop--;
    element = m_pStack[m_iTop];
    return true;
}
void MyStack::stackTraverse(){
    for(int i = m_iTop-1; i >= 0; i--){
        cout << m_pStack[i] ;//从栈顶到栈底遍历
    }
    cout << endl;
}</span>


demo.cpp
 
<span style="font-size:14px;">#include<iostream>
#include"MyStack.h"
using namespace std;
//------------------
int main(){
    MyStack *p = new MyStack(8);
    
    if(p->stackEmpty()){cout << "栈为空！" << endl;}    
    cout << "\n值压入栈中：" << endl;
    
    p->push('!');//栈底
    p->push('t');
    p->push('n');
    p->push('e');
    p->push('d');
    p->push('u');
    p->push('t');
    p->push('s');//栈顶
    
    p->stackTraverse();//遍历
    
    cout << "\n栈顶元素：" << endl;
    char e ='0';
    p->pop(e);
    cout << e << endl << endl;;
    cout << "清空：" << endl;
    p->clearStack();//清空
    
    if(p->stackEmpty()){cout << "栈为空！" << endl;}    
    
    delete p;
    p = NULL;
}</span>

//控制台运行结果：
栈为空！

值压入栈中：
student!

栈顶元素：
s

清空：
栈为空！

//-------------------------------------------------
//-------------------------------------------------
    ||                ||                ||
    ||                ||                ||
    ||                ||                ||
    ||                ||                ||
    \/               \/                \/
改造一下就可以成为针对类的栈机制
//-------------------------------------------------

//--Coordinate类类型栈机制实现---------------------


Coordinate.h
 
<span style="font-size:14px;">#ifndef COORDINATE_H
#define COORDINATE_H
//------------------
class Coordinate{
public:
    Coordinate(int x = 0, int y = 0);
    void printCoor();
private:
    int m_iX;
    int m_iY;    
};

#endif COORDINATE_H
</span>

Coordinate.cpp
 
<span style="font-size:14px;">#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate(int x, int y):m_iX(x), m_iY(y){}

void Coordinate::printCoor(){
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}
</span>

MyStack.h
 
<span style="font-size:14px;">#ifndef MYSTACK_H
#define MYSTACK_H
//---------------
#include"Coordinate.h"
//----------------
class MyStack{
public:
    MyStack(int size);//初始化栈空间，设定容量
    ~MyStack();          //回收空间
    bool stackEmpty() const;//判空
    bool stackFull() const;//判满
    void clearStack();//清空
    int stackLength() const;//栈中元素个数
    bool push(Coordinate element);//入栈
    bool pop(Coordinate& element);//出栈
    void stackTraverse();//遍历
    
private:
    Coordinate* m_pStack;//栈空间指针
    int m_iSize;//容量
    int m_iTop;//个数
};

#endif MYSTACK_H</span>


MyStack.cpp
 
<span style="font-size:14px;">#include"MyStack.h"
#include<iostream>
using namespace std;
//-------------------------
 
MyStack::MyStack(int size){
    m_iSize = size;
    m_pStack = new Coordinate[m_iSize];
    m_iTop = 0;
}
MyStack::~MyStack(){
    delete []m_pStack;
}
bool MyStack::stackEmpty() const{
    if(0 == m_iTop)
        return true;
    else return false;
}
bool MyStack::stackFull() const{
    if(m_iTop == m_iSize)
        return true;
    else return false;
}
void MyStack::clearStack(){
    m_iTop = 0;
}
int MyStack::stackLength() const{
    return m_iTop;
}

bool MyStack::push(Coordinate element){
    if(stackFull()){
        return false;    
    }
    else{
        m_pStack[m_iTop] = element;
        m_iTop++;
        return true;
    }
}
bool MyStack::pop(Coordinate& element){
    if(stackEmpty()){
        return false;
    }
    m_iTop--;
    element = m_pStack[m_iTop];
    return true;
}
void MyStack::stackTraverse(){
    for(int i = m_iTop-1; i >= 0; i--){
        m_pStack[i].printCoor() ;//从栈顶到栈底遍历
    }
    cout << endl;
}
</span>

demo.cpp
 
<span style="font-size:14px;">#include<iostream>
#include"MyStack.h"
using namespace std;
//------------------
int main(){
    MyStack *p = new MyStack(8);
    
    p->push(Coordinate(1,2));//栈底
    p->push(Coordinate(3,4));//栈顶
    
    p->stackTraverse();
    
    
    delete p;
    p = NULL;
}</span>

//控制台运行结果：
(3,4)
(1,2)
//-------------------------------------------------
//-------------------------------------------------
    ||                ||                ||
    ||                ||                ||
    ||                ||                ||
    ||                ||                ||
    \/               \/                \/
栈机制没有数据类型的没有局限性从下面的类模板demo便可窥探一二
升级成模板栈机制，针对任意类型:

MyStack.h
 
<span style="font-size:14px;">#ifndef MYSTACK_H
#define MYSTACK_H
//---------------
//#include"Coordinate.h"
#include<iostream>
using namespace std;
//----------------
// --栈机制类模板----
//--------------------
template <typename T>
class MyStack{
public:
    MyStack(int size);//初始化栈空间，设定容量
    ~MyStack();          //回收空间
    bool stackEmpty() const;//判空
    bool stackFull() const;//判满
    void clearStack();//清空
    int stackLength() const;//栈中元素个数
    bool push(T element);//入栈
    bool pop(T& element);//出栈
    void stackTraverse();//遍历
    
private:
    T* m_pStack;//栈空间指针
    int m_iSize;//容量
    int m_iTop;//个数
};


template <typename T>
MyStack<T>::MyStack(int size){
    m_iSize = size;
    m_pStack = new T[m_iSize];
    m_iTop = 0;
}
template <typename T>
MyStack<T>::~MyStack(){
    delete []m_pStack;
}
template <typename T>
bool MyStack<T>::stackEmpty() const{
    if(0 == m_iTop)
        return true;
    else return false;
}
template <typename T>
bool MyStack<T>::stackFull() const{
    if(m_iTop == m_iSize)
        return true;
    else return false;
}
template <typename T>
void MyStack<T>::clearStack(){
    m_iTop = 0;
}
template <typename T>
int MyStack<T>::stackLength() const{
    return m_iTop;
}
template <typename T>
bool MyStack<T>::push(T element){
    if(stackFull()){
        return false;    
    }
    else{
        m_pStack[m_iTop] = element;
        m_iTop++;
        return true;
    }
}
template <typename T>
bool MyStack<T>::pop(T& element){
    if(stackEmpty()){
        return false;
    }
    m_iTop--;
    element = m_pStack[m_iTop];
    return true;
}
template <typename T>
void MyStack<T>::stackTraverse(){
    for(int i = m_iTop-1; i >= 0; i--){
        cout << m_pStack[i];//从栈顶到栈底遍历
    }
    cout << endl;
}
#endif MYSTACK_H

</span>


Coordinate.h

<span style="font-size:14px;">#ifndef COORDINATE_H
#define COORDINATE_H
//------------------
#include<ostream>
using namespace std;
//------------------
class Coordinate{
    friend ostream& operator<<(ostream& o, Coordinate& coor);//"<<"操作符重载    
public:
    Coordinate(int x = 0, int y = 0);
    void printCoor();
private:
    int m_iX;
    int m_iY;    
};

#endif COORDINATE_H</span>


Coordinate.cpp
 
<span style="font-size:14px;">#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate(int x, int y):m_iX(x), m_iY(y){}

void Coordinate::printCoor(){
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

ostream& operator<<(ostream& o, Coordinate& coor){
    o << "(" << coor.m_iX << "," << coor.m_iY << ")" << endl;
    return o;
}</span>


demo.cpp
 
<span style="font-size:14px;">#include<iostream>
#include"MyStack.h"
using namespace std;
//------------------
#include"Coordinate.h"
//------------------
int main(){
    MyStack<Coordinate> *p = new MyStack<Coordinate>(2);
    
    p->push(Coordinate(1,2));//栈底
    p->push(Coordinate(3,4));//栈顶
    
    p->stackTraverse();
    
    MyStack<char> *q = new MyStack<char>(4);
    q->push('!');
    q->push('w');
    q->push('o');
    q->push('W');
    
    q->stackTraverse();
    
    delete p;
    delete q;
    q = NULL;
    p = NULL;
}</span>

//控制台运行结果：
(3,4)
(1,2)

Wow!

//-------------------------------------------------------

//-------------------------------------------------------

lu的博客
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈的模拟
tango_future的博客
12-07 383
栈的特点是“先进后出”。模拟的思路是：建立一个栈的结构体，里面有两个指针（PNODE ptop,PNODE pbutton),分别指向栈的最后一个进入的结点、第一个结点前的一个结点。程序如下图： /*程序功能：用链表模拟栈   对栈进行 初始化、压栈、判断空、遍历、出栈、清空操作 */ #include #include typedef struct node {
java 栈操作模拟实现
超烦豆先森
11-13 486
java 模拟实现栈的压入、弹出和peek操作
数据结构之栈的简单模拟
qq_54658577的博客
08-18 102
1、创建栈 private int maxSize; // 代表栈的最大容量是多少 private int[] stack; // 使用数组来存放数据 private int top = -1; // 栈顶指针的初始位置 class ArrayStack{ private int maxSize; // 栈的大小 private int[] stack; // 数据 private int top = -1; // 栈顶指针 /...
linux pstack 实现原理,Linux下pstack的实现
weixin_30054883的博客
05-14 211
Linux下有时候我们需要知道一个进程在做什么，比如说程序不正常的时候，他到底在干吗？最直接的方法就是打印出他所有线程的调用栈，这样我们从栈再配合程序代码就知道程序在干吗了。Linux下这个工具叫做pstack. 使用方法是# pstackUsage: pstack 当然这个被调查的程序需要有符号信息。 比较雷人的是 这个程序竟然是个shell脚本，核心实现是gdb的 thread apply a...
C8. C语言模拟入栈
LinuxTaoist的博客
09-14 135
记录一下，C语言上一道比较经典的题目： 实现一个基本的计算器来计算一个简单的字符串表达式的值。 字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。 示例 1: 输入: "3+2*2" 输出: 7 示例 2: 输入: " 3/2 " 输出: 1 示例 3: 输入: " 3+5 / 2 " 输出: 5 说明： 你可以假设所给定的表达式都是有效的。...
C++人工模拟栈实现方法
08-26
人工模拟栈实现方法可以帮助程序员更好地理解栈的工作原理和实现机制。 栈的定义 栈是一种后进先出的数据结构，即最新入栈的元素将被最先删除。栈的主要操作包括压栈、弹栈、读栈和判断栈空等。 人工模拟栈的实现...
rdt.zip_GBN协议_java实现gbn_rdt-_udp 模拟rdt_开发可靠的udp
09-21
通过这个"rdt.zip"项目，学习者可以了解到如何在实际编程中应用GBN协议，理解其工作原理，以及如何在Java环境下实现网络通信的可靠性。通过模拟UDP的不可靠特性，开发者可以更直观地看到GBN协议如何处理这些问题，这...
KW-2200模拟主站 模拟子站.rar
11-22
通过模拟主站和子站，开发者可以无需实际设备就能测试和验证规约实现的正确性，大大简化了开发和调试流程。 这个工具的一大亮点在于其详细的报文解析功能。报文是规约中数据传输的基本单元，包含控制信息和数据信息...
HITSZ-计算机网络实验-实现协议栈.zip
最新发布
06-01
【标题】"HITSZ-计算机网络实验-实现协议栈.zip"所涉及的知识点主要集中在计算机网络领域，尤其是网络协议栈的实现上。这通常是一个高级的计算机网络课程设计或实验项目，旨在让学生深入理解网络通信的基础原理和...
73334魔方栈源码-网站在线玩魔方源码-云魔方.rar
11-08
下面将详细介绍这款在线魔方应用的核心功能、实现原理和技术要点。 首先，魔方模拟的核心在于算法的实现。4阶魔方相对于传统的3阶魔方，其复杂度更高，需要处理更多的面和旋转组合。源码中可能采用了经典的Cube ...
栈实现队列和队列实现栈原理
Islotus
05-17 626
两个栈实现一个队列 http://blog.csdn.net/jiange_zh/article/details/50583370 两个队列实现栈 http://www.cnblogs.com/kaituorensheng/archive/2013/03/02/2939690.html
堆栈原理
qq_45521281的博客
04-07 3213
我们常常说堆栈堆栈，但是堆和栈其实是完全不同的两个概念。栈其实完全是为了函数调用而设计的，那么函数调用如何通过栈实现的呢？不同函数调用方式，栈在行为上有什么区别呢？ 系统栈的工作原理： 1、内存的不同用途: 如果您关注网络安全问题，那么一定听过缓冲区溢出这个术语。简单说来：**缓冲区溢出就是在大缓冲区中的数据向小缓冲区复制的过程中，由于没有注意小缓冲区的边界，“撑爆”了较小的缓冲区，从而冲掉了和...
栈操作
杨林峰的笔记
08-21 194
/* 对栈实现初始化，插入栈顶元素，删除栈顶元素，遍历栈，清空栈等基本操作 */ #include <stdio.h> #include <malloc.h> #include <stdlib.h>#define true 1 #define false 0 typedef struct Node { int data; struct Node *pNext; }NODE,
数据结构与算法——栈的实现及模拟
m0_62179366的博客
05-13 525
目录 一、栈的原理 二、栈的实现 1.栈的定义 2.栈的初始化 3.入栈 4.出栈 5.获取栈顶元素 6.栈的大小 7.判断栈是否为空 8.栈的销毁 一、栈的原理 堆栈（英语：stack）又称为栈或堆叠，是计算机科学中的一种抽象资料类型，只允许在有序的线性资料集合的一端（称为堆栈顶端，英语：top）进行加入数据（英语：push）和移除数据（英语：pop）的运算。因而按照后进先出（LIFO, Last In First Out）的原理运作。 常与另一种有序的线性资料集合
内存空间分配 堆、栈、静态存储区的区别
huanglaisheng123的专栏
01-07 3445
堆和栈的区别 一、预备知识—程序的内存分配 一个由c/C++编译的程序占用的内存分为以下几个部分 1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 3、全局区（静态
CPU提供的栈机制
guicaifjz的博客
07-12 887
CPU提供的栈机制栈顶超界问题 现今的CPU中都有栈的设计，8086CPU也不例外，8086CPU提供入栈和出栈指令，最基本的两个是PUSH（入栈）和POP（出栈），比如，push ax表示将寄存器ax中的数据送入栈中，pop ax表示从栈顶取出数据送入ax,8086CPU的r入栈和出栈操作都是以字为单位进行的。 我们可以将10000H—10000FH这段内存当作栈来使用 注意，字型数据用两个单元存放，高地址单元存放高8位，低地址单元存放低8位，看到所描述的push和pop指令，是否有一些疑惑，总结下来，
队列的基本原理及实现
热门推荐
BUPT-WT的博客
08-15 1万+
基本原理： 队列是有序集合，新添加的一端为队尾，另一端为队头，当一个元素从队尾进入队列时，一直向队首移动，直到它成为移除的元素为止。这种排序是先进先出FIFO，生活中常见的例子就是去学校食堂打饭，人多时候需要排队，排队在前面的同学先打饭，新来的同学在后面排队，知道前面同学都打完饭，才轮到它 代码实现： 1、小游戏：小时候大家玩过一个游戏，大家围成一个圈，从某一个人开始报数，知道某个人报数...
7-8 堆栈模拟队列 (25 分)
韩旭051的博客
07-31 3983
暑假字符串专题HBU程序设计训练营总结
栈的基本原理及实现
Ktivens的博客
11-18 1817
栈的定义 栈（stack）又称堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称进栈、入栈或者是压栈，它是把新元素放到栈顶元素的上面，使之称为新的栈顶元素；从一个栈删除一个元素又称出栈或者是退栈，它是把栈顶元素删除掉，使其相邻的元素称为新的栈顶元素。当栈中没有任何元素时称为空栈。 由于栈这种数据结构只允许在一端进行操作...
递归调用与栈：用栈实现递归计算斐波那契数列
"该资源主要介绍了如何利用栈来实现递归调用，特别是在数据结构中的栈和堆类的应用。通过一个具体的例子展示了递归计算f(n)=n*f(n-1)的过程，其中f(n)表示n的阶乘。在描述中，通过一系列的步骤展示了递归调用过程中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值