C++ 算法学习栈和队列

最新推荐文章于 2024-08-26 18:09:04 发布
最新推荐文章于 2024-08-26 18:09:04 发布
阅读量432 收藏 3
点赞数
分类专栏： 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seacowtech/article/details/79256300
版权

栈的定义：栈是一种重要的线性结构，栈是线性表的一种具体形式。

官方定义：栈（Stack）是一个后进先出（Last in first out,LIFO）的线性表，它要求只在表尾进行删除和插入操作。所谓的栈，其实也就是一个特殊的线性表（顺序表、链表），但是它在操作上有一些特殊的要求和限制：

栈的元素必须“后进先出”。

栈的操作只能在这个线性表的表尾进行。

注：对于栈来说，这个表尾称为栈的栈顶（top），相应的表头称为栈底（bottom）。

栈的插入操作（Push），叫做进栈，也称为压栈，入栈。

栈的删除操作（Pop），叫做出栈，也称为弹栈。

栈的顺序存储结构：

栈的顺序存储结构和栈的链式存储结构。

最开始栈中不含有任何数据，叫做空栈，此时栈顶就是栈底。然后数据从栈顶进入，栈顶栈底分离，整个栈的当前容量变大。数据出栈时从栈顶弹出，栈顶下移，整个栈的当前容量变小。

看一下数据结构：

typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

它包含了三个元素：base ,top ,stackSize。其中base是指向栈底的指针变量，top是指向栈顶的指针变量，stackSize指示栈的当前可使用的最大容量。

创建一个栈

#define STACK_INIT_SIZE 100
initStack(sqStack *s)
{
    s->base = (ElemType *)malloc( STACK_INIT_SIZE * sizeof(ElemType) );
    if( !s->base )
        exit(0);
    s->top = s->base;   // 最开始，栈顶就是栈底
    s->stackSize = STACK_INIT_SIZE;
}

入栈操作又叫压栈操作，就是向栈中存放数据。

入栈操作要在栈顶进行，每次向栈中压入一个数据，top指针就要+1，知道栈满为止。

#define SATCKINCREMENT 10

void Push(sqStack *s, ElemType e)
{
    // 如果栈满，追加空间
    if( s->top – s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
            exit(0);

        s->top = s->base + s->stackSize;              // 设置栈顶
        s->stackSize = s->stackSize + STACKINCREMENT; // 设置栈的最大容量
    }

    *(s->top) = e;
    s->top++;
}

出栈操作就是在栈顶取出数据，栈顶指针随之下移的操作。

每当从栈内弹出一个数据，栈的当前容量就-1。

void Pop(sqStack *s,ElemType *e)
{
    if( s->top == s->base)  // 栈已空空是也
        return;

    *e = *--(s->top);
}

栈的另一种定义：

typedef int ElemType;
typedef struct
{
    ElemType data[MAXSIZE];
    int top;        // 用于标注栈顶的位置
    int stackSize;
}

不推荐用这种方法。

清空一个栈：

清空一个栈，就是将栈中的元素全部作废，但栈本身物理空间并不发生改变（不是销毁）。

因此我们只要将s->top的内容赋值为s->base即可，这样s->base等于s->top，也就表明这个栈是空的了。这个原理跟高级格式化只是但单纯地清空文件列表而没有覆盖硬盘的原理是一样的。

void ClearStack(sqStack *s){
    s->top = s->base;
}

销毁一个栈：

销毁一个栈与清空一个栈不同，销毁一个栈是要释放掉该栈所占据的物理内存空间，因此不要把销毁一个栈与清空一个栈这两种操作混淆。

void DestroyStack(sqStack *s){
    int i, len;
    len = s->stackSize;
    for( i=0; i < len; i++ ){
        free( s->base );
        s->base++;
    }
    s->base = s->top = NULL;
    s->stackSize = 0;
}

计算栈的当前容量:

计算栈的当前容量也就是计算栈中元素的个数，因此只要返回s.top-s.base即可。

注意，栈的最大容量是指该栈占据内存空间的大小，其值是s.stackSize，它与栈的当前容量不是一个概念哦。

int StackLen(sqStack s)
{
    return(s.top – s.base);  // 初学者需要重点讲解
}

代码库（二进制转换十进制）

#include <iostream>
#include <cmath>
using namespace std;

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
    }

    *(s->top) = e;
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

int StackLen(sqStack s)
{
    return static_cast<int>(s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s{};
    int len, i, sum = 0;

    InitStack(&s);

    cout << "请输入二进制数，输入#符号表示结束:\t";
    cin >> c;
    while( c != '#' )
    {
        Push(&s, c);
        cin >> c;
    }

    getchar();  // 把'\n'从缓冲区去掉

    len = StackLen(s);
    cout << "栈的当前容量是: " << len << endl;

    for( i=0; i < len; i++ )
    {
        Pop(&s, &c);
        sum = static_cast<int>(sum + (c - 48) * pow(2, i));
    }

    cout << "转化为十进制数是: " << sum << endl;

    return 0;
}

代码库（二进制转换十六进制）

#include <iostream>
#include <cmath>
using namespace std;

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

// 函数功能：初始化栈
// 参数*s：栈的地址
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

// 函数功能：入栈操作
// 参数*s：栈的地址
// 参数e：待压入栈的元素
void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

// 函数功能：弹栈操作
// 参数*s：栈的地址
// 参数e：存放从栈里弹出的数据
void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

// 函数功能：计算栈s的当前长度
// 参数s：栈
int StackLen(sqStack s)
{
    return static_cast<int>(s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s1{};
    sqStack s2{};
    int len, i, j, sum = 0;

    InitStack(&s1); // 初始化栈s1，用来存放二进制输入

    cout << "请输入二进制数，输入#符号表示结束:\t";
    cin >> c;
    while( c != '#' )
    {
        if( c=='0' || c=='1' )  // 检查输入是否二进制
            Push(&s1, c);
        cin >> c;
    }
    getchar();      // 把'\n'从缓冲区去掉
    len = StackLen(s1);

    InitStack(&s2); // 初始化栈s2，用来存放转换的八进制

    for( i=0; i < len; i+=4 )
    {
        for( j=0; j < 4; j++ )
        {
            Pop( &s1, &c ); // 取出栈顶元素
            sum = static_cast<int>(sum + (c - 48) * pow(2, j));

            if( s1.base == s1.top )
            {
                break;
            }
        }

        switch( sum )
        {
            case 10: sum = 'A'; break;
            case 11: sum = 'B'; break;
            case 12: sum = 'C'; break;
            case 13: sum = 'D'; break;
            case 14: sum = 'E'; break;
            case 15: sum = 'F'; break;
            default: sum += 48;
        }

        Push(&s2, static_cast<ElemType>(sum));
        sum = 0;
    }

    cout << "\n转化为十六进制数是: ";
    while( s2.base != s2.top )
    {
        Pop( &s2, &c );
        cout << c;
    }
    cout << endl;

    return 0;
}

代码库（二进制转换八进制）

#include <iostream>
#include <cmath>
using namespace std;

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;
typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

// 函数功能：初始化栈
// 参数*s：栈的地址
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

// 函数功能：入栈操作
// 参数*s：栈的地址
// 参数e：待压入栈的元素
void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

// 函数功能：弹栈操作
// 参数*s：栈的地址
// 参数e：存放从栈里弹出的数据
void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }
    *e = *--(s->top);
}

// 函数功能：计算栈s的当前长度
// 参数s：栈
int StackLen(sqStack s)
{
    return static_cast<int>(s.top - s.base);
}

int main()
{
    ElemType c;
    sqStack s1{};
    sqStack s2{};
    int len, i, j, sum = 0;

    InitStack(&s1); // 初始化栈s1，用来存放二进制输入

    cout << "请输入二进制数，输入‘#’号表示结束:\t";
    cin >> c;
    while( c != '#' )
    {
        if( c=='0' || c=='1' )  // 检查输入是否二进制
            Push(&s1, c);
        cin >> c;
    }
    getchar();      // 把'\n'从缓冲区去掉
    len = StackLen(s1);

    InitStack(&s2); // 初始化栈s2，用来存放转换的八进制

    for( i=0; i < len; i+=3 )
    {
        for( j=0; j < 3; j++ )
        {
            Pop( &s1, &c ); // 取出栈顶元素
            sum = static_cast<int>(sum + (c - 48) * pow(2, j));

            if( s1.base == s1.top )
            {
                break;
            }
        }

        Push(&s2, static_cast<ElemType>(sum + 48));
        sum = 0;
    }

    cout << "\n转化为八进制数是: ";
    while( s2.base != s2.top )
    {
        Pop( &s2, &c );
        cout << c;
    }
    cout << endl;

    return 0;
}

栈的链式存储：

栈因为只是栈顶来做插入和删除操作，所以比较好的方法就是将栈顶放在单链表的头部，栈顶指针和单链表的头指针合二为一。

栈的链式存储结构定义：

teypedef struct StackNode
{
    ElemType data;  // 存放栈的数据
    struct StackNode *next;
} StackNode, *LinkStackPtr;

teypedef struct LinkStack
{
    LinkStackPrt top;   // top指针
    int count;      // 栈元素计数器
}

对于栈链的Push操作，假设元素值为e的新结点是s，top为栈顶指针，我们得到如下代码：

Status Push(LinkStack *s,ElemType e)
{
    LinkStackPtr p = (LinkStackPtr) malloc(sizeof(StackNode));
    p->data = e;
    p->next = s->top;
    s->top = p;
    s->count++;
    return OK;
}

bool Push(LinkStack *s,ElemType e)
{
    LinkStackPtr p = (LinkStackPtr) malloc(sizeof(StackNode));
    p->data = e;
    p->next = s->top;
    s->top = p;
    s->count++;
    return true;
}

链栈的出战Pop操作，假设变量p用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放p即可。

Status Pop(LinkStack *s,ElemType *e)
{
    LinkStackPtr p;
    if( StackEmpty(*s))  // 判断是否为空栈
        return ERROR;
    *e = s->top->data;
    p = s->top;
    s->top = s->top->next;
    free(p);
    s->count--;
    return OK;
}

bool Pop(LinkStack *s,ElemType *e)
{
    LinkStackPtr p;
    if( StackEmpty(*s))  // 判断是否为空栈
        return false;
    *e = s->top->data;
    p = s->top;
    s->top = s->top->next;
    free(p);
    s->count--;
    return true;
}

RPN，逆波兰计算器

#include <iostream>
using namespace std;

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10
#define MAXBUFFER       10

typedef double ElemType;
typedef struct {
    ElemType *base;
    ElemType *top;
    int stackSize;
} sqStack;

void InitStack(sqStack *s) {
    s->base = (ElemType *) malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if (!s->base)
        exit(0);

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e) {
// 栈满，追加空间
    if (s->top - s->base >= s->stackSize) {
        s->base = (ElemType *) realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if (!s->base)
            exit(0);

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;      // 存放数据
    s->top++;
}

void Pop(sqStack *s, ElemType *e
) {
    if (s->top == s->base)
        return;

    *e = *--(s->top);   // 将栈顶元素弹出并修改栈顶指针
}

int StackLen(sqStack s) {
    return static_cast<int>(s.top - s.base);
}

int main() {
    sqStack s{};
    char c;
    double d, e;
    char str[MAXBUFFER];
    int i = 0;

    InitStack( &s );

    cout << "请按逆波兰表达式输入待计算数据，数据与运算符之间用空格隔开，以#作为结束标志: \t";
    cin >> c;

    while( c != '#' )
    {
        while( isdigit(c) || c=='.' )  // 用于过滤数字
        {
            str[i++] = c;
            str[i] = '\0';
            if( i >= 10 )
            {
                cout << "出错：输入的单个数据过大" << endl;
                return -1;
            }
            cin >> c;
            if( c == ' ' )
            {
                d = atof(str);
                Push(&s, d);
                i = 0;
                break;
            }
        }

        switch( c )
        {
            case '+':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d+e);
                break;
            case '-':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d-e);
                break;
            case '*':
                Pop(&s, &e);
                Pop(&s, &d);
                Push(&s, d*e);
                break;
            case '/':
                Pop(&s, &e);
                Pop(&s, &d);
                if( e != 0 )
                {
                    Push(&s, d/e);
                }
                else
                {
                    cout << "\n出错：除数为零" << endl;
                    return -1;
                }
                break;
            default:break;
        }

        cin >> c;
    }

    Pop(&s, &d);
    cout << "\n最终的计算结果为：" << d << endl;

    return 0;
}

讲完了栈，现在开始看看队列。

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

与栈相反，队列是一种先进先出（First In First Out, FIFO）的线性表。

与栈相同的是，队列也是一种重要的线性结构，实现一个队列同样需要顺序表或链表作为基础。

队列的数据结构定义：

typedef struct QNode {
    ElemType data;      
    struct QNode *next;
} QNode, *QueuePrt;

typedef struct {
    QueuePrt front, rear; // 队头、尾指针
} LinkQueue;

创建一个队列要完成两个任务：一是在内存中创建一个头结点，二是将队列的头指针和尾指针都指向这个生成的头结点，因为此时是空队列。

void initQueue(LinkQueue*q)
{
    q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
    if( !q->front )
        exit(0);
    q->front->next = NULL;
}

入队列：

InsertQueue(LinkQueue *q, ElemType e)
{
    QueuePtr p;
    p = (QueuePtr)malloc(sizeof(QNode));
    if( p == NULL )
        exit(0);
    p->data = e;
    p->next = NULL;
    q->rear->next = p;
    q->rear = p;
}

出队列：

DeleteQueue(LinkQueue *q, ELemType *e)
{
    QueuePtr p;
    if( q->front == q->rear )
        return;
    p = q->front->next;
    *e = p->data;
    q->front->next = p->next;
    if( q->rear == p )
    q->rear = q->front;
    free(p);
}

销毁一个队列：

由于链队列建立在内存的动态区，因此当一个队列不再有用时应当把它及时销毁掉，以免过多地占用内存空间。

DestroyQueue(LinkQueue*q)
{
    while( q->front ) 
    {
        q->rear =q->front->next;
        free( q->front );
        q->front = q->rear;
    }
}

下面看一下循环队列：

定义一个循环队列

#define MAXSIZE 100
typedef struct
{
    ElemType *base; // 用于存放内存分配基地址
                    //这里你也可以用数组存放
    int front;
    int rear;
};

初始化一个循环队列

void initQueue(cycleQueue *q)
{
    q->base = (ElemType *) malloc (MAXSIZE * sizeof(ElemType));
    if( !q->base )
        exit(0);
    q->front = q->rear = 0;
}

入队列操作

bool InsertQueue(cycleQueue *q,ElemType e)
{
    if( (q->rear+1)%MAXSIZE ==q->front )
        return false; // 队列已满
    q->base[q->rear] = e;
    q->rear = (q->rear+1) %MAXSIZE;
}

出队列操作

bool DeleteQueue(cycleQueue*q, ElemType *e)
{
    if(q->front == q->rear )
        return false; // 队列为空
    *e= q->base[q->front];
    q->front= (q->front+1) % MAXSIZE;
}

C++循环队列模板

#include <iostream>
using namespace std;
class Queue{
private:
    int *data;              //定义指向整型的指针，从而动态开辟内存
    int head,tail,length,count;   //head指向队首,tail指向队尾,length表示队列的长度,count用于记录队列中元素个数,从而判断队列是否已满
public:
    explicit Queue (int length_input){       //构造函数,对新声明的队列对象进行初始化
        data = new int [length_input];      //动态开辟100个整型数据的空间
        length = length_input;              //为队列的长度赋初始值
        head = 0;                       //起初head为0，表示head值未改变的情况下,一直指向首元素
        tail = -1;                      //tail初始值为-1，表示此时队列为空,无任何数据元素
        count = 0;
    }
    ~Queue(){
        delete [] data;             //析构函数,删除动态开辟的内存
    }
    void push(int element){            //入队操作,只能从队列的尾部插入数据元素
        if(count < length){             //队列未满的时候才能插入,否则则插入失败
            tail = (tail + 1) % length;     //分两种情况,如果队尾指针此时并未指向队列的最后一位,那么队尾指针直接前移,而当队尾指针此时指向最后一位时
            data[tail] = element;           //那么当队列未满时,则队尾指针将跳转至数组起始位置，再将数据元素插入队尾指针指向的位置
            ++count;                    //入队成功,队列中元素数量加一
        }
    }
    bool pop(){
        if(count < 0){     //队列为空,出队失败
            return false;
        }
        head = (head + 1) % length;         //同样,根据循环队列的性质得出
        --count;            //出队成功,队列中元素数量减一
        return true;
    }
    int top(){
        if(count > 0){      //队列不为空的情况下才能获取队首元素
            return data[head];
        }else{
            return false;
        }
    }
    void output(){
        for(int i = head;i != tail + 1;i = (i + 1)%length){     //从队首一直遍历到队尾,当遍历到最后一位时,跳转至数组起始位置
            //特别注意此时循环截止的条件应该是i != tail + 1，因此可能tail的值小于head
            cout << data[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    Queue queue(100);               //声明一个队列对象,并初始化
    for(int i = 1;i <= 10;++i){
        queue.push(i);             //将1-10这10个数据元素依次插入队列中
    }
    queue.output();             //调用输出的方法
    cout << "当前的队首元素为:" << queue.top() << endl;
    queue.pop();               //出队
    queue.output();             //调用输出的方法
    cout << "出队操作后的队首元素为:" << queue.top() << endl;
    queue.pop();               //出队
    queue.output();             //调用输出的方法
    cout << "出队操作后的队首元素为:" << queue.top() << endl;
    return 0;
}

非模板循环队列

#include <iostream>
using namespace std;

#define MAXSIZE 100

typedef double ElemType;
typedef struct
{
    ElemType *base; // 用于存放内存分配基地址
    //这里你也可以用数组存放
    int front;
    int rear;
    int count;
}cycleQueue;

void initQueue(cycleQueue *q)
{
    q->base = (ElemType *) malloc (MAXSIZE * sizeof(ElemType));
    if( !q->base )
        exit(0);
    q->front = q->rear = 0;
}

bool InsertQueue(cycleQueue *q,ElemType e)
{
    if( (q->rear+1)%MAXSIZE ==q->front )
        return false; // 队列已满
    q->base[q->rear] = e;
    q->rear = (q->rear+1) %MAXSIZE;
    q->count++;
}

bool DeleteQueue(cycleQueue *q, ElemType *e)
{
    if(q->front == q->rear )
        return false; // 队列为空
    *e= q->base[q->front];
    q->front= (q->front+1) % MAXSIZE;
}

int main(){
    cycleQueue queue{};
    double d;

    initQueue(&queue);
    InsertQueue(&queue, 1);
    InsertQueue(&queue, 2);
    InsertQueue(&queue, 3);
    InsertQueue(&queue, 4);
    InsertQueue(&queue, 5);
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    InsertQueue(&queue, 6);
    InsertQueue(&queue, 7);
    InsertQueue(&queue, 8);
    InsertQueue(&queue, 9);
    InsertQueue(&queue, 0);
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    DeleteQueue(&queue, &d);
    cout << d << endl;
    return 0;
}
悉尼胖哥
关注
专栏目录
链式队列基本操作（入队和出队）
数据结构和算法教程（C语言版）
11-05 512
通过学习链式队列最基本的数据入队和出队操作，我们可以就实际问题，对以上代码做适当的修改。前面在学习顺序队列时，由于顺序表的局限性，我们在顺序队列中实现数据入队和出队的基础上，又对实现代码做了改进，令其能够充分利用数组中的空间。链式队列就不需要考虑空间利用的问题，因为链式队列本身就是实时申请空间。因此，这可以算作是链式队列相比顺序队列的一个优势。//链表中的节点结构int data;}QNode;//创建链式队列的函数//创建一个头节点//对头节点进行初始化。
C++算法学习(栈)
weixin_45743162的博客
02-03 553
目录什么是栈？实践题目[155. 最小栈](https://leetcode-cn.com/problems/min-stack/) 什么是栈？ 是一个运算受限制的线性表，只能在表尾进行插入和删除，也就是先进后出，后进先出。(新手检验搜一本算法图解，讲的很明白) 实践题目 155. 最小栈 struct Node{ int val; int min; Node *next; }; //建立结构体，写入题目要求的功能 class MinStack { priva
c++栈和队列（stack和queue）
最新发布
2302_80657849的博客
08-26 834
栈和队列是两个极其相似的数据结构，栈具有先进后出的特性，队列具有先进先出的特性。今天我们就来简单的介绍一下栈和队列这两数据结构，其中队列我们介绍普通队列、双端队列（了解）和优先级队列（其实这就是堆这种数据结构），我们顺便再来认识一下标准库在实现这两数据结构时使用的容器适配器，它对我们实现代码的复用起到怎样的效果
C++学习 栈(四)
测试
02-21 144
栈 栈是一种先进先出的数据结构,用处很大 进栈 使用push()函数进栈 #include <iostream> #include <stack> using namespace std; int main() { stack<int> a; a.push(10); a.push(100); a.push(10...
栈和队列的总结
weixin_30539835的博客
11-19 200
栈和队列的总结： （有时候感觉自己掌握了，栈和队列，可是在写的时候会遇到不同的情况，就不会处理了，因此在这里进行总结下）。 栈： 栈是一端受限，一段允许进行操作的线性表。我自己理解时，会将它理解成一个装书的盒子。放书，取书，就是进行的操作。这个的特点就是，你放了一踏书，现在你想取书，你只能先把上面的书一个个取...
栈及c++学习笔记（一）
wangminshe89
01-02 123
今天说实话很长时间过的都很纠结。集训的第2天，还是按照以前的生活习惯6：20起床，跑步，到ACM。不过今天非常悲剧的就是没有钥匙，队长今天貌似睡过了，嘿嘿。我跟asas123非常悲剧的在冰冷的自习室待了很长时间。不过今天张教主就回家了，嘿嘿，他把钥匙给我了。兴奋ing，终于不用担心ACM没人了。 早上把在网上订的火车票拿到手了，心里又少了一个负担。 一、 今天一整天都是在那看万恶的栈...
数据结构与算法（C++）– 栈（Stack）
Wang_Jiankun的博客
08-31 598
数据结构与算法（C++）– 栈 1、栈是什么 后进先出（Last in, First out） push 入栈，pop 出栈，top栈顶 2、栈的实现 单链表：在单链表的前端插入实现 push 操作，删除前端元素实现 pop 操作，前端元素即为 top。 数组：用 vector 的 push_back 和 pop_back 实现 push 和 pop 操作 3、栈...
C++实现的任意进制转换（数据结构——栈和队列）
08-10
本文将深入探讨如何使用C++语言实现任意进制转换，特别是涉及到小数部分的处理，并结合数据结构中的栈和队列进行阐述。C++作为一门强大的静态类型语言，其丰富的库支持和高效性能使得它成为实现这种算法的理想选择。...
基于 C++线性表及其实现 栈和队列及其应用课程实验（实验报告+源码）
06-27
【作品名称】：线性表及其实现 栈和队列及其应用【课程实验】（实验报告+源码） 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 ...
数据结构c++代码（栈，队列，斐波那契数列）
07-16
C++中常见的队列实现包括数组队列（循环数组）和链表队列。入队（enqueue）操作在队尾添加元素，出队（dequeue）操作从队头移除元素。队列广泛应用于任务调度、打印队列、广度优先搜索等。 3. **斐波那契数列**：...
C++栈和队列底层_数据结构与算法实验二_艾孜尔江·艾尔斯兰著.zip
01-01
本实验资源内附详细的指导教程和演示案例，通俗易懂，由艾孜尔江·艾尔斯兰亲自实验并撰著而成，均为底层开发，可供研究和学习使用，平时工作中亦可实践，是初学者深入学习数据结构与算法的法宝，基于C++语言实现，...
栈和队列从小白到入门的学习路径
04-03
学习栈和队列，首先要掌握其基本概念和操作，然后通过实际编程练习加深理解，例如使用Python或C++实现基本的栈和队列操作。进一步，可以研究它们在实际问题中的应用，如回溯算法、深度优先搜索（DFS）和广度优先搜索...
C++栈学习——顺序栈和链栈的区别
热门推荐
千里之行始于足下
08-24 1万+
C++中栈有顺序栈和链栈之分，在顺序栈中，定义了栈的栈底指针（存储空间首地址base）、栈顶指针top以及顺序存储空间的大小stacksize（个人感觉这个数据成员是可以不用定义的） //顺序栈数据结构C++类声明（基类） template <typename ElemType> class SqStack { public: void clear();
初学编程C++之栈
zyp1009的博客
12-04 231
代码示例： #ifndef MYSTACK_H #define MYSTACK_H class MyStack { public: MyStack(int size);//分配内存初始化空间，设定栈容量，栈顶 ~MyStack();//回收栈空间内存 bool stackEmpty();//判断栈是否为空，为空返回true，非空返回false bool stackFull();//判断...
【数据结构初学】栈 stack(C++)
qq_30933473的博客
04-18 329
栈stack是一种先进先出的数据结构，在很多高级语言中都有它的定义 将3个元素a,b,c一次以1，2，3的顺序压入(push)站内，连续3次弹出(pop)的时候会以c,b,a的顺序弹出 在C++中 stack<int> a; int num[3]; a.push(1); a.push(2); a.push(3);//此时栈a的元素为[ 1, 2, 3] for(int i = 0;i ...
C++学习笔记1-------实现栈
mr_Gemini的博客
07-04 197
第一次写博客，本系列主要记录下C++学习过程中编写的代码以及遇到的一些问题#include &lt;iostream&gt; using std::cout; using std::endl; class Stack { public: Stack(const int stacksize); Stack(const Stack &amp; rhs); Stack &amp; operato...
C++算法之 自己写一个简单的栈Stack
CppPlayer
12-06 5179
// Stack.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; enum{COUNT = 8}; typedef int TYPE; class CStack { TYPE m_pData[COUNT]; int m_nTop; int m_nCount;
C++算法（7）数组实现栈
weixin_42592666的博客
11-25 242
as
C/C++经典算法精华整理（3）-实现栈的数据结构
HELLO WORLD
08-05 424
实现栈的数据结构   #include  #include  #include  #define N 50 struct stack { int top;//栈顶的下标 int data[N];//存储栈的数据 //void *p[N]; }; void init(struct stack *p)//对于栈进行初始化 { p->top = -1;//代表为空，下标0代表
C++链表、栈与队列排序算法详解
这份C++课件提供了一个全面的框架，旨在帮助学习者理解和掌握基本的C++编程技巧，特别是与排序算法、数据结构相关的内容，以及如何将这些概念应用于实际问题的解决。通过丰富的实践练习，学生能够巩固理论知识，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值