数据结构-详细分析“栈（Stack）”

最新推荐文章于 2024-06-13 15:33:28 发布
最新推荐文章于 2024-06-13 15:33:28 发布
阅读量4.6k 收藏 13
点赞数 6
分类专栏： 算法 | 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cody_Ren/article/details/80461874
版权

详细的在这篇文章里：https://7vs10.com/article/78

一、什么是栈？

栈是一种数据结构，元素的进出方式类似于“子弹进出子弹夹”。

二、栈的实现（C++、VS2017）

1、新建三个文件，分别为MyStack.h、MyStack.cpp、StackDemo.cpp,代码分别如下，注释详细。

MyStack.h

#define MYSTACK_H
 
class MyStack {
public:
    MyStack(int size); //分配内存，初始化栈空间，设定栈容量，栈顶
    ~MyStack();     //回收栈空间内存
    bool stackEmpty(); //判定栈是否为空，为空的话返回true,非空返回false
    bool stackFull();  //判定栈是否已满，为满返回true，不满返回false
    void clearStack(); //清空栈
    int stackLength(); //已有元素个数
    bool push(char elem); //元素入栈函数，栈顶上升
    bool pop(char &elem); //元素出栈，栈顶下降
    void stackTraverse(bool isFromButtom);    //遍历栈中所有元素
 
private:
    char *m_pBuffer;   //栈空间指针
    int m_iSize;   //栈容量
    int m_iTop;        //栈顶，也代表了栈中的元素个数
};

MyStack.cpp

//具体实现栈类
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;
 
// 实现栈的构造函数
MyStack::MyStack(int size) { 
     
    m_iSize = size;   //首先将 栈的size 赋值给该类的数据成员
    m_pBuffer = new char[size];  //有了变量之后就可以申请内存了，用一个指针来指向这段内存，内存的数据类型为char
    m_iTop = 0;   //初始化栈顶,栈顶为零也就是栈为空了
}
 
// 实现栈的析构函数，用来释放回收栈所占的内存空间
MyStack::~MyStack() {
     
    delete []m_pBuffer;    // 因为是释放一个内存的数组，所以加[]
}
 
// 实现栈的判空函数
bool MyStack::stackEmpty(){
     
    if (0 == m_iTop) {  //很简单，即判断下栈顶iTop是否为0
        return true;
    }
    return false;
}
 
// 实现栈的判满函数
bool MyStack::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}
 
// 清空栈函数实现,原理很简单，就是将栈顶设为0，这样的话，栈其他的位置无论是啥都没用了，下次再赋新值的时候就会覆盖
void MyStack::clearStack() {
    m_iTop = 0;
}
 
// 获取栈当中已有的元素个数
int MyStack::stackLength() {
    return m_iTop; // 很简单，栈顶的数字即元素个数
}
 
// 实现 元素入栈、栈顶上升 函数
bool MyStack::push(char elem) { // 将elem入栈
    if (stackFull()) { // 如果栈已经满了
        return false; // 入栈失败
    }
    m_pBuffer[m_iTop] = elem; // 元素入栈
    m_iTop++; // 栈顶上升
 
    return true;
}
 
// 元素出栈，栈顶下降
bool MyStack::pop(char &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出栈一定要先将栈顶降低，以指向最高的一个数值，不然栈顶指向的一直是个空的东西
    elem = m_pBuffer[m_iTop];// 将当前的栈顶元素给elem不就行了吗
    return true;
}
 
// 遍历整个栈
void MyStack::stackTraverse(bool isFromButtom) { // 加一个判断从顶还是底开始遍历的开关
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 栈底到栈顶做遍历
            cout << m_pBuffer[i] << ",";
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 栈顶到栈底遍历
            cout << m_pBuffer[i] << ",";
        }
    }
 
}

StackDemo.cpp

//这是运行文件
//栈类具体实现文件另建
 
#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;
 
 
int main()
{
    MyStack *pStack = new MyStack(5);   // 首先实例化MyStack类的一个对象
 
    pStack->push('h'); // 底
    pStack->push('e');
    pStack->push('l');
    pStack->push('l');
    pStack->push('o'); // 顶 
 
    pStack->stackTraverse(true); // true就是从底到顶遍历
 
    cout << endl;
 
    char elem = 0;
    pStack->pop(elem); // 弹出顶
    cout << elem << endl;
 
    pStack->clearStack();
 
    cout << pStack->stackLength() << endl; // 输出栈元素的个数
 
    if (pStack->stackEmpty()) {// 通过对象这个指针来判栈是否为空
        cout << "栈为空" << endl;
    }
 
    if (pStack->stackFull()) {
        cout << "栈为满" << endl;
    }
 
    delete pStack; // 用完之后销毁指针
    pStack = NULL;    // 再将指针指向 NULL
 
    system("pause");
    return 0;
}

运行结果：
这里写图片描述

2、上面就已经实现了一个简单的栈，可以对栈进行简单的元素push、pop，但是只能对char类型的元素，然而栈可以对所有类型的元素进行操作，因此下面进行改进：

①我们会定义一个 Coordinate 坐标类；

②改造栈类，使其可以适用于坐标类。

可以灵活掌握栈机制，理解抽象数据类型在栈中的应用。

我们另外建了俩文件，现在一共五个源文件：MyStack.h、MyStack.cpp、StackDemo.cpp、Coordinate.cpp、Coordinate.h，其源代码分别如下：

MyStack.h

#define MYSTACK_H
 
#include"Coordinate.h"
 
class MyStack {
public:
    MyStack(int size); //分配内存，初始化栈空间，设定栈容量，栈顶
    ~MyStack();     //回收栈空间内存
    bool stackEmpty(); //判定栈是否为空，为空的话返回true,非空返回false
    bool stackFull();  //判定栈是否已满，为满返回true，不满返回false
    void clearStack(); //清空栈
    int stackLength(); //已有元素个数
    bool push(Coordinate elem);   //元素入栈函数，栈顶上升
    bool pop(Coordinate &elem);   //元素出栈，栈顶下降
    void stackTraverse(bool isFromButtom);    //遍历栈中所有元素
 
private:
    Coordinate *m_pBuffer; //栈空间指针
    int m_iSize;   //栈容量
    int m_iTop;        //栈顶，也代表了栈中的元素个数
};

MyStack.cpp

//具体实现栈类
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;
 
// 实现栈的构造函数
MyStack::MyStack(int size) { 
     
    m_iSize = size;   //首先将 栈的size 赋值给该类的数据成员
    m_pBuffer = new Coordinate[size];    //有了变量之后就可以申请内存了，用一个指针来指向这段内存，内存的数据类型为char
    m_iTop = 0;   //初始化栈顶,栈顶为零也就是栈为空了
}
 
// 实现栈的析构函数，用来释放回收栈所占的内存空间
MyStack::~MyStack() {
     
    delete []m_pBuffer;    // 因为是释放一个内存的数组，所以加[]
}
 
// 实现栈的判空函数
bool MyStack::stackEmpty(){
     
    if (0 == m_iTop) {  //很简单，即判断下栈顶iTop是否为0
        return true;
    }
    return false;
}
 
// 实现栈的判满函数
bool MyStack::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}
 
// 清空栈函数实现,原理很简单，就是将栈顶设为0，这样的话，栈其他的位置无论是啥都没用了，下次再赋新值的时候就会覆盖
void MyStack::clearStack() {
    m_iTop = 0;
}
 
// 获取栈当中已有的元素个数
int MyStack::stackLength() {
    return m_iTop; // 很简单，栈顶的数字即元素个数
}
 
// 实现 元素入栈、栈顶上升 函数
bool MyStack::push(Coordinate elem) { // 将elem入栈
    if (stackFull()) { // 如果栈已经满了
        return false; // 入栈失败
    }
    m_pBuffer[m_iTop] = elem; // 元素入栈
    m_iTop++; // 栈顶上升
 
    return true;
}
 
// 元素出栈，栈顶下降
bool MyStack::pop(Coordinate &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出栈一定要先将栈顶降低，以指向最高的一个数值，不然栈顶指向的一直是个空的东西
    elem = m_pBuffer[m_iTop];// 将当前的栈顶元素给elem不就行了吗
    return true;
}
 
// 遍历整个栈
void MyStack::stackTraverse(bool isFromButtom) { // 加一个判断从顶还是底开始遍历的开关
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 栈底到栈顶做遍历
            //cout << m_pBuffer[i] << ","; // 因为<<胜任不了输出复杂数据类型，所以不用<<输出
            m_pBuffer[i].printCoordinate();
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 栈顶到栈底遍历
            //cout << m_pBuffer[i] << ",";
            m_pBuffer[i].printCoordinate();
 
        }
    }
 
}

StackDemo.cpp

//这是运行文件
//栈类具体实现文件另建
 
#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;
 
 
int main()
{
    MyStack *pStack = new MyStack(5);   // 首先实例化MyStack类的一个对象
 
    pStack->push(Coordinate(1,2)); // 底
    pStack->push(Coordinate(3,4));
 
    pStack->stackTraverse(true); // true就是从底到顶遍历
 
    cout << endl;
 
 
    pStack->clearStack();
 
    cout << pStack->stackLength() << endl; // 输出栈元素的个数
 
    if (pStack->stackEmpty()) {// 通过对象这个指针来判栈是否为空
        cout << "栈为空" << endl;
    }
 
    if (pStack->stackFull()) {
        cout << "栈为满" << endl;
    }
 
    delete pStack; // 用完之后销毁指针
    pStack = NULL;    // 再将指针指向 NULL
 
    system("pause");
    return 0;
}

Coordinate.cpp

#include"stdafx.h"
#include"Coordinate.h"
#include<iostream>
using namespace std;
 
Coordinate::Coordinate(int x, int y) {
    m_iX = x;
    m_iY = y;
}
 
void Coordinate::printCoordinate() {
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

Coordinate.h

#define COORDINATE_H
 
class Coordinate {
public:
    Coordinate(int x=0,int y=0); // 默认构造函数，很重要
    void printCoordinate();
 
private:
    int m_iX;
    int m_iY;
};

运行结果：
这里写图片描述

3、尽管已经实现了可以使用栈存储输出Coordinate坐标类，但我们的目标是使其适用于任何数据类型，因此我们要将普通栈改造为类模板栈。只需要修改几个地方，源代码文件还是五个：MyStack.h、MyStack.cpp、StackDemo.cpp、Coordinate.cpp、Coordinate.h，分别如下：

MyStack.h

#define MYSTACK_H
 
template<typename T> // 将普通栈改造为类模板栈
class MyStack {
public:
    MyStack(int size); //分配内存，初始化栈空间，设定栈容量，栈顶
    ~MyStack();     //回收栈空间内存
    bool stackEmpty(); //判定栈是否为空，为空的话返回true,非空返回false
    bool stackFull();  //判定栈是否已满，为满返回true，不满返回false
    void clearStack(); //清空栈
    int stackLength(); //已有元素个数
    bool push(T elem);    //元素入栈函数，栈顶上升
    bool pop(T &elem);    //元素出栈，栈顶下降
    void stackTraverse(bool isFromButtom);    //遍历栈中所有元素
 
private:
    T *m_pBuffer;  //栈空间指针
    int m_iSize;   //栈容量
    int m_iTop;        //栈顶，也代表了栈中的元素个数
};
 
template<typename T>
// 实现栈的构造函数
MyStack<T>::MyStack(int size) {
 
    m_iSize = size;   //首先将 栈的size 赋值给该类的数据成员
    m_pBuffer = new T[size]; //有了变量之后就可以申请内存了，用一个指针来指向这段内存，内存的数据类型为char
    m_iTop = 0;   //初始化栈顶,栈顶为零也就是栈为空了
}
 
template<typename T>
// 实现栈的析构函数，用来释放回收栈所占的内存空间
MyStack<T>::~MyStack() {
 
    delete[]m_pBuffer;  // 因为是释放一个内存的数组，所以加[]
}
 
template<typename T>
// 实现栈的判空函数
bool MyStack<T>::stackEmpty() {
 
    if (0 == m_iTop) {  //很简单，即判断下栈顶iTop是否为0
        return true;
    }
    return false;
}
 
 
template<typename T>
// 实现栈的判满函数
bool MyStack<T>::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}
 
 
template<typename T>
// 清空栈函数实现,原理很简单，就是将栈顶设为0，这样的话，栈其他的位置无论是啥都没用了，下次再赋新值的时候就会覆盖
void MyStack<T>::clearStack() {
    m_iTop = 0;
}
 
 
template<typename T>
// 获取栈当中已有的元素个数
int MyStack<T>::stackLength() {
    return m_iTop; // 很简单，栈顶的数字即元素个数
}
 
 
template<typename T>
// 实现 元素入栈、栈顶上升 函数
bool MyStack<T>::push(T elem) { // 将elem入栈
    if (stackFull()) { // 如果栈已经满了
        return false; // 入栈失败
    }
    m_pBuffer[m_iTop] = elem; // 元素入栈
    m_iTop++; // 栈顶上升
 
    return true;
}
 
 
template<typename T>
// 元素出栈，栈顶下降
bool MyStack<T>::pop(T &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出栈一定要先将栈顶降低，以指向最高的一个数值，不然栈顶指向的一直是个空的东西
    elem = m_pBuffer[m_iTop];// 将当前的栈顶元素给elem不就行了吗
    return true;
}
 
 
template<typename T>
// 遍历整个栈
void MyStack<T>::stackTraverse(bool isFromButtom) { // 加一个判断从顶还是底开始遍历的开关
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 栈底到栈顶做遍历
            cout << m_pBuffer[i]; // 因为<<胜任不了输出复杂数据类型，所以不用<<输出
                                  //m_pBuffer[i].printCoordinate();
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 栈顶到栈底遍历
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }
 
}

MyStack.cpp

//具体实现栈类
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;

StackDemo.cpp

//这是运行文件
//栈类具体实现文件另建
 
#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"
 
using namespace std;
 
 
int main()
{
    //现在MyStack<>这个尖括号里的数据类型你就可以随便使用了，比如在这里用了Coordinate类型的
    MyStack<Coordinate> *pStack = new MyStack<Coordinate>(5);   // 首先实例化MyStack类的一个对象
 
    pStack->push(Coordinate(1,2)); // 底
    pStack->push(Coordinate(3,4));
 
    pStack->stackTraverse(true); // true就是从底到顶遍历
 
    cout << endl;
 
 
    pStack->clearStack();
 
    cout << pStack->stackLength() << endl; // 输出栈元素的个数
 
    if (pStack->stackEmpty()) {// 通过对象这个指针来判栈是否为空
        cout << "栈为空" << endl;
    }
 
    if (pStack->stackFull()) {
        cout << "栈为满" << endl;
    }
 
    delete pStack; // 用完之后销毁指针
    pStack = NULL;    // 再将指针指向 NULL
 
    system("pause");
    return 0;
}

Coordinate.cpp

#include"stdafx.h"
#include"Coordinate.h"
#include<iostream>
using namespace std;
 
Coordinate::Coordinate(int x, int y) {
    m_iX = x;
    m_iY = y;
}
 
void Coordinate::printCoordinate() {
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}
 
ostream &operator<<(ostream &out, Coordinate &coor) {
    out << "(" << coor.m_iX << "," << coor.m_iY << ")" <<endl;
    return out;
}

Coordinate.h

#define COORDINATE_H
 
#include<ostream>
using namespace std;
 
class Coordinate {
 
    friend ostream &operator<<(ostream &out, Coordinate &coor);
public:
    Coordinate(int x=0,int y=0); // 默认构造函数，很重要
    void printCoordinate();
 
private:
    int m_iX;
    int m_iY;
};

这样一来，你想要使用什么数据类型都可以了，只要在StackDemo.cpp文件里将MyStack<>简括里的数据类型进行相应的修改即可：

比如

这里写图片描述
这里写图片描述

三、接下来就是俩用栈来操作的小例子

1、栈应用–进制转换

描述：输入任意的十进制正整数N，分别输出该整数N的二进制、八进制、十六进制表示

公式：N = （N div d）* d + N mod d (div表示整除，mod表示求余)

(1348)(十进制) = (2504)(八进制) = (544)(十六进制) = (10101000100)(二进制)

以后只用 StackDemo.cpp 和 MyStack.h 俩文件就OK了，具体代码如下：

MyStack.h不变，只修改StackDemo.cpp：

//这是运行文件
//栈类具体实现文件另建
 
#include "stdafx.h"
 
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"
 
using namespace std;
 
/*
    栈应用--进制转换
     
    描述：输入任意的十进制正整数N，分别输出该整数N的二进制、八进制、十六进制表示
 
    公式：N = （N div d）* d + N mod d (div表示整除，mod表示求余)
 
    (1348)(十进制) = (2504)(八进制) = (544)(十六进制) = (10101000100)(二进制)
 
*/
 
// 首先需要定义好进制
#define BINARY 2
#define OCTONARY 8
#define HEXADECIMAL 16
 
int main()
{
    char num[] = "0123456789ABCDEF"; // 为了16进制考虑
 
    MyStack<int> *pStack = new MyStack<int>(30);    // 首先实例化MyStack类的一个对象
 
    int N = 2016; // 以2016为例
 
    int mod = 0; // 用 mod 来存储余数
 
    while (N != 0) { // 只要N不为零，就可以一直进行操作，进制转换的原理
        mod = N % HEXADECIMAL; // 用八进制举例子
        pStack->push(mod);// 不断将余数存储进栈
        N = N / HEXADECIMAL;
    }
 
    //pStack->stackTraverse(false);// false就是从顶到底遍历
 
    int elem = 0;
    while (!pStack->stackEmpty()) {
        pStack->pop(elem);
        cout << num[elem];
    }
 
 
    delete pStack; // 用完之后销毁指针
    pStack = NULL;    // 再将指针指向 NULL
 
    system("pause");
    return 0;
}

这里写图片描述

2、栈应用–括号匹配

描述：任意输入一组括号，判断括号是否匹配

字符串示例：[()] [()()] [()[()]] [[()]]

思路就是：将字符串每个字符按照顺序入栈，一旦当有最靠近的俩字符串匹配后，将其出栈，最后所有字符串入栈结束后，我们判断在栈中是否有未出栈的字符，也就是说栈是否为空，为空说明匹配完毕，所有字符串都匹配成功了。（栈顶就是亟需匹配的字符，匹配成功，出栈）

MyStack.h不变，修改StackDemo.cpp即可，代码如下：

//这是运行文件
//栈类具体实现文件另建
 
#include "stdafx.h"
 
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"
 
using namespace std;
 
/*
    栈应用--括号匹配（发散思维可知，不止可以括号匹配）
     
    描述：任意输入一组括号，判断括号是否匹配
 
    字符串示例：[()] [()()] [()[()]] [[()]]
 
    思路就是，将字符串每个字符按照顺序入栈，一旦当有最靠近的俩字符串匹配后，将其出栈，最后所有字符串入栈结束后，我们判断在栈中是否有未出栈的字符，也就是说栈是否为空，为空说明匹配完毕，所有字符串都匹配成功了。
*/
 
 
int main(void)
{
    MyStack<char> *pStack = new MyStack<char>(30);
 
    MyStack<char> *pNeedStack = new MyStack<char>(30);
 
    char str[] = "[()]";
 
    char currentNeed = 0;
 
    for (int i = 0; i < strlen(str); i++) {
        if (str[i] != currentNeed) {
            pStack->push(str[i]);
            switch (str[i]) {
 
            case '[':
                if (currentNeed != 0) {
                    pNeedStack->push(currentNeed);
                }
                currentNeed = ']';
                break;
 
            case '(':
                if (currentNeed != 0) {
                    pNeedStack->push(currentNeed);
                }
                currentNeed = ')';
                break;
 
            default:
                cout << "不匹配" << endl;
                system("pause");
                return 0;
            }
        }
        else {
            char elem;
            pStack->pop(elem);
            if (!pNeedStack->pop(currentNeed)) {// 判断出栈是否成功
                currentNeed = 0;
            }
        }
    }
 
    if (pStack->stackEmpty()) {
        cout << "匹配啦" << endl;
    }
    else {
        cout << "不匹配" << endl;
    }
 
    delete pStack;
    pStack = NULL;
 
    delete pNeedStack;
    pNeedStack = NULL;
 
    system("pause");
    return 0;
}

这里写图片描述

完。

meiweiboboji
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-栈.zip_数据结构-栈
09-24
5. **自定义栈的实现**：除了使用STL的`stack`，还可以自定义栈，例如使用动态数组或链表作为底层数据结构。自定义栈的优势在于可以根据需求定制栈的行为，如增加新的操作或优化性能。 综上所述，这个压缩包提供的...
数据结构：八种数据结构大全
热门推荐
緑水長流*z
07-29 20万+
数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式；通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等； 1.2 数据结构的分类 1.2.1 排列方式 1）集合 集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系； 2）线性结构 线性
顺序栈与链式栈
m0_61548909的博客
05-12 417
目录 1.顺序栈 2.算法3.1数制的转换 3.算法3.2括号匹配 4.算法3.3链式栈解决表达式求值 5.算法3.4舞伴问题 6.算法3.5汉诺塔问题 1.顺序栈 #include <iostream> #include<stdio.h> using namespace std; #define SElemType int #define Status int #define STACK_INIT_SIZE 100 #define STACKINCREME
数据结构——栈(Stack)详解
最新发布
Yuan_o_的博客
06-13 1066
栈：一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中数据元素遵循后进先出LIFO(Last In First Out)的原则压栈：栈的插入操作可以叫做进栈、压栈、入栈，入数据在栈顶出栈：栈的删除操作叫做出栈，出数据在栈顶。
数据结构(全)
s6664的博客
06-21 5万+
线性结构, 树形结构, 图结构, 排序, 查找, 数据结构, 算法
【数据结构】（一）数据结构入门
weixin_44378835的博客
11-06 1万+
文章目录数据结构入门1 数据结构基础知识2 算法复杂度 数据结构入门 数据结构+算法=程序数据结构+算法=程序数据结构+算法=程序 1 数据结构基础知识 数据 指所有能输入到计算机中的描述客观事物的符号，包括文本、声音、图像、符号等。 数据元素 数据元素是数据的基本单位，也称节点或记录，如下图所示。 数据项 数据项表示有独立含义的数据最小单位，也称域。若干个数据项构成一个数据元素，数据项是不可分割的最小单位，如上图所示的“86”。 数据对象 数据对象是指相同特性的数据元素的集合，是数据的一个子集。 数据结
C语言版数据结构顺序栈的数据结构和基本操作函数实现
cyannxc的博客
10-14 1556
这个简单程序的编写过程可谓不简单，一点小bug卡了将近10多天，今天灵感一来，解决了。 书上只有完整函数声明，但没有完整函数代码，于是我为了练习并且加深印象，就打算将所有函数实现一遍，于是就有了这个程序。在完成过程中有借鉴，但是有些借鉴并不正确，编译出来还是有错，我就自己再看书学习研究，根据自己的理解修改，最后费尽心思还是完成了这个练习程序代码，在Code::Blocks中顺利编译运行，真的是...
数据结构学习--栈及其应用
06-25
数据结构学习中，栈是一种非常基础且重要的结构，它被称为后进先出（LIFO，Last In First Out）的数据组织形式。在栈中，新添加的元素（压栈）会在最后，而取出元素（出栈）总是从这些新元素开始，即最先添加的元素...
数据结构-栈和队列的使用
03-25
栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，类似于日常生活中叠放的盘子。在栈中，最新的元素（压栈）总是在最顶部，而最先的元素（入栈）则在底部。栈的主要操作有： 1. **压栈（Push）**...
JS中的算法与数据结构之栈(Stack)实例详解
10-16
主要介绍了JS中的算法与数据结构之栈(Stack),结合实例形式详细分析了js中栈的概念、原理、定义及常见使用方法,需要的朋友可以参考下
数据结构--栈与队列的应用.doc
05-04
数据结构--栈与队列的应用 栈是一种常用的数据结构，它是一种后进先出的数据结构，即最后入栈的元素最先出栈。栈的应用非常广泛，如解决递归问题、实现深度优先搜索、实现括号匹配等。 在栈的应用中，我们需要设计...
常见的数据结构总结（8种）
m0_60416282的博客
07-05 2万+
1. 顺序表（数组 Array）2. 链表 3. 栈（Stack）4. 队列（Queue）5. 树（Tree）6. 堆（Heap）7. 图（graph）8. 散列表（Hash）
数据结构（C语言版）——3.1、顺序栈实现
weixin_41600504的博客
10-06 985
3.1、顺序栈实现 3.1.1、顺序栈说明 和顺序表（线性表的顺序存储结构）类似。顺序栈即栈的顺序存储结构是利用一组地址连续的存储单元依次存放 自栈底 到栈顶 的数据元素，同时附设指针 toptoptop 指示栈顶元素在顺序栈中的位置。 通常习惯做法，以栈顶指针 top=0top=0top=0 表示空栈，鉴于C语言中数组的下标约定从整数 0 开始，则为了方便，这里栈顶指针 toptoptop 设为 intintint 变量。初始状态，top=0top = 0top=0 表示栈为空，每当插入一个新的栈顶元素时
数据结构_栈
水逝流年
03-31 801
栈和队列是两种重要的线性结构。从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可以称它们为限定性的数据结构。但从数据类型角度看，它们是和线性表大不相同的两类重要的抽象数据类型。 1、介绍 栈（stack）是限定仅在表尾进行插入或删除操作的线性表。因此，对于栈来说，表尾端有其特殊含义，称为栈顶（top），相应地，表头端称为栈
大话数据结构08：共享栈 C++
weixin_42376458的博客
01-01 122
基础介绍 共享栈就是一块内存分配给两个栈，两个栈从各自端点向中间生长，就是计算机基础中内存栈的实现吧 代码 #include "stdio.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 20 /* 存储空间初始分配量 */ typedef int Status; typedef int SElemType; /* SElemType类型根据实际情况而定，这里假设为int */ //两
栈的分析和详解
angry_youth的博客
05-13 710
栈
数据结构：八大数据结构分类
JavaAlliance
09-14 4301
数据结构：八大数据结构分类 数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。 常用的数据结构有：数组，栈，链表，队列，树，图，堆，散列表等，如图所示： 每一种数据结构都有着独特的数据存储方式，下面为大家介绍它们的结构和优缺点。 1、数组 数组是可以在内存中连续存储多个元素的结构，在内存中的分配也是连续的，数组中的元素通过数组下标进行访问，...
【数据结构】八种常见数据结构介绍
非晚非晚的博客
02-05 5万+
数据结构是计算机存储、组织数据的方式。一种好的数据结构可以带来更高的运行或者存储效率。数据在内存中是呈线性排列的，但是我们可以使用指针等道具，构造出类似“树形”的复杂结构。下面介绍八个常见的数据结构。
链式栈 C语言
cai_niaocainiao的博客
04-09 393
链栈：栈的链式存储结构 顺序栈的实现在于使用了数组这个基本数据结构，数组中的元素在内存中的存储位置是连续的，且编译器要求我们在编译期就要确定数组的大小，这样对内存的使用效率并不高，一来无法避免因数组空间用光而引起的溢出问题，二在系统将内存分配给数组后，则这些内存对于其他任务就不可用；而对于链栈而言，使用了链表来实现栈，链表中的元素存储在不连续的地址，由于是动态申请内存，所以我们可以以...
数据结构与算法分析-栈的实现及应用
"这篇资源是关于数据结构的清华大学课件，主要讲解了基本操作的实现，特别是栈的数据结构。在课件中，栈的类型定义使用了结构体`SqStack`，栈的初始大小为`STACK_SIZE`，增长单位为`STACKINCREMENT`，并定义了栈底和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值