C语言解决链栈

#include <stdio.h>

//#include<stdlib.h>

#include <malloc.h>

typedef int DataType

typedef struct node {

DataType data

struct node *next

}Node,*Stack,*ps

Stack GetEmptyStack() {

Stack 简羡s = (ps)malloc(sizeof(Node))

s->next = NULL

return s

}

void InitStack(Stack &s) { //链栈初始化

s =  (ps)malloc(sizeof(Node)) // 配置头结点方便后续 *** 作

s->next = NULL 

}

void DestroyStack(Stack s) {//销毁链栈

ps q,p = s->next

while(p) { //依次释放链栈的每一个结点

q = p

p = p->next

free(q)

//p = s

}

free(s) //最后删除头结点

}

void Push(Stack &s,DataType x) { //入栈 *** 作

ps t = (ps)malloc(sizeof(Node)) 

t->data = x

t->next = s->next

s->next = t

}

int Empty(Stack s) {

return (s->next == NULL)

}

int Pop(Stack s,DataType 散颤*ptr) {

ps p

if(Empty(s)) {

printf("下溢错误，删除失败。\n")

ptr = NULL

return 0 // 0返回值时，ptr指向的内容不可用

}

p = s->next

*ptr = p->data // 存取要删除的栈顶元素

s->next = p->next // 头指针指向下一个数据结点

free(p)

return 1

}

int GetTop(Stack s,DataType *ptr) { //取栈顶元素

if(Empty(s)) {

printf("下溢错误。冲咐败\n")

return 0

}

*ptr = s->next->data

return 1

}

int main() {

DataType x

Stack s = GetEmptyStack() // 定义链栈的栈顶指针并初始化

// InitStack(s) // 指针相当于一个地址&

printf("对15和10进行入栈 *** 作\n")

Push(s,15)

Push(s,10)

if(GetTop(s,&x)) printf("当前栈顶元素为:%d\n",x) // 输出当前栈顶元素10

if(Pop(s,&x)) printf("执行一次出栈 *** 作，等同于删除栈顶元素:%d\n",x) // 输出出栈元素10

if(GetTop(s,&x)) printf("现在的栈顶元素为:%d\n",x) // 输出当前栈顶元素15

printf("请输入待插元素:")

scanf("%d",&x)

Push(s,x)

if(Empty(s)) printf("栈为空。\n")

else printf("栈并不为空。\n")

return 0

}

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#define elemType int /* 链栈元素数据类型 */

#define SNODE_SIZE sizeof (struct sNode) /* 链栈结点空间大小 */

#define status int /* 状态型变量 */

#define OVERFLOW -1 /* 内存溢出状态码 */

#define ERROR 0 /* 错误状态码 */

#define OK 1 /* 正确状态码 */

/* 链栈结点存储结构 */

typedef struct sNode {

elemType data

struct sNode *next

} sNode, *sNodePtr

/* 链栈存储结构 */

typedef struct linkStack {

sNodePtr top /* 栈顶指针 */

} linkStack

/* 初始化 */

/* 态逗纳 *** 作结果：构造一个带头结点的空链栈S */

void initStack (linkStack *S) {

S->top = (sNodePtr) malloc (SNODE_SIZE) /* 产生头结点，栈顶指针指向此头结点 */

if (!S->top) /* 内存分配失败 */

exit (OVERFLOW)

S->top->next = NULL

}

/* 销毁 */

/* 初始条件：链栈S已存在。 *** 作结果：销毁链栈S */

void destroyStack (linkStack *S) {

sNodePtr p, q

p = S->top /* p指向S的头结点 */

while (p) {

q = p->next /* q指向p的下一个结点 */

free (p) /* 回收p指向的结点 */

p = q /* p移动到下一个结点 */

} /* 直到没有下一个结点 */

}

/* 清空 */

/* 初始条件：链栈S已存在。 *** 作结果：将S重置为空栈 */

void clearStack (linkStack *S) {

sNodePtr p, q

p = S->top->next /* p指向栈的第一个结点 */

while (p) {

q = p->next /* q指向p的下一个结点 */

free (p) /* 帆没回收p指向的结点 */

p = q /* p移动到下一个结点 */

}  /* 直到没有下一个结点 */

S->top->next = NULL

}

/* 判断链栈是否为空 */

/* 初始条件：链栈S已存在。 *** 作结果：若S为空链栈，则返回TRUE，否则返回FALSE */

status stackIsEmpty (linkStack *S) {

return S->top->next == NULL

}

/* 入栈 */

/*  *** 作结果：在S的栈顶插入新的元素e */

status push (linkStack *S, elemType e) {

sNodePtr p

p = (sNodePtr) malloc (SNODE_SIZE) /* 产生新结点 */

if (!p) /* 内存分配失败 */

exit (OVERFLOW)

p->data = e

p->next = S->top->next /* 将新结点链接到原栈顶 */

S->top->next = p /* 栈顶指向新结点 */

}

/* 打印栈内容 */

/* 初始条件：链栈S已存在。 *** 作结果：当栈不为空时，打印栈内容并返回OK，否则返回ERROR */

status printStack (linkStack *S) {

sNodePtr p

if (stackIsEmpty (S)) {

puts ("The stack is empty! ")

return ERROR

}

p = S->top->next

while (p) {

printf ("%d\t", p->data)

p = p->next

}

putchar ('\n')

return OK

}

int main (void) {

linkStack S

elemType e 

elemType a, b, c, d

a = 1 b = 2 c = 3 d 指此= 4

initStack (&S)

push (&S, a)

push (&S, b)

push (&S, c)

push (&S, d)

printf ("S:\t")

printStack (&S)

putchar ('\n')

puts ("Clear the stack")

clearStack (&S)

printf ("S:\t")

printStack (&S)

destroyStack (&S)

getch () /* 屏幕暂留 */

return 0

}

如有问题，点击头像联系我

#include

#include

#define Max 100

typedef char T

typedef struct MyStack

{

T aa[Max]

unsigned int p

} stack

//创建空栈

stack* createEmptyStack()

{

stack* st = (stack *)malloc(sizeof(stack))

int i=0

for(i=0i<Maxi++)

st->aa[i]=0

st->p=0

return st

}

//栈判空

int isEmpty(const stack* st)

{

if(st->p==0) return 1

else return 0

}

//求栈的大小

unsigned int size(const stack* st)

{

return st->p

}

//push *** 作

void push(stack* st,const T a)

{

st->p=st->配圆桥p+1

if(st->p==Max)

{

printf("栈培猛满\n")

st->p--

return

}

st->aa[st->p]=a

}

//pop *** 腔碰作

T pop(stack* st)

{

if(isEmpty(st))

{

printf("栈空")

return NULL

}

char t=st->aa[st->p]

st->p=st->p-1

printf("%c ",t)

return t

}

//栈销毁

void destroy(stack* st)

{

free(st)

}

int main()

{

stack* st = createEmptyStack()

if(isEmpty(st)) printf("MyStack is empty\n")

else printf("MyStack is not empty\n")

push(st,'a')

push(st,'b')

push(st,'c')

push(st,'d')

push(st,'e')

printf("%d\n",size(st))

while(!isEmpty(st)) pop(st)

destroy(st)

system("pause")

return 0

}

---