栈的内容..

1：顺序栈

#include <stdio.h>
#define MAXSIZE 100

typedef struct {
    int* base; // 栈底地址
    int* top; // 栈顶地址
    int stacksize; // 栈可用的最大容量
} sqstack;

// 初始化栈
int InitStack(sqstack& s) {
    s.base = new int[MAXSIZE];
    if (!s.base) return -1;
    s.top = s.base;
    s.stacksize = MAXSIZE;
    return 1;
}

// 入栈
int Push(sqstack& s, int e) {//
    if (s.top - s.base >= s.stacksize) return -1; // 栈满
    *s.top++ = e;
    return 1;
}

// 出栈
int Pop(sqstack& s, int& e) {//引用传递允许我们直接在调用处更改传入的变量，而不需要返回值
    if (s.top == s.base) return -1; // 栈空
    e = *--s.top;
    return 1;
}

// 取栈顶元素
int GetTop(sqstack& s, int& e) {
    if (s.top == s.base) return -1; // 栈空
    e = *(s.top - 1);
    return 1;
}

// 打印栈的元素
void PrintStack(sqstack& s) {
    int* p = s.base;
    while (p != s.top) {
        printf("%d ", *p);
        p++;
    }
    printf("\n");
}

int main() {
    sqstack s;
    int e;

    // 初始化栈
    if (InitStack(s) == -1) {
        printf("栈初始化失败\n");
        return -1;
    }

    // 入栈操作
    Push(s, 1);
    Push(s, 2);
    Push(s, 3);

    // 打印栈
    printf("栈中的元素为：");
    PrintStack(s);

    // 第一次取栈顶元素
    if (GetTop(s, e) == 1) {
        printf("当前栈顶元素为：%d\n", e);
    }
    else {
        printf("栈为空\n");
    }

    // 出栈
    if (Pop(s, e) == 1) {
        printf("出栈元素为：%d\n", e);
    }
    else {
        printf("栈为空\n");
    }

    // 第二次取栈顶元素
    if (GetTop(s, e) == 1) {
        printf("新的栈顶元素为：%d\n", e);
    }
    else {
        printf("栈为空\n");
    }

    // 再次打印栈
    printf("当前栈中的元素为：");
    PrintStack(s);

    // 释放栈空间
    delete[] s.base;

    return 0;
}

分析：

1：int &e，为什么要加&？

在函数原型中使用 int &e 是为了使用 C++ 中的引用传递机制。引用传递允许我们直接在调用处更改传入的变量，而不需要返回值。

1. 引用传递:

   • 引用传递（int &e）允许函数直接操作传入的变量，而不会创建一个副本。这意味着函数内部对 e 的修改将直接反映在传入的变量上。在这个例子中，e 是一个引用参数，函数 Pop 可以直接修改 main 函数中的变量。

2. 提高效率:

   • 传递引用通常比传递指针更高效，因为它避免了显式的解引用操作。而和按值传递相比，它避免了创建临时副本，从而节省了内存空间和拷贝时间。

3. 简化接口:

   • 如果函数通过返回值返回多个信息（例如成功与否和出栈元素本身），使用引用可以简化函数接口。因为返回值只能有一个，引用可以帮助提供额外的输出。

2：链表栈

#include<stdio.h>
typedef struct StackNode {
	int data;
	struct StackNode* next;
}StackNode,*LinkStack;

int InitStack(LinkStack &s)
{
	s = NULL;
	return 1;
}


bool isEmpty(LinkStack s) { // 栈空
	if (s == NULL) {
		return true;
	}
	return false;
}

int Push(LinkStack& s, int e)
{
	StackNode* p = new StackNode;
	p->data = e;
	p->next = s;
	s = p;
	return 1;
}

void pop(LinkStack& s,int num)//出栈
{
	if (isEmpty(s))
	{
		printf("栈空");
	}
	num = s->data;
	LinkStack p = s;
	s = s->next;
	delete p;
	printf("%d出栈成功\n", num);
	return;
}

void GetTop(LinkStack& s)//获得栈顶元素
{
	if (!isEmpty(s)) {
		printf("%d\n", s->data);
		return;
	}
}


void ShowStack(LinkStack s) { // 显示栈 
	if (!isEmpty(s)) {
		StackNode* p = s;
		while (p != NULL) {
			printf("%d  ", p->data);
			p = p->next;
		}
		printf("\n");
		return;
	}
}

int main()
{
	LinkStack s=new StackNode;
	InitStack(s);
	Push(s,10);
	Push(s, 50);
	Push(s, 60);
	Push(s, 60);
	Push(s, 90);
	ShowStack(s);
	
	pop(s,50);
	ShowStack(s);

	pop(s, 60);
	ShowStack(s);

	GetTop(s);

	return 0;
}