王道数据结构强化打卡表2.1.1-2.1.6

2.1.1-2.1.2 顺序表

#include <iostream>
using namespace std;

#define Maxsize 50  // 去掉分号

// 结构体定义 - 只包含数据成员
typedef struct {
    int data[Maxsize];  // 使用定义的常量
    int top;
} SqStack;

// 初始化栈 - 作为独立函数
void initZhan(SqStack &s) {
    s.top = -1;  // 添加分号
}

// 判断栈空
bool isEmpty(SqStack &s) {
    return s.top == -1;
}

// 判断栈满
bool isFull(SqStack &s) {
    return s.top == Maxsize - 1;
}

// 入栈操作
bool inZhan(SqStack &s, int a) {
    if (s.top < Maxsize - 1) {  // 修正判断条件
        s.data[++s.top] = a;
        return true;
    }
    cout << "栈满，无法入栈！" << endl;
    return false;
}

// 出栈操作
bool outZhan(SqStack &s, int &x) {  // 通过引用返回出栈元素
    if (s.top != -1) {
        x = s.data[s.top--];  // 修正：先取值再减指针
        return true;
    }
    cout << "栈空，无法出栈！" << endl;
    return false;
}

// 获取栈顶元素
bool getTop(SqStack &s, int &x) {
    if (s.top != -1) {
        x = s.data[s.top];
        return true;
    }
    return false;
}

int main() {
    SqStack s;
    initZhan(s);
    
    // 测试入栈
    for (int i = 1; i <= 5; i++) {
        if (inZhan(s, i)) {
            cout << "入栈成功：" << i << endl;
        }
    }
    
    // 测试出栈
    int x;
    while (outZhan(s, x)) {
        cout << "出栈元素：" << x << endl;
    }
    
    return 0;
}

2.1.3-2.1.4 单向链表

#include <iostream> 
using namespace std; 
 
typedef struct ListNode{
    int data;
    struct ListNode *next;
}LinkNode,*LiStack;

    
// 初始化栈（创建一个空栈）
void initStack(LiStack &L) {
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->next = NULL;
}

// 判空操作
bool isEmpty(LiStack &L) {
    return L->next == NULL;
}

// 入栈
bool push(LiStack &L, int a){
    ListNode *l = (LinkNode*)malloc(sizeof(LinkNode));
    l->data = a;
    l->next = L->next;
    L->next = l;
}

// 出栈
int pop(LiStack &L)
{
    int temp = L->next->data;
    L->next = L->next->next;
    return temp;
}
int main() 
{ 
    LiStack L;
    initStack(L);
    push(L,1);
    push(L,2);
    printf("%d",pop(L));
}

2.1.5-2.1.6 双向链表

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

typedef struct ListNode {
    int data;
    struct ListNode *prev;  
    struct ListNode *next;
} LinkNode, *LiStack;


void initStack(LiStack &L) {
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->prev = NULL;
    L->next = NULL;
}

// 判空操作
bool isEmpty(LiStack &L) {
    return L->next == NULL;
}

// 判满操作（链式栈理论上不会满，除非内存耗尽）
bool isFull() {
    LinkNode* testNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (testNode == NULL) {
        return true;  
    }
    free(testNode);
    return false;
}

// 入栈操作
bool push(LiStack &L, int a) {
    if (isFull()) {
        cout << "栈满，无法入栈！" << endl;
        return false;
    }
    
    LinkNode *newNode = (LinkNode*)malloc(sizeof(LinkNode));
    newNode->data = a;
    
    // 新节点插入在头节点之后
    newNode->next = L->next;
    newNode->prev = L;  // 新节点的前驱指向头节点
    
    if (L->next != NULL) {
        L->next->prev = newNode;  // 原第一个节点的前驱指向新节点
    }
    
    L->next = newNode;  // 头节点指向新节点
    return true;
}

// 出栈操作
bool pop(LiStack &L, int &value) {
    if (isEmpty(L)) {
        cout << "栈空，无法出栈！" << endl;
        return false;
    }
    
    LinkNode *temp = L->next;  // 要删除的节点（栈顶）
    value = temp->data;        // 保存栈顶元素值
    
    L->next = temp->next;      // 头节点指向下一个节点
    if (temp->next != NULL) {
        temp->next->prev = L;  // 新栈顶节点的前驱指向头节点
    }
    
    free(temp);  // 释放内存
    return true;
}


int main() {
    LiStack L;
    initStack(L);
    int value;
    
    cout << "=== 双向链表栈测试 ===" << endl;
    
    // 测试判空
    cout << "初始栈是否为空: " << (isEmpty(L) ? "是" : "否") << endl;
    
    // 测试入栈
    cout << "\n=== 入栈操作测试 ===" << endl;
    for (int i = 1; i <= 5; i++) {
        if (push(L, i)) {
            cout << "入栈成功: " << i << endl;
        }
    }
    
   
    // 测试出栈
    cout << "\n=== 出栈操作测试 ===" << endl;
    while (pop(L, value)) {
        cout << "出栈元素: " << value << endl;
    }

    
    return 0;
}