本文目录一览：
- 1、栈的基本操作的实现(c语言)，高手速来！！
- 2、数据结构实验（用c语言写） 栈的基本操作
- 3、用C语言实现栈的基本操作（数制的转换）
- 4、c语言 栈的操作
- 5、栈的c语言实现基本操作
- 6、栈的基本操作的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(
i5)
{
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
#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
评论
加载更多
用C语言实现栈的基本操作（数制的转换）
//顺序栈以及基本操作如下：
#includeiostream.h
enum
{
MAX_SIZE=20
};
typedef struct
{
int* base;
int* top;
int stacksize;
}SqStack;
void InitStack(SqStack S)
{
S.base=new int[MAX_SIZE];
S.top=S.base;
S.stacksize=MAX_SIZE;
}
bool Push(SqStack S,int e)
{
if(S.top-S.base=S.stacksize)
return false;
*S.top=e;
S.top++;
return true;
}
bool Pop(SqStack S,int e)
{
if(S.top==S.base)
return false;
S.top--;
e=*S.top;
return true;
}
void DestroyStack(SqStack S)
{
if(S.base)
delete S.base;
S.top=S.base=NULL;
S.stacksize=0;
}
bool StackEmpty(SqStack S)
{
return (S.top==S.base);
}
void Print(SqStack S)
{
int i=0;
while(iS.top-S.base)
{
coutS.base[i++]endl;
}
}
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;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;
}
栈的c语言实现基本操作
写了一个链式栈，你看看
# include stdio.h
# include malloc.h
# include stdlib.h
typedef struct Node
{
int data;
struct Node *pNext;
}NODE, *PNODE;
typedef struct Stack
{
PNODE pTop;
PNODE pBottom;//pBottem是指向栈底下一个没有实际意义的元素
}STACK, *PSTACK;
void init( PSTACK );
void push( PSTACK, int );
void traverse( PSTACK );
int pop( PSTACK, int * );
int empty( PSTACK pS );
int main( void )
{
STACK S;//STACK等价于struct Stack
int val;
init( S );//目的是造出一个空栈
push( S, 1 );//压栈
push( S, 2 );
push( S, 3 );
push( S, 4 );
push( S, 5 );
push( S, 6 );
push( S, 7 );
traverse( S );//遍历输出
// clear( S ); //清空数据
// traverse( S );//遍历输出
if( pop( S, val ) )
{
printf( "出栈成功,出栈的元素是%d\n", val );
}
else
{
printf( "出栈失败" );
}
traverse( S );//遍历输出出栈之后的元素
return 0;
}
void init( PSTACK pS )
{
pS-pTop = ( PNODE )malloc( sizeof( NODE ) );
if( NULL == pS-pTop )
{
printf( "动态内存分配失败!\n" );
exit( -1 );
}
else
{
pS-pBottom = pS-pTop;
pS-pTop-pNext = NULL;//或是pS-pBottom = NULL;
}
}
void push( PSTACK pS, int val )
{
PNODE pNew = ( PNODE )malloc( sizeof( NODE ) );
pNew-data = val;
pNew-pNext = pS-pTop;//pS-Top不能改为pS-pBottom
pS-pTop = pNew;
}
void traverse( PSTACK pS )
{
PNODE p = pS-pTop;
while( p != pS-pBottom )
{
printf( "%d ", p-data );
p = p-pNext;
}
printf( "\n" );
}
int empty( PSTACK pS )
{
if( pS-pTop == pS-pBottom )
return 1;
else
return 0;
}
//把pS所指向的栈出栈一次,并把出栈的元素存入pVal形参所指向的变量中,如果出栈失败,则返回false,否则true
int pop( PSTACK pS, int *pVal)
{
if( empty( pS ) )//pS本身存放的就是S的地址
{
return 0;
}
else
{
PNODE r = pS-pTop;
*pVal = r-data;
pS-pTop = r-pNext;
free( r );
r = NULL; //为什么要把r赋给NULL呢??
return 1;
}
}
//clear清空
void clear( PSTACK pS )
{
if( empty( pS ) )
{
return ;
}
else
{
PNODE p = pS-pTop;
PNODE q = p-pNext;
while( p != pS-pBottom )
{
q = p-pNext;
free( p );
p = q;
}
pS-pTop = pS-pBottom;
}
}
栈的基本操作的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;
}
