c语言系列-栈与队列（面向大厂）

栈的结构

创建一个栈

#define STACK_INIT_SIZE 100
initStack(sqStack *s)
{
	s->base=(ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
	if(!s->base)
		exit(0);
	s->top=s->base;
	s->stackSize = STACK_INIT_SIZE;
}

入栈操作

#define STACKINCREMENT 10
Push(sqStack *e, ElemType e)
{
	if(s->top-s->base>=s->stackSize)
	{
		s->base=(ElemType *)realloc(s->stackSize+STACKINCREMENT)+sizeof(ElemType));
		if(!a->base)
			exit(0);
			s->top=s->base+s->stackSize;
			s->stackSize=s->stackSize+STACKINCREMENT;
	}
	*(a->top)=e;
	a->top++;
}

出栈操作

出栈操作就是在栈顶取出数据，栈顶指针随之下
移的操作。
每当从栈内弹出一个数据，栈的当前容量就－1.
代码清单：

Pop (sqstack*s, ElemType*e)
｛
if (s-> top==s-> base) // 栈已空空是也
return;
＊e=*-- (s-> top) ;
｝

进制转换

#include <math.h>
#define STACK INIT SIZE 20 
#define STACKINCRENENT 10
typedef char ElemType;
typedef struct 
{
	ElemType *base;
	ElemType *top;
	int stackSize;
}sqStack;
void InitStack (sqstack *s) ;
{
	s-> base= (ElemType*) malloc (STACK _INIT_SIZE*sizeof (ElemType) ) ;
	if (!s-> base)
	{
		exit (0) ;
	}
	s-> top=s-> base;
	s-> stacksize= STACK_INIT_SIZE;
void Push (sqStack *s, ElemType e)
{
	if (s-> top-s-> base> =s-> stackSize) 
	｛
		s-> base = (ElemType*) realloc (s-> base, (s->stackSize+STACKINCREMENT)*sizeof(E.
		if (!s-> base)
		{
			exit (0) ;
		}
	}
	* (s-> top) =e;
	s-> top++;
}
void Pop (sqStack *s, ElemType *e)
{
	if (s-> top ==s-> base)
	{
	return;
	}
 	*e=*-- (s-> top) ;
}
int StackLen (sqStack s)
{
	return (s.top-s.base) ;
}
int main () 
{
	ElemType C; 
	sqstack s;
	int i,sum=0;len;
	InitStack（&s）;
	printf("请输入二进制数，#表示结束");
	scanf("%c",&c);
	while (c! ='#')
	{
		Push (&s,c) ;
		scanf ("%c", &c) ;
	}
	getchar () ; 
	len= StackLen (s) ;
	printf ("栈的当前容量是:%d\n",len) ;
	for (i=0;i < len;i++)
	{
		Pop (&s, &c) ;
		sum=sum+ (c-48) * pow (2,i) ;
	}
	printf("十进制数%d\n",sum);
	return 0;
}

队列

创建一个队列要完成两个任务：一是在内存中创
建
一个头结点，二是将队列的头指针和尾指针都
指向这个生成的头结点，因为此时是空队列。

initQueue (LinkQueue*q)
｛
q-> front=q-> rear= (QueuePtr) malloc (sizeof (QNode) ) ;
if (!q-> front)
exit (0) ;
q-> front-> next=NULL;
｝

入队列操作

InsertQueue (LinkQueue*q, ElemType e)
｛
	Queueptr p;
	p= (QueuePtr) malloc (sizeof (QNode) ) ;
	if (p==NULL)
		exit (0) ;
	p-> data=e;
	p-> next=NULL;
	q-> rear-> next=p;
	q-> rear =p; 
｝

出队列

DeleteQueue (LinkQueue*q, ELemType*e)
｛
	Queueptr p;
	if (q-> front ==q-> rear)
		return;
	p. =q-> front-> next;
	＊e=p-> data;
	q-> front-> next=p-> next;
	if (q-> rear==p)
		q-> rear= q-> front;
	free (p) ;
｝

销毁队列

由于链队列建立在内存的动态区，因此当一个队
列不再有用时应当把它及时销毁掉，以免过多地
占用内存空间。

DestroyQueue (LinkQueue*q)
｛
	while q-> front) {
		q-> rear=q-> front-> next;
		free (q-> front) ;
		q-> front=q-> rear;
	｝
｝

初始化循环队列

初始化一个循环队列
initQueue (cycleQueue*q)
｛
	q-> base= (ElemType*)malloc (MAXSIZE*
	sizeof (ElemType) ) ;
	if (!q-> base)
		exit (0) ;
	q-> front=g-> next=0;
｝
InsertQueue (cycleQueue*g, ElemType e)
｛
	if ( (q-> rear+1) %MAXSIZE==g-> front)
	return; //队列已满
	q-> base [q-> rear] =e;
	q-> rear- (g-> rean+1) %MAXSIZE;
｝

递归数列

#include <stdio.h>
void move (int n,char x,char y, char z) ／／将n个盘子从x借助y移动到{
	if (1==n)
	{
		printf ("%c--> %c\n",x,z) ; 
	}
	else
	{
		move (n-1,x,z,y) ;
		printf ("%C--> %c\n”，x,z) ;
		move (n-1,y,x,z) ;
	}
}
int main ()
{
	int n;
	printf ("请输入汉诺塔的层数：＂） ;
	scanf ("%d", &n) ;
	printf (”移动的步骤如下：＼n”） ;
	move (n, 'x', 'y', 'Z') ;
	return 0;
}

有问题的欢迎留言区留言，网友很热心的