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;
}
最後總結，原理就是利用棧的先進後出的特性來實現逆置的。有什麼不懂可以再提問。