c語言棧的基本操作
❶ 棧的基本操作的c語言程序
#include <stdio.h>
#include <stdlib.h>
#define MAX 1024 ///棧使用數組模擬，MAX是最大元素個數
typedef int DataType; ///數據域使用整形
typedef struct _stack
{
DataType data[MAX]; ///存放數據
int top; ///棧頂指針
}stack;
///初始化
int initStack(stack (*s))
{
return emptyStack(s);
}
///數據壓棧，成功返回1，失敗返回0
int push(stack (*s), DataType d)
{
if ((*s).top >= MAX - 1) //棧已滿
{
printf("棧已滿，不能壓棧\n");
return 0;
}
//數據壓棧
(*s).top++;
(*s).data[(*s).top] = d;
return 1;
}
///數據出棧，成功返回1，d指向的區域存儲彈出的數據，失敗返回0
int pop(stack (*s), DataType *d)
{
if ((*s).top <= -1)
{
printf("棧為空，不能出棧\n");
return 0;
}
//出棧
*d = (*s).data[(*s).top];
(*s).top--;
return 1;
}
///清空棧
int emptyStack(stack (*s))
{
(*s).top = -1;
return 1;
}
int main(int argc, char** argv)
{
stack s;
int i, d;
initStack(&s);
//壓棧
for (i = 0; i < 1025; i++)
{
push(&s, i);
}
//清空
emptyStack(&s);
for (i = 0; i < 10; i++)
{
push(&s, i);
}
//出棧
for (i = 0; i < 11; i++)
{
pop(&s, &d);
printf("%d\n", d);
}
return 0;
}
❷ c語言 棧的操作
#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=0;i<Max;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;
}
❸ 數據結構實驗（用c語言寫） 棧的基本操作
//順序棧
#include
#include
#include
#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;i
#include
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;b
評論
0
0
載入更多
❹ 棧的基本操作
1、棧是一種先進後出的線性表，是最基本的一種數據結構
2、棧是限制插入和刪除只能在一個位置上進行的線性表
3、由於棧是線性表，所以可以使用鏈表或順序表實現
4、鏈棧（動態棧）：使用單鏈表實現棧。通過單鏈表的頭插法來實現入棧操作；通過刪除首節點來實現出棧操作；動態棧具有鏈表的部分特性，即元素與元素之間在物理存儲上可以不連續，但是功能有些受限制，動態棧只能在棧頂處進行插入和刪除操作，不能在棧尾或者棧中進行插入和刪除操作
5、順序棧（靜態棧）：每個棧都有一個topOfStack，用來表示棧頂在數組中的下標；需要注意的是對空棧的pop操作和對滿棧的push操作都會產生數組越界並引起程序crash
❺ 那位大神能講下C語言中棧的使用啊
堆棧就是先入後出的數據結構。
如果用c語言來實現的話用個struct
先定義一個棧的節點
struct
node;
typedef
strcut
node
*
position;
typedef
position
stack;
stack
creat();
void
push(int,stack);
int
pop(stack);
int
top();
struct
node
{
int
element;
position
next;
}
stack
creat()
{
stack
s;
s=malloc(sizeof(struct
node));
s->next==NULL;
}
void
push(int
a,stack
s)
{
position
temp;
temp=malloc(sizeof(struct
node));
temp->element=a;
temp->next=s->next;:
s->next=temp;
}
int
pop(stack
s)
{
int
res=s->next->element;
position
temp=s->next;
s->next=temp->next;
free
temp;
}
int
top(stack
s)
{
return
s->next->element;
}
好啦，先creat()一個棧，再進行push
pop等。程序中忽略了麻煩的錯誤檢測給出了重點，當然還可以添加其他操作。。對了，頭文件也要加上。本人還是習慣用c++弄成一個類^_^
❻ 棧的基本操作的實現(c語言)，高手速來！！
/*程序錯誤太多*/ #include"stdio.h"
#include"stdlib.h"
#include"time.h"
#include"malloc.h"
#define
STACK_INIT_SIZE
10
//棧容量 typedef
struct
SqStack
{
int
top;
//棧頂當前指針
int
*base;
//棧空間數組
}SqStack; void
InitStack(SqStack
&S);
//構造空棧S
int
Push(SqStack
&S,int
e);
//入棧（棧地址，入棧數據）
返回0對，-1錯
int
Pop(SqStack
&S);
//出棧
（棧地址）返回棧頂數據
int
StackLength(SqStack
S);
//返回站的元素個數，即求棧長
void
Print_S(SqStack
S);
//顯示棧內數據 int
main()
{
SqStack
S;
int
i=0;
int
a,e;
InitStack(S);
srand((unsigned)time(NULL));
//srand((unsigned)time(NULL))以time函數值(當前時間)作為種子
printf("隨機填充5個元素為:
");
while(
i<5)
{
a
=
rand()%100;
printf("%d
",
a);
Push(S,a);
i++;
}
Print_S(S);
printf("請輸入要插入棧頂的元素:");
scanf("%d",&e);
Push(S,e);
Print_S(S);
printf("再彈出的棧頂元素為:%d
\n",Pop(S));
printf("棧的長度為:%d
\n",StackLength(S));
Print_S(S);
return
0;
} void
InitStack(SqStack
&S)
//構造空棧S
{
S.base
=
(int
*)malloc(STACK_INIT_SIZE
*
sizeof(int));
//分配組數空間，長度STACK_INIT_SIZE
if
(S.base==NULL)
{
printf("內存分配失敗!\n");
return;
}
S.top=-1;
} int
Push(SqStack
&S,int
e)
{
if(S.top>=STACK_INIT_SIZE)
{
printf("棧空間已滿，入棧失敗!\n");
return
-1;
}
else
{
S.base[++S.top]=e;
return
0;
}
} int
Pop(SqStack
&S)
//返回棧頂數據
{
if
(S.top>=0)
//棧內有數據
{
return
S.base[S.top--];
}
else
{
printf("空棧，無數據彈出!\n");
return
-1;
}
} int
StackLength(SqStack
S)
{
return
S.top+1;
} void
Print_S(SqStack
S)
{
printf("\n出棧顯示：");
if(S.top
==
-1)
printf("棧內無數據!\n");
else
{
while(S.top>=0
)
printf("%d
",Pop(S));
putchar('\n');
}
}
❼ 棧的操作，用c語言急！
#include <stdio.h>
#define MAXSIZE 100
#define ERROR -1
typedef struct
{
int element[MAXSIZE];
int top;
}stack;
void InitStack(stack *s)
{
s->top=0;
}
bool IsEmpty(stack s)
{
if(s.top==0)
return true;
return false;
}
bool IsFull(stack s)
{
if(s.top==MAXSIZE)
return true;
return false;
}
void push(stack *s,int x)
{
if(!IsFull(*s))
{
s->element[s->top]=x;
s->top++;
}
else
printf("stack overflow\n");
}
int pop(stack *s)
{
if(!IsEmpty(*s))
{
s->top--;
return s->element[s->top];
}
else
{
printf("stack flow\n");
return ERROR;
}
}
int getTop(stack *s)
{
if(!IsEmpty(*s))
return s->element[s->top];
else
{
printf("stack empty\n");
return ERROR;
}
}
void empty(stack *s)
{
InitStack(s);
}
int measureStack(stack s)
{
return s.top;
}
int main(int argc,char *argv[])
{
stack s;
InitStack(&s);
push(&s,1);
push(&s,2);
push(&s,3);
printf("%d\n",pop(&s));
while(s.top!=0)
printf("%d\n",s.element[--s.top]);
return 0;
}
❽ 棧的操作，用c語言急！
#include<stdio.h>
#include<malloc.h>
#define DataType int
#define MAXSIZE 1024
typedef struct
{
DataType data[MAXSIZE];
int top;
}SeqStack;
SeqStack *Init_SeqStack()//棧初始化
{
SeqStack *s;
s=(SeqStack *)malloc(sizeof(SeqStack));
if(!s)
{
printf("空間不足\n");
return NULL;
}
else
{
s->top=-1;
return s;
}
}
int Empty_SeqStack(SeqStack *s)//判棧空
{
if(s->top==-1)
return 1;
else
return 0;
}
int Push_SeqStack(SeqStack *s,DataType x)//入棧
{
if(s->top==MAXSIZE-1)
return 0;//棧滿不能入棧
else
{
s->top++;
s->data[s->top]=x;
return 1;
}
}
int Pop_SeqStack(SeqStack *s,DataType *x)//出棧
{
if(Empty_SeqStack(s))
return 0;//棧空不能出棧
else
{
*x=s->data[s->top];
s->top--;
return 1;
}//棧頂元素存入*x，返回
}
DataType Top_SeqStack(SeqStack *s)//取棧頂元素
{
if(Empty_SeqStack(s))
return 0;//棧空
else
return s->data[s->top];
}
int Print_SeqStack(SeqStack *s)
{
int i;
printf("當前棧中的元素:\n");
for(i=s->top;i>=0;i--)
printf("%3d",s->data[i]);
printf("\n");
return 0;
}
int main()
{
SeqStack *L;
int n,num,m;
int i;
L=Init_SeqStack();
printf("初始化完成\n");
printf("棧空：%d\n",Empty_SeqStack(L));
printf("請輸入入棧元素個數：\n");
scanf("%d",&n);
printf("請輸入要入棧的%d個元素：\n",n);
for(i=0;i<n;i++)
{
scanf("%d",&num);
Push_SeqStack(L,num);
}
Print_SeqStack(L);
printf("棧頂元素：%d\n",Top_SeqStack(L));
printf("請輸入要出棧的元素個數（不能超過%d個）：\n",n);
scanf("%d",&n);
printf("依次出棧的%d個元素：\n",n);
for(i=0;i<n;i++)
{
Pop_SeqStack(L,&m);
printf("%3d",m);
}
printf("\n");
Print_SeqStack(L);
printf("棧頂元素：%d\n",Top_SeqStack(L));
return 0;
}