如何用C语言创建一个链栈，并进行操作

1 思路: 主要是链表的插入和删除操作

创新互联公司是一家专业提供龙湾企业网站建设,专注与成都网站设计、网站建设、H5场景定制、小程序制作等业务。10年已为龙湾众多企业、政府机构等服务。创新互联专业的建站公司优惠进行中。

2 代码

#includestdio.h

#includestdlib.h

typedef struct node

{

int  data;

struct node *next;

}node_type;

void push(node_type* stack, int elem){

node_type*node = (node_type*)malloc(sizeof(node_type));

node-data = elem;

node-next = stack;

stack = node;

}

int pop(node_type* stack){

int elem = stack-data;

node_type*node = stack;

stack = stack-next;

free(node);

return elem;

}

bool IsEmpty(node_type* stack){

return stack == NULL;

}

void display(node_type*stack){

while (stack){

printf("%d ", stack-data);

stack = stack-next;

}

puts("");

}

void destroy(node_type*stack){

while (!IsEmpty(stack)){

pop(stack);

}

}

int main(){

puts("(1) 建立空链栈");

node_type*stack = NULL;

puts("\n(2) 调用进栈函数，将从键盘输入的数据元素逐个进栈，输入0结束；");

int num;

scanf("%d", num);

while (num != 0){

push(stack, num);

scanf("%d", num);

}

puts("\n(3) 显示进栈后的数据元素");

display(stack);

puts("\n(4) 调用两次出栈函数，显示出栈后的数据元素");

if (!IsEmpty(stack))

printf("%d\n", pop(stack));

if (!IsEmpty(stack))

printf("%d\n", pop(stack));

destroy(stack);

getchar();

getchar();

return 0;

}

3 运行效果

用C语言中的链表如何实现栈？

struct point{

point *last;

int data;

};

int main(){

cin n;

point *top = NULL;

for(int i = 1 ; i = n ; i++){

scanf("%d" , x);

point *p = new point;

p - data = x; //入栈

p - last = top;

top = p; // 将头指针指向最后一个

}

while (top != NULL){//判断栈是否为空

cout top - data endl; //输出栈顶元素

top = top - last; //将头指针向下移动

}

}

C语言单链表实现栈 菜鸟求教

NODE * x = head; NODE * y = 0;

int i = 0;

for(i = 0; i 8; i++) x = x-next;

y = x-next;

x-next = y-next;

free(y);

数据结构实验（用c语言写） 栈的基本操作

//顺序栈

#includestdio.h

#includestdlib.h

#includemalloc.h

#define STACK_INIT_SIZE 100;

#define STACKINCREMENT 10;

typedef struct

{

int *base;

int *top;

int stacksize;

}SqStack;

typedef int ElemType;

int InitStack(SqStack S) //为栈S分配存储空间，并置S为空栈

{

int size = STACK_INIT_SIZE;

S.base=(int *)malloc(size*sizeof(ElemType));

if(!S.base)

return 0;

S.top=S.base; //置栈S为空栈

S.stacksize=STACK_INIT_SIZE;

return 1;

}

int GetTop(SqStack S,int e) //若栈不空，则用e返回S的栈顶元素

{

if(S.top==S.base) return 0;

e=*(S.top-1);

return 1;

}

int Push(SqStack S, int e) /*进栈函数,将e插入栈S中,并使之成为栈顶元素*/

{ if(S.top-S.base=S.stacksize) /*栈满，追加存储空间*/

{

int stackinvrement = STACKINCREMENT;

S.base=(ElemType *) realloc(S.base,(S.stacksize+stackinvrement)*sizeof(ElemType));

if(!S.base)

return 0; /*存储分配失败*/

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return 1;

}

int Pop(SqStack S,int e)/*出栈函数,若栈S不空,则删除S的栈顶元素,用e返回其值*/

{ if(S.top==S.base) return 0;

e=*--S.top;

return 1;

}

void OutputStack(SqStack S)

{int *q;

q=S.top-1;

for(int i=0;iS.top-S.base;i++)

{

printf("%3d ",*q);q--;}

}

void main()

{

int a,b,c ;

char m;

SqStack s;

InitStack(s);

printf("请输入要进栈的元素个数是:");

scanf("%d",a);

printf("\n请输入要进栈的%d个元素:",a);

for(b=0;ba;b++) {

scanf("%d",c);

Push(s,c); }

do { printf("\n");

printf("*********** 1.输出栈的元素**********\n");

printf("*********** 2.取栈顶元素************\n");

printf("*********** 3.删除栈顶元素**********\n");

printf("*********** 4.退出程序**********\n");

printf("\n请选择一个字符:");

getchar();

scanf("%c",m);

switch(m) {

case '1': printf("\n输出的栈为:");

OutputStack(s);

break;

case '2': GetTop(s,c);

printf("\n栈顶元素为:%d",c);

printf("\n输出的栈为:");

OutputStack(s);

break;

case '3': Pop(s,c);

printf("\n删除的栈顶元素:%d",c);

printf("\n输出的栈为:");

OutputStack(s);

printf("\n");

break;

case '4':break;

default: printf("输入的数字有错，请重新选择!\n"); break;

}

}while(m!='4');

}

//链栈

#includestdio.h

#includestdlib.h

typedef struct SNode

{

int data;

struct SNode *next;

}SNode,*LinkStack;

LinkStack top;

LinkStack PushStack(LinkStack top,int x) //入栈

{

LinkStack s;

s=(LinkStack)malloc(sizeof(SNode));

s-data=x;

s-next=top;

top=s;

return top;

}

LinkStack PopStack(LinkStack top) //退栈

{

LinkStack p;

if(top!=NULL)

{

p=top;

top=top-next;

free(p);

printf("退栈已完成\n");

return top;

}

else printf("栈是空的，无法退栈！\n"); return 0;

}

int GetStackTop(LinkStack top) //取栈顶元素

{

return top-data;

}

bool IsEmpty()//bool取值false和true，是0和1的区别,bool只有一个字节,BOOL为int型,bool为布尔型

{

return top==NULL ? true:false;

}

void Print()

{

SNode *p;

p=top;

if(IsEmpty())

{

printf("The stack is empty!\n");

return;

}

while(p)

{

printf("%d ", p-data);

p=p-next;

}

printf("\n");

}

void main()

{

int x,a,b;

char m;

do { printf("\n");

printf("###############链栈的基本操作##################\n");

printf("××××××××1.置空栈××××××××××\n");

printf("××××××××2.进栈×××××××××××\n");

printf("××××××××3.退栈×××××××××××\n");

printf("××××××××4.取栈顶元素××××××××\n");

printf("××××××××5.退出程序×××××××××\n");

printf("##############################################\n");

printf("\n请选择一个字符:");

scanf("%c",m);

switch(m){

case '1':

top=NULL;

printf("\n栈已置空!");

break;

case '2':

printf("\n请输入要进栈的元素个数是:");

scanf("%d",a);

printf("\n请输入要进栈的%d个元素:",a);

for(b=0;ba;b++) {

scanf("%d",x);

top=PushStack(top,x); }

printf("进栈已完成！\n");

printf("\n输出栈为:");

Print();

break;

case '3':

printf("\n操作之前的输出栈为:");

Print();

top=PopStack(top);

printf("\n操作过后的输出栈为:");

Print();

break;

case '4':

printf("\n输出栈为:");

Print();

if(top!=NULL)

printf("\n栈顶元素是：%d\n",GetStackTop(top));

else

printf("\n栈是空的，没有元素！");

break;

case '5':break;

default:

printf("\n输入的字符不对，请重新输入!");

break;

}

getchar();

}while(m!='5');

}

C语言数据结构实现链栈的入栈、出栈、删除与插入

1、栈（stack）又名堆栈，它是一种运算受限的线性表。

其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

2、例程：

#include stdio.h

#include stdlib.h

#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=0;iMax;i++)

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;

}

用链表存储堆栈内容，出栈入栈函数~~我快崩溃了！

1、main函数默认是int，需要一个return 0；

改成void，少一个警告。

void main()

2、typedef应用错误。

typedef struct node * list_pointer;

typedef struct node{

int key;

list_pointer *link;

};改成：

typedef struct node * list_pointer;

struct node{

int key;

list_pointer link;//已经是指针

};

3、list_pointer已经被定义为指针，不用再次指针：

main中：

lp=(list_pointer *)malloc(sizeof(node));

ptr=(list_pointer *)malloc(sizeof(node));

改为：

lp=(list_pointer)malloc(sizeof(node));

ptr=(list_pointer)malloc(sizeof(node));

add中：

p=(list_pointer *)malloc(sizeof(node));//因为你还没有定义

改为

list_pointer p=(list_pointer)malloc(sizeof(node));

4、null在C中没定义，只能用NULL，这是预定义过的

if(b-link==null)return(null);

——〉if(b-link==NULL)return(NULL);

5、deletes中p没有定义：

else

{

list_pointer p;

p=b-link;

x=p-key;

b-link=p-link;

free(p);

return(x);

}

6、deletes定义返回类型不对，应该为：

int deletes(list_pointer b);

7、如今是没错了，但是算法本身就有不可原谅的错误！

#includestdio.h

#includestdlib.h

#define Max 100

typedef struct node * list_pointer;

struct node{

int key;

list_pointer link;

};

void add(list_pointer a,int n);

int deletes(list_pointer b);

void main()

{

// int i;

list_pointer ptr,lp;

lp=(list_pointer)malloc(sizeof(node));

ptr=(list_pointer)malloc(sizeof(node));

add(ptr,5);

printf("%d",deletes(ptr));

free(ptr);

add(lp,6);

printf("%d",deletes(lp));

free(ptr);

}

void add(list_pointer a,int n){

list_pointer p=(list_pointer)malloc(sizeof(node));

p-key=n;

p-link=a-link;

a-link=p;

}

int deletes(list_pointer b){

int x;

if(b-link==NULL)return(NULL);

else

{

list_pointer p;

p=b-link;

x=p-key;

b-link=p-link;

free(p);

return(x);

}

}