你在main里調用InitStack初始化棧，後面就可以Push Pop進出了
B. c語言 為什麼棧的初始化時候棧頂指針要指向-1
這種初始化是用於線性棧的，也就是用一個數組來組成棧，棧頂指針廳消值為當前棧頂元素的下標值。
當有數據入棧時，會先執行棧頂指針自加。
初始化為空棧，
規定空棧的時候指向-1，這樣在有握伏知第一個元素入棧的時候棧段消頂指針就可以通過自加指向0元素，從而避免其它判斷。
C. C語言中如何初始化棧 每個元素均為空
<1>如果順序棧的定義如下
typedef struct
{datatype data[stacksize];
int top;
}SeqStack;
---則置空棧的操作如下
void InitStack(seqstack *s)
{s->top=-1;
}
<2>如果鏈棧的定義如下
typedef struct node
{datatype data;
struct node *next;
}LinkStack;
---則置空棧的操作如下
void InitStack(linkstack *s)
{s->top=null;
}
D. C語言中鏈棧 棧頂指針始終指向NULL
你的問題很仿拿簡單，就是你沒有區分清楚函數形參和實參之間傳值和傳址的區別。
#include <stdio.h>
#include <malloc.h>
typedef struct node { int data;
struct node *next;
} stacknode;
/*
stacknode *initnode()
{
stacknode *top; //這聲明的是個局部變數，你這里這樣用是沒有意義的，因為局部變數在函數結束後就釋放了
top = NULL;
return top;
}
//修改為：*/
void initnode(stacknode **top)
{
*top = NULL;
}
int emptynode(stacknode * top) //判空
{
if (top == NULL)
return 1;
else
return 0;
//return top == NULL;//可寫為一行代備乎搭碼
}
/*從本質上來說，函數調用都是值傳遞的。這里，crnode(top)的實參top把top的值賦給了crnode函數里形參top的值，即相當於top(形參) = top(實參);注意，這里兩個top是不一樣的變數，兩者的內存地址也不同，形參top是crnode函數里分配的內存，而實參top則是main函數里分配的內存。所以你crnode函數里去改變top的值當然就不會相對應的改變main函數里top的值*/
/*void crnode(stacknode * top) //進棧
{
stacknode *p; int i;
for (i = 0; i < 5; i++) {
p = (stacknode *) malloc(sizeof(stacknode));
printf("input data:\n");
scanf("%d", &p->data);
p->next = top;
top = p; //這樣是無法改變主函數里top的值的，只是改變了該函數里top指針的值
}
}
//修改為：*/
void crnode(stacknode ** top) //進棧,
{
stacknode *p; int i;
for (i = 0; i < 5; i++) {
p = (stacknode *) malloc(sizeof(stacknode));
printf("input data:\n");
scanf("%d", &p->data);
p->next = *top;
*top = p;
}
}
int numnode(stacknode * top) //計棧中結點數
{
stacknode *p, *s;
int i = 0; //i應該從0開始，這樣當top為NULL時i才會為0
s = top;
while (s != NULL) {
p = s->next;
s = p;
i++;
}
return i;}
void outnode(stacknode * top) //出棧
{
stacknode *p;
int x;
while (top != NULL) {
x = top->data;
printf("%d\t", top->data);
p = top->next;
top = p;
//top = top->next;//上面兩個代碼寫為一行就行了。。。
}
}
void main()
{
int i;
stacknode *top;
initnode(&top);//top = initnode();
i = emptynode(top);
if (i == 1)
printf("棧空");
crnode(&top);/頃老/crnode(top);
i = emptynode(top);
if (i == 1)
printf("棧空");
printf("%d\n", numnode(top));
outnode(top);
i = emptynode(top);
if (i == 1)
printf("棧空");
}
E. C語言中鏈棧 棧頂指針始終指向NULL
調用c函數是把實參值傳給形參，在
crnode(top);
這一句處，是把top
這個指針的值，也就是NULL
傳個函數培判脊crnode
的形參，在進棧時，只是對crnode函數里的
top
變數做了改變，如top
=
p;
但是
在main函數里的
top
和
crnode函數里的
top
完全是兩個不同的變數，所以main
函數里的
top
始終為NULL。
另外說一下，你剛開始學編程吧，編程要仔細理解你寫的東西到底做什麼用，也就是真正了解你的代碼，就像你寫的那個初始化函數，僅僅是返回一個空值給了top，其他什麼都沒做，還不如直接
top
=
NULL
來的爽快。
又例如這個函數
void
outnode(stacknode
*top)//出棧
{
stacknode
*p;
int
x;
while(top!=NULL)
{
x=top->data;
printf("%d\t",top->data);
p=top->沖散next;
top=p;
}
}
你定義配滲的
x
是干什麼用的，僅僅是為了給它賦個值嗎？
等等吧，再好好看看書吧，編程要仔細理解
F. C語言鏈棧問題
#include<stdio.h>
#include<malloc.h>
#define null 0
typedef struct node
{
int data;
struct node *next;
}linkstack;
linkstack *top;
/*linkstack *initstack(linkstack *top) //初始化棧將棧的數據設空//
{
top->next=null;
return top;
} 這個函數沒必要。return (top->next==null);也是錯的。*/
linkstack *push(linkstack *top,int x) ////入棧
{
linkstack *p;
p=(linkstack*)malloc(sizeof(linkstack));
p->data=x;
p->next=top;////要理解棧的結構，棧頂是鏈表的頭部，所以p->next要指向即時的top////
top=p;
return top;
}
linkstack* pop(linkstack *top) //出棧
{
linkstack *p;
if(!top)
{
printf("空鏈棧");
return null;
}
p=top;
top=top->next;
free(p); //釋放存儲空間
return top;
}
void print(linkstack *top) //輸出棧
{
linkstack *p;
p=top;
while(p!=null) ////剛開始棧頂的next項為空////
{
printf("%d\n",p->data);
p=p->next;
}
}
void main()
{
int x,i;
top=(linkstack*) malloc(sizeof(linkstack));
scanf("%d",&x);
top->data=x;//頭部賦值。
top->next=null;
// initstack(top);
for(i=1;i<=3;i++)
{
scanf("%d",&x);
top=push(top,x);//返回一個指針。
}
print(top);
top=pop(top);//返回一個指針。
print(top);
}
G. C語言解決鏈棧
#include<stdio.h>
//#include<stdlib.h>
#include<malloc.h>
typedefintDataType;
typedefstructnode{
DataTypedata;
structnode*next;
}Node,*Stack,*ps;
StackGetEmptyStack(){
Stacks=(ps)malloc(sizeof(Node));
s->next=NULL;
returns;
}
voidInitStack(Stack&s){//鏈棧初始化
s=(ps)malloc(sizeof(Node));//配置頭結點方便後續操作
s->next=NULL;
}
voidDestroyStack(Stacks){//銷毀鏈棧
psq,p=s->next;
while(p) {//依次釋放鏈棧的每一個結點
q=p;
p=p->next;
free(q);
//p=s;
}
free(s);//最後刪除頭結點
}
voidPush(Stack&s,DataTypex){//入棧操作
pst=(ps)malloc(sizeof(Node));
t->data=x;
t->next=s->next;
s->next=t;
}
intEmpty(Stacks){
return(s->next==NULL);
}
intPop(Stacks,DataType*ptr){
psp;
if(Empty(s)){
printf("下溢錯誤，刪除失敗。
");
ptr=NULL;
return0;//0返回值時，ptr指向的內容不可用
}
p=s->next;
*ptr=p->data;//存取要刪除的棧頂元素
s->next=p->next;//頭指針指向下一個數據結點
free(p);
return1;
}
intGetTop(Stacks,DataType*ptr){//取棧頂元素
if(Empty(s)){
printf("下溢錯誤。
");
return0;
}
*ptr=s->next->data;
return1;
}
intmain(){
DataTypex;
Stacks=GetEmptyStack();//定義鏈棧的棧頂指針並初始化
// InitStack(s);//指針相當於一個地址&
printf("對15和10進行入棧操作
");
Push(s,15);
Push(s,10);
if(GetTop(s,&x))printf("當前棧頂元素為:%d
",x);//輸出當前棧頂元素10
if(Pop(s,&x))printf("執行一次出棧操作，等同於刪除棧頂元素:%d
",x);//輸出出棧元素10
if(GetTop(s,&x))printf("現在的棧頂元素為:%d
",x);//輸出當前棧頂元素15
printf("請輸入待插元素:");
scanf("%d",&x);
Push(s,x);
if(Empty(s))printf("棧為空。
");
elseprintf("棧並不為空。
");
return0;
}
H. 求編程高手用c語言編寫鏈棧完整源代碼
/****************************************************************************************
實現鏈棧各種基本運算的演算法 *
編寫程序實現鏈棧種基本運算，並在此基礎上設計一個主程序完成如下功能：
1、 初始化棧
2、 判斷棧是否為空
3、 依次進棧a,b,c,d,e元素。
4、 判斷棧是否為空
5、 輸出棧的長度
6、 輸出從棧頂到棧底元素
7、 輸出出棧序列
8、 判斷棧是否為空
9、 釋放棧/
*********************************************************************************************/
#include<iostream.h>
#include<stdlib.h>
#include<stdio.h>
#define OVERFLOW -2
#define ok 1
#define STACK_INIT_SIZE 100 //存儲空間初始分配量
#define STACKCREMENT 10 //增加分量
typedef struct{
char *base;
char *top;
int stacksize;//當前分配的空間
int lenght;
}SqStack; //Sqlist
/*********************************初始化棧*************************************/
int InitStack(SqStack &S)
{
S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));// 分配存儲空間
if(!S.base) exit(0);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
S.lenght=0;
return 1;
}
/******************************************************************************/
/********************************判斷棧是否為空******************************/
bool StackEmpty(SqStack&S){
if(S.top==S.base)return 1;
else
return 0;
}
/*****************************釋放棧********************************/
int FreeStack(SqStack&S)
{
free(S.base);
S.top=S.base;
return ok;
}
/******************************************************************/
/*********************求出棧的長度*********************************/
int StackLenth(SqStack&S){
S.lenght=S.top-S.base;
return S.lenght;
}
/******************************************************************/
/**********************入棧*****************************************/
int Push(SqStack &S,char e){
if(S.lenght>=S.stacksize){
S.base=(char*)realloc(S.base,(S.stacksize+STACKCREMENT)*sizeof(char));//增加分配存儲
if(!S.base) exit(OVERFLOW);
S.top=S.base+S.stacksize;
S.stacksize+=STACKCREMENT;
}
*S.top++=e;
S.lenght++;
return ok;
}
/**************************************************************/
/****************************出棧****************************/
char Pop(SqStack&S,char &e){
if(S.base==S.top)
return 0; //當棧為空時，返回錯誤
else
e=*--S.top;
S.lenght--;
return e;
}
/*************************顯示*******************************/
void DispStack(SqStack S)
{
int i;
for(i=S.lenght;i>0;i--)
{
printf("%c",*(--S.top));
}
printf("\n");
}
//*******************主函數************************************/
int main(){
int i;
SqStack Lst;
char a,b,c,d,e,f;
char g;
printf("初始化棧:\n");
InitStack(Lst);
printf("依次進棧元素a,b,c,d,e,f\n");
cin>>a>>b>>c>>d>>e>>f;
Push(Lst,a);
Push(Lst,b);
Push(Lst,c);
Push(Lst,d);
Push(Lst,e);
Push(Lst,f);
printf("列印\n");
DispStack(Lst);
int l=StackLenth(Lst);
cout<<"棧的長度為"<<l<<endl;
printf("出棧序列:");
for(i=1;i<=6;i++)
{
Pop(Lst,g);
printf("%c ",g);
}
printf("\n");
printf("棧為:%s\n",(StackEmpty(Lst)?"空":"非空"));
printf("釋放棧\n");
FreeStack(Lst);
return 0;
}
可以正確運行，你看下可以不？？希望能幫到樓主！ 我用visual C++6.0編譯的，現在主流都是用這個，不好意思，WINTC我沒有用過，樓主可以自己改嗎？？
額，你們老師太不人道了，WINTC好像在後面得加一個getch()吧？？這個軟體我沒有用過
I. C語言數據結構 棧的初始化
base被定義為int的指針，卻傳給他一個char型的指針
char和int雖然經常通用，但char是8位，int是16位，兩者還是不一樣的。
J. 鏈表初始化的問題，指針問題。
最近學習鏈表棧隊列時候，發現邏輯上來說這幾個問題是很容易就搞明白的，但是具體實現尤其是用C語言實現，這個指針參數的傳入，有很大的問題，還牽扯到malloc函數的亮模調用的用法，我來一一總結一下。
關於棧鏈初始化，我們一般來說用以下方法。
typedef struct SNode *Stack;
typedef struct SNode{
ElementType Data;
Stack Next;
};
Stack InitStack(){
Stack S = (Stack)malloc(sizeof(struct SNode));
S->Next=NULL;
return S;
}
我們先定義了一個SNode的結構體，是節點，然後我們定義了Stack 是一個指針變數指向了SNode,實際上它就是鏈表的最開始的頭指針，然後我們進行初始化，定義頭節點指針為S，這時候我們注意，Stack是一個指針型變數，指向的是結構體，因此，malloc分配函數直接進行強制轉化 左邊括弧就是Stack, 轉化成了一種指針類型，我們順便復習一下malloc的用法，malloc函數分配就是動態的分配內存，右邊括弧是計算出需要用的位元組數，也即是我們申請存放變數的類型位元組數，前面的括弧里的即是要轉化成的指針類型，是屬於一種強制類型轉化。最後我們定義S的下一個節點是空，這樣就可以完成初始化了形成一個空棧。
值得一提的是，malloc申請分配完的內存在使用完畢後需要free，將其釋放。
再例如以下初始化。
typedef struct Node
{
StackElementType data;
struct node *next;
} LinkStackNode;
typedef LinkStackNode *LinkStack;
void initStack(LinkStack *L)
{
*L=(LinkStack)malloc(sizeof(Node))
(*L)->next=NULL;
}
這種初始化和上面那種初始化實際上是一樣的，雖然看起來有較大差異，同樣的，我們定義了一個Node節點的結構體，然後LinkStack是一個指向結構敬正緩體的指針，我們初始化的參數是一個指向指針的指針L，因此在初始化過程清滲中我們用的是*L，這里的*L是指向頭節點的指針變數也即使前一種方法裡面的Stack。
我們一定要分清楚，前者是不用二重指針的，因為它有了返回值，而後者需要用二重指針，原因就在於我們需要改變一重指針的下一個節點，也就是改變一重指針的內容，因此我們需要用到指向該一重指針的指針，也就是二重指針，聽起來很難理解，但是實際上我們可以把一重指針想像成一個普通變數，我們要在函數里修改該變數並且將其返回主函數，要麼是有返回值，要不然就是傳入該變數的地址，通過該地址來改變，也即使傳入該變數的指針，這么說想必大家就明白了這兩種方法的區別。鏈表初始化的問題也就搞明白了，鏈表初始化的目的就是我們要新建一個頭指針，讓其指向為空。