用C++写一个栈

 用C++写一个栈

- 顺序栈

//main.cpp
#include "Stack.h"
int main() {
    SqStack *stack_1;
    Stack_1 test_1;
    int temp_1;
    test_1.initStack(stack_1);
    test_1.push(stack_1 , 2);
    test_1.push(stack_1 , 1);
    test_1.push(stack_1 , 2);
    test_1.push(stack_1 , 3);
    test_1.push(stack_1 , 5);
    test_1.pop(stack_1,0);
    temp_1 = test_1.getTop(stack_1);
    cout << "TOP:"<<  temp_1 << endl;
    test_1.destroyStack(stack_1);
    test_1.push(stack_1 , 2);
    test_1.push(stack_1 , 1);
    test_1.push(stack_1 , 2);
    test_1.push(stack_1 , 3);
    test_1.push(stack_1 , 5);
    test_1.display(stack_1);
    return 0;
}

//Stack.h
#include <iostream>
using namespace std;
struct SqStack{
//    int *data = new int[5];
    int data[5];
    int top;
};
class Stack_1{
private:
public:
    void initStack(SqStack * &stack);//类型是因为其实它就是个数组而已
    void destroyStack(SqStack * &stack);

    bool emptyStack(SqStack *stack);
    bool foolStack(SqStack *stack);
    bool push(SqStack* &stack,int num);//之所以是bool类型，是因为&的直接操作
    bool pop(SqStack* &stack ,int num);

    int getTop(SqStack *stack );
    void display(SqStack *stack);
};

struct shareStack{
    int *data = new int[10];
    int top_1,top_2;
};
class Stack_2{
private:
public:
    void initStack(shareStack * &stack);//类型是因为其实它就是个数组而已
    void destroyStack(shareStack * &stack);

    bool emptyStack(shareStack *stack);
    bool foolStack(shareStack *stack);
    bool push(shareStack *stack,int num);
    bool pop(shareStack *stack ,int num);

    int getTop(shareStack *stack );
    void display(shareStack *stack);
};

//Stack.cpp
//
// Created by 33559 on 2022/11/17.
//
#include "Stack.h"

void Stack_1::initStack(SqStack *&stack){
    stack = new SqStack;
    stack->top = -1;
}

void Stack_1::destroyStack(SqStack *&stack) {
    delete [] stack;
    stack = new SqStack;
    stack ->top = -1;
}

bool Stack_1::emptyStack(SqStack *stack) {return stack->top == -1 ;}
//        return stack->top == -1 ? true : false;
//-- 上下等效会报警告，表达可以简化
bool Stack_1::foolStack(SqStack *stack) {return stack->top == 4;}

int Stack_1::getTop(SqStack *stack) {
    if (stack->top == -1) return 0;
    return stack->data[stack->top];
}

bool Stack_1::push(SqStack* &stack, int num) {
    if (foolStack(stack)) return false;
    stack ->top++;
    stack->data[stack->top] = num;
    return true;
}
bool Stack_1::pop(SqStack* &stack, int num) {
    if (emptyStack(stack)) return false;
    stack->data[stack ->top] = num;
    stack -> top --;
    return true;
}//弹栈顶

void Stack_1::display(SqStack *stack) {
    cout <<" Stack:" << " ";
    while(stack ->top != -1)
        cout << stack->data[stack->top--];
}
//stack->top + 1
//0,1,2已存三个数据，但是条件为i < 2 -- 循环2次 所以要加1

- 共享栈

//Stack.h
#ifndef STACKANDQUEUE_STACK_H
#define STACKANDQUEUE_STACK_H
#include <iostream>
#include <malloc.h>
using namespace std;
struct shareStack{
    int *data = new int[10];
    int top_1,top_2;
};

class Stack_2{
private:
public:
    void initStack(shareStack * &stack);//类型是因为其实它就是个数组而已
    void destroyStack(shareStack * &stack);

    bool emptyStack_1(shareStack *stack);
    bool emptyStack_2(shareStack *stack);
    
    bool foolStack_1(shareStack *stack);
    bool foolStack_2(shareStack *stack);

    bool push_1(shareStack *&stack,int num);
    bool push_2(shareStack *&stack,int num);

    bool pop_1(shareStack *&stack ,int num);
    bool pop_2(shareStack *&stack ,int num);

    int getTop_1(shareStack *stack );
    int getTop_2(shareStack *stack );

    void display_1(shareStack *stack);
    void display_2(shareStack *stack);

};
#endif //STACKANDQUEUE_STACK_H

- 链栈

//main.cpp
#include "Stack.h"
int main(void)
{
    StackNode *stack_3;
    Stack_3 test_3;
    int num;
    test_3.initStack(stack_3);
    if (test_3.emptyStack(stack_3))
        cout << "Yes" << endl;
    test_3.push(stack_3,1);
    test_3.push(stack_3,3);
    test_3.push(stack_3,2);
    test_3.push(stack_3,4);
    test_3.pop(stack_3,0);
    num = test_3.getTop(stack_3);
    cout << num << endl;
//    test_3.destroyStack(stack_3);
    test_3.display(stack_3);

    return 0;
}

#ifndef STACKANDQUEUE_STACK_H
#define STACKANDQUEUE_STACK_H
#include <iostream>
#include <malloc.h>
using namespace std;
struct StackNode{
    int data ;
    StackNode *next;
};

class Stack_3{
private:
public:
    void initStack(StackNode * &stack);//类型是因为其实它就是个数组而已
    void destroyStack(StackNode * &stack);

    bool emptyStack(StackNode *stack);
    bool push(StackNode *stack,int num);
    bool pop(StackNode *stack ,int num);

    int getTop(StackNode *stack );
    void display(StackNode *stack);
};
#endif //STACKANDQUEUE_STACK_H

//Stack.cpp
#include "Stack.h"

void Stack_3::initStack(StackNode *&stack) {
    stack = new StackNode;
    stack->next = nullptr;//不写死循环
}

void Stack_3::destroyStack(StackNode *&stack) {
    StackNode *delP,*prev;
    delP = stack;
    prev = stack->next;
    while(stack != nullptr)
    {
        delete delP;
        delP = prev;
        prev = delP ->next;
    }
    stack ->next = nullptr;
}

bool Stack_3::push(StackNode *stack, int num) {
    StackNode *temp = new StackNode;
    temp ->data = num;
    temp ->next = stack->next;
    stack ->next = temp;
    return true;
}

bool Stack_3::pop(StackNode *stack, int num) {
    /*StackNode *temp ;
    if (stack ->next == nullptr) return false;
    temp = stack ->next;
    num = stack ->data;//提取值 -- 写不写都行
    stack ->next = temp ->next;
    delete temp;*/
    while(stack->next)
    {
        pop(stack,0);
    }
    stack->next = nullptr;
}

int Stack_3::getTop(StackNode *stack) {
    if (stack->next == nullptr) return 0;
    return stack->next->data;
}

bool Stack_3::emptyStack(StackNode *stack) {
    if (stack->next == nullptr)
        return true;
}

void Stack_3::display(StackNode *stack) {
    stack = stack ->next;
    while(stack)
    {
        cout << stack->data <<" ";
        stack = stack ->next;
    }
}