通过代码快速上手C语言数据结构-栈与队列

最新推荐文章于 2021-10-22 11:53:31 发布
最新推荐文章于 2021-10-22 11:53:31 发布
阅读量327 收藏 6
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aiqq136/article/details/116050932
版权

3.1-3.4顺序栈

3.1初始化顺序栈

3.2顺序栈进栈运算

3.3顺序栈出栈运算

3.4顺序栈取栈顶元素运算

顺序栈头文件

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

/*顺序栈*/

typedef struct
{
	StackElementType elem[Stack_Size]; /*用来存放栈中元素的一维数组*/
	int top;          		/*用来存放栈顶元素的下标，top为-1表示空栈*/
}SeqStack;


/*初始化*/
void InitStack(SeqStack *S)
{
	/*构造一个空栈S*/
  	S->top = -1;
}

/*判栈空*/
int IsEmpty(SeqStack *S) /*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top==-1?TRUE:FALSE);
}

/*判栈满*/
int IsFull(SeqStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

int Push(SeqStack *S,StackElementType x)
{
	if(S->top==Stack_Size-1)  
		return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top] = x;
	return(TRUE);
}

int Pop(SeqStack *S,StackElementType *x)
{  
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if(S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
  		return(TRUE);
	}
}

/*取栈顶元素。*/
int GetTop(SeqStack *S,StackElementType *x)
{  
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
  		return(TRUE);
	}	
}

/*进行匹配*/
int Match(char ch,char str)
{		
	if(ch=='(' && str==')')
	{
		return TRUE;
	}
	else if(ch=='[' && str==']')
	{
		return TRUE;
	}
	else if(ch=='{' && str=='}')
	{
		return TRUE;
	}
	else 
		return FALSE;
}

3.5-3.7双端顺序栈

3.5双端顺序栈初始化

3.6双端顺序栈进栈操作

3.7双端顺序栈出栈操作

#define TRUE 1
#define FALSE 0
#define M 100

typedef struct
{
	StackElementType Stack[M];
	StackElementType top[2];  /*top[0]和top[1]分别为两个栈顶指示器*/
}DqStack;

/*初始化操作。*/
void InitStack(DqStack *S)
{
	S->top[0]=-1;
	S->top[1]=M;
}

/*进栈操作。*/
int Push(DqStack *S,StackElementType x,int i)
{
	/*把数据元素x压入i号堆栈*/
	if(S->top[0]+1==S->top[1]) /*栈已满*/
		return(FALSE);
	switch(i)
	{
	case 0:
		S->top[0]++;
		S->Stack[S->top[0]]=x;
		break;
	case 1:
		S->top[1]--;
		S->Stack[S->top[1]]=x;
		break;
	default:  /*参数错误*/
        return(FALSE)
 	}
	return(TRUE);
}

/*出栈操作。*/
int Pop(DqStack *S,StackElementType *x,int i)
{
	/* 从i 号堆栈中弹出栈顶元素并送到x中 */
	switch(i)
	{
	case 0:
		if(S->top[0]==-1)  
			return(FALSE);
		*x=S->Stack[S->top[0]];
		S->top[0]--;
		break;
	case 1:
		if(S->top[1]==M)  
			return(FALSE);
		*x=S->Stack[S->top[1]];
		S->top[1]++;
		break;
	default:
		return(FALSE);
	}
	return(TRUE);
}

 

3.8-3.11链栈

3.8链栈进栈操作

3.9链栈出栈操作

3.10第i号栈进栈操作

3.11第i号栈出栈操作

#define TRUE 1
#define FALSE 0

typedef struct node
{
	StackElementType data;
	struct node *next;
}LinkStackNode;

typedef LinkStackNode *LinkStack;

/*进栈操作。*/
int Push(LinkStack top, StackElementType x)/* 将数据元素x压入栈top中 */ 
{
	LinkStackNode *temp;
	temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
 	if(temp==NULL)  
 		return(FALSE);   /* 申请空间失败 */
	temp->data=x;
	temp->next=top->next;
	top->next=temp;   /* 修改当前栈顶指针 */ 
	return(TRUE);
}

/*出栈操作。*/
int Pop(LinkStack top, StackElementType *x)
{  
	/* 将栈top的栈顶元素弹出，放到x所指的存储空间中 */
	LinkStackNode * temp;
	temp=top->next;
	if(temp==NULL)  /*栈为空*/
		return(FALSE);
	top->next=temp->next;
	*x=temp->data;
	free(temp);   /* 释放存储空间 */
	return(TRUE);
}

 

3.1-3.11完整实现

#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <dos.h>
#define N 5
#define PRICE 5
//#define NULL 0

/****************************************/
typedef struct{
	int boardnumber;
	int arritime;
}car;

typedef struct{
	car elem[N];
	int top;
}seqstack;

typedef struct node{
	car data;
	struct node *next;
}linkqueuenode;

typedef struct{
	linkqueuenode *front;
	linkqueuenode *rear;
}linkqueue;
/*****************************************/
void initstack(seqstack *s){
	s->top=-1;
}

void initqueue(linkqueue *q){
	q->front=(linkqueuenode*)malloc(sizeof(linkqueuenode));
	if(q->front!=NULL){
		q->rear=q->front;
		q->front->next=NULL;
	}
}

void enterqueue(linkqueue *q,car *x){
	linkqueuenode *new1;
	new1=(linkqueuenode *)malloc(sizeof(linkqueuenode));
	if(new1!=NULL){
		new1->data.boardnumber=x->boardnumber;
		new1->data.arritime=x->arritime;
		new1->next=NULL;
		q->rear->next=new1;
		q->rear=new1;
	}
}

void deletequeue(linkqueue *q,car *p){	
	    linkqueuenode *x;
		if(q->front==q->rear) return 0;
		x=q->front->next;
		q->front->next=x->next;
		if(q->rear==x)q->rear=q->front;
		p->boardnumber=x->data.boardnumber;
		p->arritime=x->data.arritime;
	    free(x);
}

void pushstack(seqstack *s,car *x){
	s->top++;
	s->elem[s->top].boardnumber=x->boardnumber;
	s->elem[s->top].arritime=x->arritime;
}

void popstack(seqstack *s,car *x){
	x->boardnumber=s->elem[s->top].boardnumber;
	x->arritime=s->elem[s->top].arritime;
	s->top--;
}

void leave(seqstack *cheku,car *x){
	int time,pay,leavetime;
	printf("please input the leavetime:\n");
	scanf("%d",&leavetime);
	popstack(cheku,x);
	time=leavetime-x->arritime;
	pay=time*PRICE;
	printf("Boardnumber   Arritime   Leavetime  Pay\n");
	printf("%4d %14d %10d %8d\n",x->boardnumber,x->arritime,leavetime,pay);
}
/*************************************************************/
main(){
	seqstack cheku,chedao;
	linkqueue biandao;
	car x,y;
	car xx;
	//char b;
	int k,m,j=1,p=0;
	int choice=0;
	//clrscr();
	initstack(&cheku);
	initstack(&chedao);
	initqueue(&biandao);
	while(choice!=4){
		printf("/****************/\n");
		printf("1.Enter Cheku\n");
		printf("2.Enter Biandao\n");
		printf("3.Leave\n");
		printf("4.Exit\n");
		printf("5.Print Out\n");
		printf("Your selection:");
		scanf("%d",&choice);
		switch(choice){
			case 1:
                                p++;
                                if(p>0&&p<6){
					printf("please input the boardnumber and arritime of cars that go into cheku:\n");
					scanf("%d,%d",&x.boardnumber,&x.arritime);
					pushstack(&cheku,&x);
					printf("\nBnum Intime No.InCheku\n");
					printf("%6d %10d %10d\n",x.boardnumber,x.arritime,cheku.top+1);
				}
				else{
					printf("/***************************************************/\n");
					printf("Illegal input!There is only %d rooms in the cheku.\n",N);
					printf("/***************************************************/\n");
					p--;
				}
				break;
			case 2:
				printf("please input the boardnumber and arritime of cars that go into biandao:\n");
				scanf("%d,%d",&y.boardnumber,&y.arritime);x=y;
				enterqueue(&biandao,&x);
				printf("\nBnum Intime No.InBiandao\n");
				printf("%-6d %-10d %-10d\n",biandao.rear->data.boardnumber,biandao.rear->data.arritime,j);
				j++;
				break;
			case 3:
				printf("please input the position of the leaving car in cheku:\n");
				scanf("%d",&k);
				while(cheku.top>k){
					popstack(&cheku,&x);
					pushstack(&chedao,&x);
					printf("chedao:%d %d %d\n",chedao.elem[chedao.top].boardnumber,chedao.elem[chedao.top].arritime,chedao.top);
				}
					y=cheku.elem[cheku.top];
					leave(&cheku,&y);
				while(chedao.top>=0){
					popstack(&chedao,&x);
					pushstack(&cheku,&x);
					printf("cheku:%d %d %d\n",cheku.elem[cheku.top].boardnumber,cheku.elem[cheku.top].arritime,cheku.top);
				}
				if(biandao.front!=biandao.rear)
					{
						deletequeue(&biandao,&xx);
						printf("XX:%d,%d\n",xx.boardnumber,xx.arritime);
						pushstack(&cheku,&xx);
					}
				
				
				break;
			case 4:
				break;
			case 5:  m=cheku.top;
				while(m>-1){
					printf("%d %d %d\n",cheku.elem[m].boardnumber,cheku.elem[m].arritime,m);
					m--;
				}
		}
	}
}

 

3.12括号匹配算法

#define TRUE 1
#define FALSE 0
#define Stack_Size 50

#define StackElementType char

/*顺序栈*/

typedef struct
{
	StackElementType elem[Stack_Size]; /*用来存放栈中元素的一维数组*/
	int top;          		/*用来存放栈顶元素的下标，top为-1表示空栈*/
}SeqStack;


/*初始化*/
void InitStack(SeqStack *S)
{
	/*构造一个空栈S*/
  	S->top = -1;
}

/*判栈空*/
int IsEmpty(SeqStack *S) /*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top==-1?TRUE:FALSE);
}

/*判栈满*/
int IsFull(SeqStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

int Push(SeqStack *S,StackElementType x)
{
	if(S->top==Stack_Size-1)  
		return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top] = x;
	return(TRUE);
}

int Pop(SeqStack *S,StackElementType *x)
{  
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if(S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
  		return(TRUE);
	}
}

/*取栈顶元素。*/
int GetTop(SeqStack *S,StackElementType *x)
{  
	/* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top == -1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
  		return(TRUE);
	}	
}

/*进行匹配*/
int Match(char ch,char str)
{		
	if(ch=='(' && str==')')
	{
		return TRUE;
	}
	else if(ch=='[' && str==']')
	{
		return TRUE;
	}
	else if(ch=='{' && str=='}')
	{
		return TRUE;
	}
	else 
		return FALSE;
}
#include <stdio.h>

void BracketMatch(char *str);

void BracketMatch(char *str) /* str[]中为输入的字符串，利用堆栈技术来检查该字符串中的括号是否匹配*/
{
	SeqStack S; 
	int i; 
	char ch;
	
	InitStack(&S);
	
	for(i=0; str[i]!='\0'; i++)   /*对字符串中的字符逐一扫描*/
	{
    	switch(str[i])
    	{
		case '(':
		case '[':
		case '{':
			Push(&S,str[i]);  
	        break;
      	case ')':
      	case ']':
      	case '}':
			if(IsEmpty(&S))
		    { 
				printf("\n右括号多余!");  
		        return;
		    }
			else
			{
				GetTop(&S,&ch);
				if(Match(ch,str[i]))  /*用Match判断两个括号是否匹配*/
					Pop(&S,&ch);      /*已匹配的左括号出栈*/
	            else
		        {
		            printf("\n对应的左右括号不同类!");  
		            return;
		        }
			}
		}/*switch*/
	}/*for*/
	if(IsEmpty(&S))
		printf("\n括号匹配!");
	else
		printf("\n左括号多余!");
}

void main()
{
	char str[100];
	printf("please input:");
	gets(str);
	BracketMatch(str);
}

3.13无括号算术表达式处理算法

#define TRUE 1
#define FALSE 0
#define Stack_Size 50


/*顺序栈-整型*/
typedef struct
{
	int elem[Stack_Size];  /*用来存放栈中元素的一维数组*/
	int  top;          /*用来存放栈顶元素的下标，top为-1表示栈是空栈*/
}nStack;

/*初始化*/
void  nInitStack(nStack *S)
{
/*构造一个空栈S*/
  	S->top=-1;
}

/*判栈空*/
int nIsEmpty(nStack *S)	/*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top==-1?TRUE:FALSE);
}

/*判栈满*/
int nIsFull(nStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

int nPush(nStack * S, int x)
{
	if(S->top== Stack_Size-1)  return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}

int nPop(nStack * S, int *x)
{  /* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x= S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
  		return(TRUE);
	}
}

int nGetTop(nStack *S, int *x)
{  /* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
  		return(TRUE);
	}
}


/*顺序栈-字符型*/
typedef struct
{
	char elem[Stack_Size];  /*用来存放栈中元素的一维数组*/
	int  top;          /*用来存放栈顶元素的下标，top为-1表示栈是空栈*/
}strStack;

/*初始化*/
void strInitStack(strStack *S)
{
/*构造一个空栈S*/
  	S->top=-1;
}

/*判栈空*/
int strIsEmpty(strStack *S)	/*判断栈S为空栈时返回值为真，反之为假*/
{
	return(S->top==-1?TRUE:FALSE);
}

/*判栈满*/
int strIsFull(strStack *S)	/*判断栈S为满栈时返回值为真，反之为假*/
{
	return(S->top==Stack_Size-1?TRUE:FALSE);
}

char strPush(strStack * S, char x)
{
	if(S->top== Stack_Size-1)  return(FALSE);  /*栈已满*/
	S->top++;
	S->elem[S->top]=x;
	return(TRUE);
}

char strPop(strStack * S, char *x)
{  /* 将栈S的栈顶元素弹出，放到x所指的存储空间中 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x= S->elem[S->top];
		S->top--;    /* 修改栈顶指针 */
  		return(TRUE);
	}
}

int strGetTop(strStack *S, char *x)
{  /* 将栈S的栈顶元素弹出，放到x所指的存储空间中，但栈顶指针保持不变 */
	if(S->top==-1)  /*栈为空*/
		return(FALSE);
	else
	{
  		*x = S->elem[S->top];
  		return(TRUE);
	}
}

/*功能函数*/
int Match(char ch,char str)
{		
	if(ch=='('&&str==')')
	{
		return TRUE;
	}
	else if(ch=='['&&str==']')
	{
		return TRUE;
	}
	else if(ch=='{'&&str=='}')
	{
		return TRUE;
	}
	else return FALSE;
}

int In(char ch)
{
	if(ch=='+')
	{
		return TRUE;	
	}
	else if(ch=='-') 
	{
		return TRUE;	
	}
	else if(ch=='*')
	{
		return TRUE;	
	}
	else if(ch=='/')
	{
		return TRUE;	
	}
	else if(ch=='(')
	{
		return TRUE;	
	}
	else if(ch==')')
	{
		return TRUE;	
	}
	else if(ch=='#')
	{
		return TRUE;	
	}
	else return FALSE;
}

char Compare(char x,char ch)
{
	switch(x)
	{
	case '+':
		if(ch=='+'||ch=='-'||ch==')'||ch=='#')
			return '>';	
		else if(ch=='*'||ch=='/'||ch=='(')
				return '<';	
		break;
	case '-':
		if(ch=='+'||ch=='-'||ch==')'||ch=='#')
			return '>';	
		else if(ch=='*'||ch=='/'||ch=='(')
			return '<';	
		break;
	case '*':
		if(ch=='(')
		{
			return '<';
		}
		else
		{
			return '>';
		}
		break;
	case '/':
		if(ch=='(')
				return '<';	
		else
				return '>';	
		break;
	case '(':
		if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(')
			return '<';	
		else if(ch==')')
			return '=';	
		else if(ch=='#')
			return '0';	
		break;
	case ')':
		if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch==')'||ch=='#')
			return '>';	
		else if(ch=='(')
			return '0';	
		break;
	case '#':
		if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='(')
			return '<';	
		else if(ch=='#')
			return '=';	
		else if(ch==')')
			return '0';	
		break;	
	default:
		return '0';
		break;
	}

}	

int Execute(int a,char op,int b)
{
	switch(op)
	{
	case '+':
		return (a+b);
		break;
	case '-':
		return (a-b);
		break;
	case '*':
		return (a*b);
		break;
	case '/':
		return (a/b);
		break;
	}
}
#include "stdio.h"
#include <conio.h>


char ch;

int ExpEvaluation()/*读入一个简单算术表达式并计算其值。operatsign和operatdata分别为运算符栈和运算数栈，OPS为运算符集合*/
{
	char x,y;
	char op;
	int a,b,v;
	
	nStack operatdata;
	strStack operatsign;
	nInitStack(&operatdata);
	strInitStack(&operatsign);
	strPush(&operatsign,'#');
	
	printf("\nPlease input an expression (Ending with #) :\n");
    ch=getchar();

 	
 	strGetTop(&operatsign,&y);

 	while(ch!='#'||y!='#') /* strGetTop()通过函数值返回栈顶元素*/
   	{
		if(!In(ch))                   /*不是运算符，是运算数*/
		{
			
			int temp; 		   /*存放数字的临时变量*/
			temp=ch-'0';
			/*将字符转换为十进制数*/
			fflush(stdin);
			ch=getchar();
			while(!In(ch))  //用ch逐个读入运算数的各位数码，并转化为十进制数temp
			{
				temp=temp*10+ch-'0'; // 将逐个读入运算数的各位转化为十进制数
	 			fflush(stdin);
				ch=getchar();
			}  
   			nPush(&operatdata,temp);
		}
		else
      		switch(Compare(y,ch))
			{
	 			case '<': 
					strPush(&operatsign,ch); 
              		fflush(stdin);
					ch=getchar();
					break;
	 			case '=': 
					strPop(&operatsign,&x); 
					fflush(stdin);
					ch=getchar(); 
					break;
				case '>': 
					strPop(&operatsign,&op);
					nPop(&operatdata,&b);
					nPop(&operatdata,&a);
					v=Execute(a,op,b);  /* 对a和b进行op运算 */
					nPush(&operatdata,v);
					break;
			}
		strGetTop(&operatsign,&y);
	}
	nGetTop(&operatdata,&v);
	return (v);
}

void main()
{
	int result;   
    result=ExpEvaluation();
    printf("\n%d",result);
}

3.14-3.15汉诺塔

3.14汉诺塔递归算法

3.15汉诺塔非递归算法示意

#include "stdio.h"


move(char a,char c,FILE **fp,int *count)
{
(*count)++;
printf("%6d:%c-->%c\n",*count,a,c);
fprintf(*fp,"%6d:%c-->%c\n",*count,a,c);
}


hanoi(int n, char a, char b, char c, FILE **fp, int *count)
{
if(n==1) move(a,c,fp,count);
else
{
hanoi(n-1,a,c,b,fp,count);
move(a,c,fp,count);
hanoi(n-1,b,a,c,fp,count);
}
}


main()
{
int n,count=0; /*count用来记录移动次数*/
FILE *fp;
fp=fopen("hanoi.txt","w");
printf("Input the number of disk:");
scanf("%d",&n);
fprintf(fp,"%d disks hanoi tower:\n",n);
hanoi(n,'A','B','C',&fp,&count);
fclose(fp);
}

 

 

3.16斐波那契数列的非递归算法

3.17求n!非递归算法

 

3.18-3.20链队

3.18链队列初始化

3.19链队列入队操作算法

3.20链队列出队操作算法

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct Node
{
	QueueElementType data;     /*数据域*/
	struct Node *next;     /*指针域*/
}LinkQueueNode;

typedef struct 
{
	LinkQueueNode *front;
	LinkQueueNode *rear;
}LinkQueue;

/*初始化操作。*/
int InitQueue(LinkQueue *Q)
{ 
	/* 将Q初始化为一个空的链队列 */
	Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
	if(Q->front!=NULL)
	{
		Q->rear=Q->front;
		Q->front->next=NULL;
 		return(TRUE);
	}
	else return(FALSE);    /* 溢出！*/
}

/*入队操作。*/
int EnterQueue(LinkQueue *Q,QueueElementType x)
{  
	/* 将数据元素x插入到队列Q中 */
	LinkQueueNode *NewNode;
	NewNode=(LinkQueueNode * )malloc(sizeof(LinkQueueNode));
	if(NewNode!=NULL)
	{
		NewNode->data=x;
		NewNode->next=NULL;
		Q->rear->next=NewNode;
		Q->rear=NewNode;
		return(TRUE);
	}
	else  return(FALSE);    /* 溢出！*/
}

/*出队操作。*/
int DeleteQueue(LinkQueue *Q,QueueElementType *x)
{  
	/* 将队列Q的队头元素出队，并存放到x所指的存储空间中 */
	LinkQueueNode * p;
	if(Q->front==Q->rear)
		return(FALSE);
	p=Q->front->next;
	Q->front->next=p->next;  /* 队头元素p出队 */
	if(Q->rear==p)  /* 如果队中只有一个元素p，则p出队后成为空队 */
		Q->rear=Q->front;  
	*x=p->data;
	free(p);   /* 释放存储空间 */
	return(TRUE);	
}

int GetHead(SeqQueue *Q, int *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

3.21-3.23循环队列

3.21循环队列初始化操作

3.22循环队列入队操作

3.23循环队列出队操作

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	QueueElementType  element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
}SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, QueueElementType x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, QueueElementType *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

int IsEmpty(SeqQueue *Q)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(TRUE);
	else
		return(FALSE);  /*操作成功*/
}

3.18-3.23实现

#define FALSE  0
#define TURE   1
#define N     3

#include<malloc.h>
#include<stdio.h>

/***************************************************************/

typedef struct    /* 定义数据汽车类数据类型  */
{
      int  number;
      int  t_come;
      int  t_go;
} car,*CAR;


typedef struct Stack    /*模拟栈 */
{
   CAR c[N];
   int n;
}Stack;


typedef struct Node
{
    car *Car;
    struct Node *next;

}LinkQueueNode;

typedef struct
{
	LinkQueueNode *front;
	LinkQueueNode *rear;
}LinkQueue;





Stack S;
LinkQueue Q;
int   Time;

/*******************************************************************/

void print();
int Init_queue()
{
	Q.front=(LinkQueueNode *)
		malloc(sizeof(LinkQueueNode));
	if(Q.front !=NULL)
	{
		Q.rear =Q.front ;
		Q.front ->next =NULL;
                return( TURE );
     }
  	else return(FALSE);
}

/*=====================================================================*/

int Enter_queue( car x) /*入队，成功返回在对中的位置，否则返回 0 */
{
	LinkQueueNode *p=Q.front;
    int i=0;
    LinkQueueNode *temp;
    temp=(LinkQueueNode *)
	    malloc(sizeof(LinkQueueNode));
	if(temp == NULL)
		return( FALSE);
	else
	{
		*(temp->Car) = x;
                temp->next = NULL;
		Q.rear ->next=temp;
		Q.rear=temp;
                while(p!=Q.rear)
                {
                   p=p->next;
                   i++;
                }
		return(i);

	}
}

/*=================================================================*/

CAR DeletQueue()
{
	LinkQueueNode *p;
	if(Q.front == Q.rear)
	    return( FALSE);
    p=Q.front->next;
	Q.front ->next=p->next ;
	if(Q.rear==p)
		Q.rear=Q.front;
	p->Car->t_come =Time;
    return(p->Car);
}

/*=================================================================*/

comein()
{
       car mm;


       printf("\n\tPlease put in the coming car's number: ");
	   scanf("%d",&mm.number);


       printf("\n\tPlease put in the car's come time: ");
	      scanf("%d",&mm.t_come);
	   Time=mm.t_come ;            /*全局时间变量*/
       if(S.n<N)
       {
           car *temp;
		   temp=(car *)malloc(sizeof(car));
		   *temp=mm;
	       S.c[S.n]=temp;
              S.n++;
	       printf("\nThe car insert the stack %d",S.n);
       }
       else
       {
	       printf("\n\rThe car insert the queue %d",Enter_queue(mm));
       }

}

/*----------------------------------------------------------------------*/

goout()
{
      int i,j;
      int str;
      CAR mm;
      printf("\n\tPlease put in the number of the going car: ");
             scanf("%d",&str);
      for(i=0;i<S.n;i++)
      {
           if(str == S.c[i]->number)
           {
	       printf("\n\tPlease put in the go time: ");
		   scanf("%d",&Time);
		   S.c[i]->t_go=Time;
	       printf("\n Stop time is %d",S.c[i]->t_go - S.c[i]->t_come);
	       for(j=i;j<S.n-1;j++)
	         S.c[j]=S.c[j+1];
	       S.n--;

	       break;
           }

      }
      if(Q.rear != Q.front)
      {
         S.c[S.n]=DeletQueue();
         S.n++;

      }
      if(i==N || S.n==0)
             printf(" Not in the stack");

}

/*=====================================================================*/
void print()
{
   int i;
   LinkQueueNode *temp=Q.front;
   printf("\n\n----------------------------------------\n");
   printf("The cars in the Stack\n");
   printf("place \t number\n");
   for(i=0;i<S.n;i++)
     printf("%4d\t %4d \n",i+1, S.c[i]->number);
   i=0;

   if(Q.front != Q.rear)
   {
       printf("\nThe cars in the queue:\n");
       printf("place \t number\n");
       while(temp!=Q.rear)
       {
	     i++;
	     temp=temp->next;
	     printf("%4d \t %4d \n",i, temp->Car->number);
       }
   }
   else
     printf("\nThere is no car in the queue.");
   printf("\n------------------------ok------------");
}
main()
{
    int k;
    char ch;
    S.n=0;
    Init_queue();

    while(1)
    {
       printf("\n\n\rPLEASE CHOSE:\n\tC: COME IN\n\tG: GO OUT \n\tF: LOOK\n\t0: EXIT");
       ch=getch();

       if(ch=='c'||ch=='C')
	   comein();
       else if(ch=='g'||ch=='G')
	   goout();
       else if(ch=='f'||ch=='F')
	    print();
       else if(ch=='0'||ch=='O' || ch=='o'||ch==27)
	   break;
     }

     for(k=0;k<N;k++)
     {
          printf("%d",S.c[k]->number);
     }
}
/*the end*/

 

3.24打印杨辉三角前n行算法

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	int element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
}SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, int x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, int *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, int *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

#include <stdio.h>

void YangHuiTriangle( )
{ 
	int n;
	int i;
	int temp;
	int x;
	int N;
	SeqQueue Q;
	InitQueue(&Q);
	EnterQueue(&Q,1);  /* 第一行元素入队*/
	printf("please input N:");
	scanf("%d",&N);
	for(n=2;n<=N;n++)   /* 产生第n行元素并入队，同时打印第n-1行的元素*/
	{
		EnterQueue(&Q,1);   /* 第n行的第一个元素入队*/
		for(i=1;i<=n-2;i++)  /* 利用队中第n-1行元素产生第n行的中间n-2个元素并入队*/
		{
			DeleteQueue(&Q,&temp);
			printf("%6d",temp);     /* 打印第n-1行的元素*/
			GetHead(&Q,&x);
			temp=temp+x;      /*利用队中第n-1行元素产生第n行元素*/
			EnterQueue(&Q,temp);  
		}
		DeleteQueue (&Q,&x);  
		printf("%6d",x);    /* 打印第n-1行的最后一个元素*/
		EnterQueue(&Q,1);   /* 第n行的最后一个元素入队*/
		printf("\n");
	}
}

void main()
{
	YangHuiTriangle( );
}

3.25键盘输入循环缓冲区算法

#include "stdio.h"
#include "conio.h"

#define  TRUE 1
#define  FALSE 0
#define  QueueElementType char

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	QueueElementType  element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
}SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, QueueElementType x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, QueueElementType *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

int IsEmpty(SeqQueue *Q)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(TRUE);
	else
		return(FALSE);  /*操作成功*/
}

main()
{
	char ch1,ch2;
	SeqQueue  Q;
	int f;
	InitQueue (&Q);

	while(TRUE)
	{
		while(TRUE)
		{
			printf("A");

			if(kbhit())
			{
				ch1=getch();
				if(ch1==';'||ch1=='.')
					break;
				f= EnterQueue(&Q,ch1);
				if(f==FALSE)
				{
					printf("full");
					break;
				}
			}

		}
		while (!IsEmpty(&Q))
		{
			DeleteQueue(&Q,&ch2);
			putchar(ch2);
		}
		getch();
		if(ch1=='.') break;
	}
}

多链栈头文件模板

#define  M  10   /*M个链栈*/
#define TRUE 1
#define FALSE 0

typedef struct node
{
	StackElementType data;
	struct node *next;
}LinkStackNode,  *LinkStack;
LinkStack  top[M];

/*第i号栈的进栈操作*/
int  pushi(LinkStack top[M],int i,StackElementType x)
{
	/*将元素x进入第i号链栈*/
	LinkStackNode  *temp;
	temp=(LinkStackNode * )malloc(sizeof(LinkStackNode));
	if(temp==NULL)  
		return(FALSE);   /* 申请空间失败 */
	temp->data=x;
	temp->next=top[i]->next;
	top[i]->next=temp;   /* 修改当前栈顶指针 */ 
	return(TRUE);
}

/*第i号栈元素的出栈操作*/
int Pop(LinkStack top[M],int i,StackElementType *x)
{  
	/* 将栈top的栈顶元素弹出，放到x所指的存储空间中 */
	LinkStackNode *temp;
	temp=top[i]->next;
	if(temp==NULL)  /*第i号栈为空栈*/
		return(FALSE);
	top[i]->next=temp->next;
	*x=temp->data;
	free(temp);   /* 释放存储空间 */
	return(TRUE);
}

链队列头文件模板

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct Node
{
	QueueElementType data;     /*数据域*/
	struct Node *next;     /*指针域*/
}LinkQueueNode;

typedef struct 
{
	LinkQueueNode *front;
	LinkQueueNode *rear;
}LinkQueue;

/*初始化操作。*/
int InitQueue(LinkQueue *Q)
{ 
	/* 将Q初始化为一个空的链队列 */
	Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
	if(Q->front!=NULL)
	{
		Q->rear=Q->front;
		Q->front->next=NULL;
 		return(TRUE);
	}
	else return(FALSE);    /* 溢出！*/
}

/*入队操作。*/
int EnterQueue(LinkQueue *Q,QueueElementType x)
{  
	/* 将数据元素x插入到队列Q中 */
	LinkQueueNode *NewNode;
	NewNode=(LinkQueueNode * )malloc(sizeof(LinkQueueNode));
	if(NewNode!=NULL)
	{
		NewNode->data=x;
		NewNode->next=NULL;
		Q->rear->next=NewNode;
		Q->rear=NewNode;
		return(TRUE);
	}
	else  return(FALSE);    /* 溢出！*/
}

/*出队操作。*/
int DeleteQueue(LinkQueue *Q,QueueElementType *x)
{  
	/* 将队列Q的队头元素出队，并存放到x所指的存储空间中 */
	LinkQueueNode * p;
	if(Q->front==Q->rear)
		return(FALSE);
	p=Q->front->next;
	Q->front->next=p->next;  /* 队头元素p出队 */
	if(Q->rear==p)  /* 如果队中只有一个元素p，则p出队后成为空队 */
		Q->rear=Q->front;  
	*x=p->data;
	free(p);   /* 释放存储空间 */
	return(TRUE);	
}

int GetHead(SeqQueue *Q, int *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

循环队列头文件模板

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	QueueElementType  element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
}SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, QueueElementType x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, QueueElementType *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

int IsEmpty(SeqQueue *Q)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(TRUE);
	else
		return(FALSE);  /*操作成功*/
}

 

 

 

 

神迹小卒
关注
专栏目录
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
数制转换
智慧源
06-25 436
<br />#define Stack_Size 50/*数制转换*/ #define FALSE 0 /*2009.08.17*/ #define TRUE 1 typedef int StackElemType; typedef struct { StackElemType elem[Stack_Size];//用数组模拟栈 int top; }SeqStack; void InitStack(SeqStack *s)//初始化 { s->top=-1; } int Pu
数据结构（C语言实验代码实现）--第三章 栈和队列
qq_50574166的博客
10-22 1004
3.1 顺序栈 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<math.h> #include<time.h> #define StackSize 100 //栈元素最多100 typedef int DataType; //顺序栈的存储结构 typedef struct { DataType data[StackSize];//存放栈元素
Letcode刷题（python）
黄鑫的博客
04-26 836
题目出自《程序员代码面试指南》 1.1 最小栈 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) -- 将元素 x 推入栈中。 pop() -- 删除栈顶的元素。 top() -- 获取栈顶元素。 getMin() -- 检索栈中的最小元素。 python内的list来实现栈 class MinS...
栈的实现（C语言）（栈的压入弹出等操作）
gp1330782530的博客
03-06 3595
栈的实现 1、栈的概念 栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 2、栈的数据结构 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。 定长的静态栈的结构 ...
栈的基本操作
热门推荐
qq_56683739的博客
08-25 2万+
对于栈这一数据结构，我首先写一下它的基本概念。 栈(stack)是仅限定在表尾进行插入和删除操作的线性表。 栈就是一个线性表，只不过，栈的Insert 和 delete只能在表尾。 普通的线性表，在表中的任意位置都可以进行insert和delete操作。 LIFO: Last In First Out 后进先出，先进后出 栈顶(Top): 进行插入和删除操作的一端 栈底(Bottom) 栈其实我们计算机科学中，更多的一种思想，“先进后出的思想”。 在很...
数据结构模板源代码（图、栈、队列、链表、二叉树），C语言/C++
08-24
各位好，这里是太阳终于出来啦，之前有考408的朋友觉得数据结构的算法题无从下手，我给他的建议是多去上手实操，毕竟有实时的输出反馈对于初学者而言帮助很大，但是他又和我抱怨对着空白的编译器无从下手，这才想到...
数据结构C语言版--中国铁道出版社
02-21
　本书包括：C 语言与数据结构、数组与字符串、基本链表、复杂链表、栈与队列、递归函数、二叉树、图、查找方法、内部排序法、外部排序法、OOP 与数据结构等，而且所有算法都有C 语言编写，大多数读者比较容易上手。...
c语言c++项目源代码_C语言10个数据结构课程设计实例二叉树建立遍历冒泡排序快速排序等.rar
03-27
**C语言数据结构课程设计合集** 本次提供的C语言项目源码合集涵盖了10个经典的数据结构课程设计实例，包括二叉树的建立与遍历、冒泡排序、快速排序等。这些实例不仅是对C语言编程能力的锻炼，更是对数据结构深入...
《数据结构与算法分析：C语言描述》答案中文版.zip
最新发布
06-16
Python作为解释型语言，代码简洁易读，特别适合初学者快速上手数据结构。 本书的中文版答案可以帮助读者验证自己的解题思路，理解并检查程序中的错误，这对于提升编程能力至关重要。通过解决书中给出的问题，读者...
C语言用栈实现括号匹配问题
kiddingstreet的博客
03-09 1万+
例如：{}[()]、{[()]}、()[]{}这种大中小括号成对出现（位置不限）则为括号匹配，反之则不匹配，如{()[ 接下来看一下实现方式 栈的定义以及相关操作 //栈的定义 typedef struct{ char elem[stack_size]; int top; }seqStack; //栈的初始化 void initStack(seqStack *s){ s->top=-...
顺序栈和链栈的基本操作实现
IMIS_TwentyEight的博客
10-24 2918
一、实验目的1、熟练掌栈的结构特点，掌握栈的顺序存储和链式存储结构和实现。 2、 学会使用栈解决实际问题。 二、实验内容 自己确定结点的具体数据类型和问题规模： 分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。 三、实验步骤 1、依据实验内容分别说明实验程序中用到的数据类型的定义； 2、相关操作的算法表达； 3、完整程序； 4、总结、
2007.08.27栈的表示和实现之顺序栈
blacklord的专栏
08-27 1036
 栈作为一种特殊的线性表，在计算机中也主要有两种基本的存储结构：顺序存储结构和链式存储结构。我们称顺序存储的栈为顺序栈，链式存储的栈为链栈。1.顺序栈顺序栈是用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时由于栈的操作的特殊性，还必须附设一个位置指针top（栈顶指针）来动态地指示栈顶元素在顺序栈中的位置。通常以top=-1表示空栈。顺序栈的存
第三章栈和队列-作业题
weixin_52326703的博客
10-17 3730
第三章栈和队列-作业题1.栈和列队的基本概念6-1 使用栈完成回文判断 (12 分)6-2 判断表达式中括号是否匹配 (12 分)6-3 队列的操作集合（带尾指针的循环链表） (18 分)6-4 循环队列的操作集合（只设 rear和quelen） (18 分)6-5 循环队列的操作集合（增设tag） (18 分) 1.栈和列队的基本概念 2-1 若元素a,b,c,d,e,f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈操作，则不可能得到的出栈序列是（D ）。 (2分) A.d,c,e,b,f
（学习笔记）栈数据结构中压（入）栈操作（C语言实现）
大智若鱼
11-04 4532
在用C语言实现栈结构，实现压栈、进栈操作的时候，会碰到栈满的情况，此时需要增加栈的大小，在C语言的代码中将要用到realloc();这个函数，发现对这个函数认识模糊，查了各种资料，发现网上网友总结的内容都非常模糊，于是翻了一翻《the  C programming language》，在其附录中对realloc函数是这样描述的：  “void *realloc(void *p,size_t si
C语言数据结构-队列 循环链表表示队列 假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针）
aiqq136的博客
03-26 1万+
队列 循环链表表示队列 假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），请完成下列任务： 1: 队列初始化，成功返回真，否则返回假： bool init_queue(LinkQueue *LQ); 2: 入队列，成功返回真，否则返回假： bool enter_queue(LinkQueue *LQ, ElemType x); 3: 出队列，成功返回真，且*x为出队的值，否则返回假 bool leave_queue(LinkQueue *LQ, ElemType *
C语言数据结构-2020级ICODING答案分享
aiqq136的博客
03-29 1万+
顺序表 删除指定范围 #include "list.h" // 请不要删除，否则检查不通过 #include <stdio.h> #include <stdlib.h> void del_x2y(SeqList* L, ElemType x, ElemType y) { int i = 0, j = 0; for (i = 0; i <= L->last; i++) { if (L->elem[i] < x || L-&g
C语言数据结构-栈-后缀表达式计算
aiqq136的博客
03-26 7541
栈 后缀表达式计算 请使用已定义好的栈完成后缀表达式计算： (1)如果是操作数，直接入栈 (2)如果是操作符op，连续出栈两次，得到操作数x 和 y,计算 x op y，并将结果入栈。 后缀表达式示例如下： 931-3*+102/+ 13445+51/6- 操作数、操作符之间由空格隔开，操作符有 +，-，*, /, %共 5 种符号，所有操作数都为整型。 栈的定义如下： #define Stack_Size 50 typedef st...
C语言数据结构-串-串替换-实现字符串替换操作
aiqq136的博客
04-06 5649
串替换 不调用库函数，自己实现字符串替换操作，函数原型为： int str_replace(const char *in, char *out, int outlen, const char *oldstr, const char *newstr); 参数说明: in， 原始字符串，保持不变 out, 存放替换结果的字符串 outlen，out空间的大小 oldstr，要替换的旧字符串 newstr，替换成的新字符串 函数返回成功替换的次数，即有多少个子串被成功替换 在替换过.
C语言与指针课后习题答案及代码解析
17. **经典抽象数据类型**（Classic Abstract Data Types）：可能讲解了一些基于C语言实现的经典数据结构，如栈、队列、链表等。 18. **运行时环境**（Runtime Environment）：讨论C程序的执行过程，包括内存布局、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值