1. 在c语言中该怎样建立栈具体代码是什么
1.栈空间（stack段）用来存放函数中的局部变量和函数调用时的上下文。
2.
全局变量和静态变量存放于进程的数据段。
3.
windows下进程的栈空间会自动增长，一般不会出现空间不足的问题；
4。如果变量实在太大，甚至大于栈可增长的范围，如数百兆，则会编译出错。
2. C语言 链表栈的问题！
int empty(stack *s) {
if (length_stack(s)) {
return 1;
} else {
return -1; //此处改为return 0；
}
}
main里while(empty(&st))条件判断需要empty返回为0时才会停止，你的empty返回值有1和-1，while就死循环了。
3. 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);
4. 12345链表出入栈c语言写法
给你个完整的：
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;
typedef struct linknode{
data_t data;
struct linknode *next;//结构体不完整类型，可以定义指针，但是不能引用内容
}link_t;
link_t *creat_link()
{
link_t *head;
head = malloc(sizeof(link_t));
head->next = NULL;
return head;
}
/*在链表的头结点 之后 第零个元素之前插入以新数据*/
int ins_head_link(link_t *head,const data_t *data)
{
//1.申请空间
//2.保存数据，指针指向，插入位置的下一个元素
//3.头结点里的指针指向，新结点
link_t *newnode;
newnode = malloc(sizeof(link_t));
newnode->data = *data;
newnode->next = head->next;
head->next = newnode;
return 0;
}
int ins_index_link(link_t *head,int index,const data_t *data)
{
//1.定位
//2.插入
while(index -- ){
head = head->next;
if(NULL == head)
return -1;
}
ins_head_link(head,data);
return 0;
}
int del_head_link(link_t *head)
{
link_t *temp;
if(NULL == head->next)
return -1;
temp = head->next;// (*head).next
head->next = temp->next;// head->next->next;
free(temp);
return 0;
}
int del_index_link(link_t *head,int index)
{
if(NULL == head->next)
return -1;
//1.定位到要删除结点的前一个
while(index --){
head = head->next;
if(NULL == head->next)
return -1;
}
//2.执行删除
del_head_link(head);
return 0;
}
/*找到一个元素并 返回该元素结点的前一个结点的地址*/
link_t *locate_link(link_t *head,const data_t *data)
{
while(NULL != head->next){
if(*data == head->next->data)
return head;
head = head->next;
}
return NULL;
}
int del_locate_link(link_t *head,const data_t *data)
{
head = locate_link(head,data);
if(NULL != head)
return del_head_link(head);
return -1;
}
int ins_locate_link(link_t *head,const data_t *data,const data_t *newdata)
{
head = locate_link(head,data);
if(NULL != head)
return ins_head_link(head,newdata);
return -1;
}
int get_head_link(link_t *head,data_t *databuf)
{
if(NULL == head->next)
return -1;
*databuf = head->next->data;
return 0;
}
int length_link(link_t *head)
{
link_t *h;
int count = 0;
h = head->next;
while(NULL != h){
count ++;
h = h->next;
}
return count;
}
int empty_link(link_t *head)
{
return NULL == head->next;
}
int change_index_link(link_t *head,int index,const data_t *newdata)
{
if(NULL == head->next)
return -1;
//1.定位到要删除结点的前一个
while(index --){
head = head->next;
if(NULL == head->next)
return -1;
}
//2.执行更新
head->next->data = *newdata;
return 0;
}
int clean_link(link_t *head)
{
while(0 == del_head_link(head))
;
return 0;
}
int dis_link(link_t **headp)
{
clean_link(*headp);
free(*headp);
*headp = NULL;
return 0;
}
void print_link(link_t *head)
{
link_t *h;
h = head->next;
while(NULL != h){
printf("%d ",h->data);
h = h->next;
}
printf("\n");
}
int main(int argc, const char *argv[])
{
link_t *head;
link_t *node;
int i;
data_t buf;
head = creat_link();
for(i = 7;i >= 0;i --){
ins_head_link(head,&i);
}
print_link(head);
buf = 250;
ins_index_link(head,9,&buf);
// del_index_link(head,8);
print_link(head);
buf = 0;
node = locate_link(head,&buf);
if(NULL != node)
printf(">>:%d\n",node->next->data);
else
printf("not fund\n");
buf = 123;
change_index_link(head,5,&buf);
print_link(head);
del_locate_link(head,&buf);
print_link(head);
dis_link(&head);
return 0;
}
5. 用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; //将头指针向下移动
}
}
6. c语言怎样把链表中的数据导入到栈中
晕。。。你的栈的*S.top++=p->data;就可以了
7. C语言：用栈来逆置一个单链表，哪位大神能给出下面代码的详细的解释谢谢
#include <stdio.h>
#include<stdlib.h>
#define stacksize 100
typedef int datatype;//这里所谓的datatype关键字是不存在的，所以这里用typedef (类型定义) 定义成int 型，意思是datatype 就是int
typedef struct
{
datatype data[stacksize];
int top;
}seqstack;//这里定义了栈（其实就是结构体，里面有个int型的数组和int型的成员），在下面有栈的一些运算，
typedef struct node
{
datatype data;
struct node *next;
}listnode;//这里定义了链表。int 型成员和 node * 指针
typedef listnode *linklist;//定义linklist指针，就是listnode 类型的指针
linklist h;
linklist p;
int x;
linklist creatlist(int n) //这里是创建链表
{
linklist h;
listnode *p1,*p2;
int i;
h=(linklist)malloc(sizeof(listnode));/*这里是为 h 这个结点（或者可称为结构体，它本来的面目）,申请内存空间，大小就是（sizeof(listnode)，就是结构体所占大小）*/
h->next=NULL; /*逆置单链表初始为空*/
p2=h;
printf("请输入链记录!:
");
for(i=0;i<n;i++)//这里就输入n个记录，比如1，2，3，4，5
{
p1=(linklist)malloc(sizeof(listnode));//同上
scanf("%d",&p1->data);//输入该节点中的数据成员data的值
p1->next=p2->next; /*将当前处理节点p插入到逆置L的表头*/
p2->next=p1;
p2=p1; /*p指向下一个待插入的节点*/
}
return (h);
}
void print(linklist h,int n)//将该链表打印出来
{
if(h==NULL)
printf("链表为空!
");
printf("这%d个链记录是:
",n);
p=h->next;
printf("%d",p->data);
x=1;
while(p->next!=NULL)
{
x++;
p=p->next;
printf("%4d",p->data);//这里就是P指针一直指向next, 循环打印，直到p=NULL..
if(!(x%10))
printf("
");// - -这里应该是每打印10次就换行的意思。
}
}
datatype push(seqstack *s,int x) /*这里就是栈的操作，进栈，返回类型为datatype，实际上就是int,这里说下参数，第一个参数是指向栈的指针类型，第二个参数是你要进栈的值*/
{
if(s->top==stacksize-1)//超出栈的大小
printf("堆栈溢出!
");
else
s->data[++s->top]=x;
}
datatype pop(seqstack *s) //和上面相同，这个是出栈，return 栈的元素的值
{
if(s->top==-1)
printf("堆栈为空!
");
else
return (s->data[s->top--]);
}
datatype deleted(linklist h)//删除链表结点的值，并将该结点中data值放到temp
{
datatype temp;
linklist p;
p=h->next;
temp=(p->data);
h->next=p->next;
free(p);//这步重要！释放结点所占的空间
return (temp);
}
void invertedlist(linklist h,int n)//
{
seqstack s;
int i,j,temp;
s.top=-1;
for(i=0;i<n;i++)//说白了就是将链表的值依次进栈
{
temp=deleted(h);
push(&s,temp);
}
for(i=0;i<n;i++)//然后将各个值依次出栈
{
temp=pop(&s);
printf("%5d",temp);
if(!((i+1)%10))
printf("
");
}
printf("
");
}
main()
{
linklist h;
int n;
printf("请输入n的值:
");
scanf("%d",&n);
h=creatlist(n);
print(h,n);
printf("
");
printf("经过逆置,链记录为:
");
invertedlist(h,n);
system("pause");
return 0;
}
最后总结，原理就是利用栈的先进后出的特性来实现逆置的。有什么不懂可以再提问。