关于栈:栈是一个先进后出的数据结构,简称LIFO结构。栈包含栈底和栈顶。其中栈底是第一个进栈(栈的插入)的元素,栈顶是最后一个进栈的元素。当栈里一个元素都没有时,称为空栈。

栈_#include

I.普通栈

1.建立栈

#define max 50
typedef struct
{
int data[max];
int top;
}Stack;

这个栈最多放50个元素

2.进栈

void InsertStack(Stack*L,int e)
{
if(L->top==Max)
return;//栈满了直接返回
else
{
++L->top;//栈从下标1开始存取元素
L->data[L->top]=e;
}
}

3.出栈

int PopStack(Stack*L,int*e)
{
if(L->top==0)
return;//空栈直接返回
else
{
*e=L->data[top];
--L->top;
}
return*e;
}

4.打印栈中元素

void PrintStack(Stack*L)
{
if(L->top==0)
return;
else
for(int i=1;i<=L->top;i++)
printf("%d ",L->data[i]);
}

5.总代码

#include<stdio.h>
#include<malloc.h>
//1.建立栈
#define Max 50
typedef struct
{
int data[Max];
int top;
}Stack;
//2.进栈
void InsertStack(Stack *L,int e)
{
if (L->top == Max)
return;
else
{
++L->top;
L->data[L->top] = e;
}
}
//3.出栈
int GoStack(Stack* L, int* e)
{
if (L->top == 0)
return;
else
{
*e = L->data[L->top];
L->top--;
}
return *e;
}
//4.打印栈中元素
void PrintStack(Stack* L)
{
if (L->top == 0)
return;
else
for (int i = 1; i <= L->top; i++)
printf("%d ", L->data[i]);
}
//5.代码实现
int main()
{
Stack* L = (Stack*)malloc(sizeof(Stack));
L->top = 0;//初始化
for (int i = 0; i < 10; i++)
InsertStack(L, i * 2);
PrintStack(L);
printf("\n");
int* e = malloc(sizeof(int));
GoStack(L, e);
PrintStack(L);
return 0;
}

II.两栈共享空间

就是有两个栈,一个是top1,Max=10;一个是top2,Max=20。

栈_#include_02

然后我们把它合成一块,就是Max=31,但是这个栈中有top1和top2。其中top1从1开始,top2从31开始。(1-31是为了代码原因,这里只要存储30个元素就行)。

栈_#include_03

然后就是代码这块了。

注意栈满了的条件是top1+1=top2;

1.建立栈

#define Max 31
typedef struct
{
int data[Max];
int top1;
int top2;
}Stack;

2.进栈

void InsertStack(Stack* L,int e, int Stacknum)//Stacknumber用来判断是否用top1还是top2
{
if (L->top1 + 1 == L->top2)//栈满就直接退出
return;
else
{
if (Stacknum == 1)
{
++L->top1;
L->data[L->top1] = e;
}
if (Stacknum == 2)
{
--L->top2;
L->data[L->top2] = e;
}
}
}

3.出栈

int GoStack(Stack*L,int*e,int Stacknum)
{
if (L->top1==0&&L->top2==Max)//空栈就直接退出
return;
else
{
if (Stacknum == 1)
{
*e=L->data[L->top1];
--L->top1;
}
if (Stacknum == 2)
{
*e = L->data[L->top2];
++L->top2;
}
}
return *e;
}

4.打印栈

void PrintStack(Stack* L,int Stacknum)
{
if (L->top1 == 0 && L->top2 == Max)//空栈直接退出
return;
else
{
if (Stacknum == 1)
for (int i = 1; i <= L->top1;++i)
printf("%d ", L->data[i]);
if (Stacknum == 2)
for (int i =Max-1;i>=L->top2;--i)
printf("%d ", L->data[i]);
}
}

5.总代码

#include<stdio.h>
#include<malloc.h>
#define Max 31
typedef struct
{
int data[Max];
int top1;
int top2;
}Stack;
//1.进栈
void InsertStack(Stack* L,int e, int Stacknum)//Stacknumber用来判断是否用top1还是top2
{
if (L->top1 + 1 == L->top2)//栈满就直接退出
return;
else
{
if (Stacknum == 1)
{
++L->top1;
L->data[L->top1] = e;
}
if (Stacknum == 2)
{
--L->top2;
L->data[L->top2] = e;
}
}
}
//2.出栈
int GoStack(Stack*L,int*e,int Stacknum)
{
if (L->top1==0&&L->top2==Max)//空栈就直接退出
return;
else
{
if (Stacknum == 1)
{
*e=L->data[L->top1];
--L->top1;
}
if (Stacknum == 2)
{
*e = L->data[L->top2];
++L->top2;
}
}
return *e;
}
//3.打印元素
void PrintStack(Stack* L,int Stacknum)
{
if (L->top1 == 0 && L->top2 == Max)//空栈直接退出
return;
else
{
if (Stacknum == 1)
for (int i = 1; i <= L->top1;++i)
printf("%d ", L->data[i]);
if (Stacknum == 2)
for (int i =Max-1;i>=L->top2;--i)
printf("%d ", L->data[i]);
}
}
int main()
{
Stack* L = malloc(sizeof(Stack));
L->top1 = 0, L->top2 = Max;//初始化,一定要.
for (int i = 0; i < 10; i++)
{
InsertStack(L, i * 2, 1);
InsertStack(L, i * 2, 2);
}
PrintStack(L, 1);
PrintStack(L, 2);
printf("\n");
int* e = malloc(sizeof(int));
GoStack(L, e, 1);
PrintStack(L, 1);
PrintStack(L, 2);
return 0;
}

注意:栈中不能遍历元素

III.链栈

栈中含有指针,也就意味着这个链栈是可以遍历元素的。

栈_i++_04

下面看一段代码,仅供参考。

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

void INit(StackNode** p, StackNode*** L)
{
(*p)->next =**L, ** L = *p;
++(**L)->count;
}
//1.进栈
void InsertStack(StackNode** L, int e)
{
StackNode* p = (StackNode*)malloc(sizeof(StackNode));
p->data = e; p->next = NULL; p->count = (*L)->count;//存取进来后栈中一共有多少个元素
INit(&p, &L);
}
//2.出栈
void PopStack(StackNode** L)
{
StackNode* p = (StackNode*)malloc(sizeof(StackNode));
p = *L; *L = (*L)->next;
free(p);
}
//3.打印栈
void PrintStack(StackNode* L)
{
StackNode* p = L;
for (int i = 0; i < L->count; i++)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int main()
{
StackNode* L = malloc(sizeof(StackNode)); L->next = NULL; L->count = 0;
for (int i = 0; i < 10; i++)
InsertStack(&L, i * 2);
PrintStack(L);
//删除栈顶元素
PopStack(&L);
PrintStack(L);
return 0;
}

我在这个指针上面就花了蛮长的时间,如果是函数(用指针作为形参!!!).