数据结构与算法基本程序目录
一、 线性表及其操作
1、 尾插法建立一个单链表，并按顺序输出
2、 单链表的元素查找，按内容查找
3、 元素插入操作
4、 按内容元素删除操作
5、 按位置删除元素
6、 建立双向链表
7、 单链表就地逆置
8、 约瑟夫环问题
二、 栈及其操作
1、 建立堆栈
2、 进栈与出栈
3、 栈的应用，括号匹配
三、 队及其操作
1、 链队列的建立
2、 入队和出队
3、 循环队列建立
4、 循环队列的入队和出队操作
四、 串及其操作
1、 串的朴素匹配
五、 树（二叉树）及其操作
1、 二叉排序树
2、 哈夫曼编码
六、 排序
1、 冒泡排序
2、 直接选择排序法
一、线性表及其操作
//All copyright are preserved by cobby
/*尾插法建立一个单链表，并按顺序输出*/
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q; /*用指针类型定义三个结点类型的指针*/
char ch;
l=(L)malloc(sizeof(struct node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar(); //此语句用来吸收键盘输入的回车符，没有其它含义
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(struct node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
}
//All copyright are preserved bycobby
/*单链表的元素查找，按内容查找*/
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q; /*用指针类型定义三个结点类型的指针*/
char ch;
int n;
l=(L)malloc(sizeof(struct node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar();
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(struct node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
/*--------以上为建立一个单链表-------------*/
printf("\nInput a character you wanna find\n");
scanf("%c",&ch);
printf("\nthe character you wanna find is %c\n",ch);
q=l->next; /*q移至头结点的后一个元素，即实际第一个数据点*/
n=1; //位置计数器
while(q!=NULL) /*若q不为空，即该结点存在*/
{
if(q->c==ch) /*字符匹配*/
printf("character found in position %d\n",n);
q=q->next; /*移至下一个元素继续查找*/
n++;
}
}
//All copyright are preserved bycobby
/*元素插入操作*/
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}Node,*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q; /*用指针类型定义三个结点类型的指针*/
char ch;
int pos,n;
l=(L)malloc(sizeof(Node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar();
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(Node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
/*以上为建立一个单链表*/
printf("Input the character and its position, such as s,3\n\n");
scanf("%c,%d",&ch,&pos);
q=l;
n=1;
while(n!=pos&&q->next!=NULL) /*未找到插入位置，且后面还有元素*/
{
q=q->next;
n++;
}
/*退出循环后，要么找到插入位置，要么表已到最后，输入的插入位置过大*/
if(n<pos) /*表已读完，仍未找到插入位置*/
printf("\n\nincorrect position, insert failed\n\n");
else /*找到插入位置*/
{
/*将进行插入操作*/
p=(L)malloc(sizeof(Node)); /*给新输入的数据分配内存空间*/
p->c=ch;
p->next=q->next;
q->next=p;
}
/*操作完成，然后输出新表*/
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
}
//All copyright are preserved bycobby
/*按内容元素删除操作*/
#include<malloc.h>
#include<stdio.h>
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}Node,*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q; /*用指针类型定义三个结点类型的指针*/
char ch;
int n;
l=(L)malloc(sizeof(Node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar();
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(Node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
/*以上为建立单链表*/
printf("input the character you wanna delete\n\n");
scanf("%c",&ch);
printf("the element you wanna delete is %c\n\n",ch);
q=l->next;
p=l;
n=1;
while(q!=NULL&&q->c!=ch)
{
p=q;
q=q->next;
n++;
}
/*退出循环时可能找到指定元素，也可能表读完，需要进一步判断*/
if(q==NULL)
printf("element not found, delete failed\n\n");
else
p->next=q->next;
q=l->next; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
}
//All copyright are preserved bycobby
/*按位置删除元素*/
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}Node,*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q; /*用指针类型定义三个结点类型的指针*/
char ch;
int pos,n;
l=(L)malloc(sizeof(Node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar();
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(Node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
/*以上为建立单链表*/
printf("Input the position\n");
scanf("%d",&pos);
p=l;
n=1;
while(p->next!=NULL&&n!=pos)
{
p=p->next;
n++;
}
/*退出循环后，可能找到删除的元素位置，可能表读完，需要进一步判断*/
if(n==pos) /*删除位置找到，删除该位置上的元素*/
{
p->next=p->next->next;
//free(p);
}
else
printf("incorrect position, delete failed\n");
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
}
//建立双向链表
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define NULL 0
typedef struct dlnode
{
char ch;
struct dlnode *pri,*next;
}dnode,*dl;
main()
{
dl l,p,q;
char c;
l=(dl)malloc(sizeof(dnode));
l->ch='\0';
l->next=NULL;
l->pri=NULL;
q=l;
printf("输入字符建立双向链表\n");
scanf("%c",&c);
getchar();
while(c!='!')
{
p=(dl)malloc(sizeof(dnode));
p->ch=c;
p->pri=q;
p->next=NULL;
q->next=p;
q=p;
scanf("%c",&c);
getchar();
}
q=l;
while(q->next!=NULL)
{
q=q->next;
printf("%c-->",q->ch);
}
printf("\n");
while(q->pri!=NULL)
{
printf("%c-->",q->ch);
q=q->pri;
}
printf("\n");
}
//单链表就地逆置
#define NULL 0 /*宏定义*/
typedef struct node /*定义结点类型的数据结构*/
{
char c; /*数据域，类型为字符型*/
struct node *next; /*指针域，类型为本结构体类型*/
}Node,*L; /*类型重定义，即Node和*L和struct node等价*/
main()
{
L l,p,q,r; /*用指针类型定义三个结点类型的指针*/
char ch;
l=(L)malloc(sizeof(Node)); /*分配内存空间*/
l->c='\0'; /*为头结点的数据域赋值，值为空*/
l->next=NULL; /*指明下一个结点目前不存在*/
q=l; /*q为游动指针，链表结点的连结要用*/
printf("Input a character:\n");
scanf("%c",&ch);
getchar();
while(ch!='!') /*输入!表示输入结束*/
{
p=(L)malloc(sizeof(Node)); /*为新输入的数据分配内存空间*/
p->c=ch;
p->next=NULL; /*新输入的结点在链表的最后，即它的后面没有其它元素*/
q->next=p; /*q用于将上一个元素链接至当前新元素*/
q=p; /*q自己移到当前最后一个元素，以备继续链接所用*/
scanf("%c",&ch);
getchar();
}
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
printf("\n");
//以上完成了单链表的创建
q=l->next;
p=q->next;
r=p->next;
q->next=NULL;
while(r!=NULL)
{
p->next=q;
q=p;
p=r;
if(r->next!=NULL) //r后面还有结点，则逆置继续
r=r->next;
else
break;
}
r->next=q;
l->next=r; //头结点指向最后一个结点
q=l; /*输入整个链表前，先将q移到链表头，l一般不动*/
while(q->next!=NULL) /*若q所指向的元素后面还有其它元素，则将该元素的数据输出*/
{
printf("%c-->",q->next->c); /*q->next->c表示q所指向的下一个元素的数据*/
q=q->next; /*完成该元素的输出后，q移至下一个元素重复输出操作*/
}
printf("\n");
}
//约瑟夫环问题
#include<stdio.h>
#include<malloc.h>
typedef struct lnode
{
int num;
struct lnode *next;
}node,*L;
main()
{
int amount,start,circle,n,c;
L p,l,q;
printf("一共有几个人围成一圈？\n");
scanf("%d",&amount);
getchar();
printf("从第几个开始计数？\n");
scanf("%d",&start);
getchar();
printf("每几人一次循环？\n");
scanf("%d",&circle);
getchar();
l=(L)malloc(sizeof(node)); //头结点
l->next=NULL;
l->num=0;
q=l;
n=0;
while(n++<amount)
{
p=(L)malloc(sizeof(node));
p->next=NULL;
p->num=n;
q->next=p;
q=p;
}
q->next=l->next; //形成循环链表
//以上完成了单向循环链表的建立
p=l->next;
q=l;
n=1;
while(n++<start)
{
p=p->next;
q=q->next;
}
//退出循环时p,q分别位于指定位置
//接下去进行周期性结点删除，直到链表只余一个结点为止
n=1; //n计算被删除的结点的数量，当n=amount-1时删除结束
while(n++<amount)
{
c=1; //c作为循环临时变量
while(c++<circle)
{
p=p->next;
q=q->next;
}
//删除当前p指向的结点
printf("删除结点%d\t",p->num);
q->next=p->next;
p=p->next;
}
printf("\n最后剩下%d\n",p->num);
}
二、栈及其操作
//All copyright are preserved bycobby
/*建立堆栈*/
#include<stdio.h>
#include<malloc.h>
#define NULL 0
typedef struct node
{
char ch;
struct node *next;
}Snode,*stack;
main()
{
stack s,top,p;
char ch;
s=(stack)malloc(sizeof(Snode));
s->ch='\0';
s->next=NULL; /*建立栈底指针*/
top=s;
scanf("%c",&ch);
getchar();
while(ch!='!')
{
p=(stack)malloc(sizeof(Snode));
p->ch=ch;
p->next=top;
top=p;
scanf("%c",&ch);
getchar();
}
while(top->next!=NULL)
{
printf("%c-->",top->ch);
top=top->next;
}
printf("\n");
}
//All copyright are preserved bycobby
/*进栈与出栈*/
#include<stdio.h>
#include<malloc.h>
#define NULL 0
typedef struct node
{
char ch;
struct node *next;
}Snode,*stack;
main()
{
stack s,top,p;
char ch;
int choice;
s=(stack)malloc(sizeof(Snode));
s->ch='!';
s->next=NULL; /*建立栈底指针*/
top=s;
scanf("%c",&ch);
getchar();
while(ch!='!')
{
p=(stack)malloc(sizeof(Snode));
p->ch=ch;
p->next=top;
top=p;
scanf("%c",&ch);
getchar();
}
while(p->next!=NULL) //此处p可用top代替
{
printf("%c-->",p->ch);
p=p->next;
}
printf("\n");
/*以上建立了一个堆栈*/
printf("进栈或出栈？输入“1”为进栈，输入“2”为出栈，其它则退出程序\n");
scanf("%d",&choice);
getchar();
while(choice==1||choice==2) //若不是输入1或2，则不做任何操作
{
if(choice==1)
{
/*进栈*/
printf("\n输入要入栈的元素\n");
scanf("%c",&ch);
getchar();
p=(stack)malloc(sizeof(Snode));
p->ch=ch;
p->next=top;
top=p;
}
else if(choice==2)
{
if(top->next!=NULL)
top=top->next;
else
{
printf("栈已清空\n");
exit();
}
/*出栈*/
}
//printf("%c-->",top->ch);
p=top;
while(p->next!=NULL)
{
printf("%c-->",p->ch);
p=p->next;
}
printf("\n");
printf("进栈或出栈？输入“1”为进栈，输入“2”为出栈，其它则退出程序\n");
scanf("%d",&choice);
getchar();
}
}
//All copyright are preserved bycobby
//栈的应用，括号匹配
#include<stdio.h>
#include<malloc.h>
#define NULL 0
typedef struct node
{
char ch;
struct node *next;
}snode,*stack;
main()
{
stack s,top,p;
char *string,ch[100]="";
s=(stack)malloc(sizeof(snode)); //建立栈底元素
s->ch='\0';
s->next=NULL;
top=s;
printf("输入一个含括号的四则运算表达式：\n");
scanf("%s",ch);
string=ch;
while(*string!='\0')
{
if(*string=='('||*string=='['||*string=='{') //遇到左括号，入栈
{
p=(stack)malloc(sizeof(snode));
p->ch=*string;
p->next=top;
top=p;
}
else if(*string==')'||*string==']'||*string=='}') //遇到右括号
{
if(*string==')')
if(top->ch=='(') //括号匹配
top=top->next;
else
{
printf("小括号不匹配");
exit(0);
}
else if(*string==']')
if(top->ch=='[') //括号匹配
top=top->next;
else
{
printf("中括号不匹配");
exit(0);
}
else
if(top->ch=='{') //括号匹配
top=top->next;
else
{
printf("大括号不匹配");
exit(0);
}
}
string++;
}
if(top->ch!='\0')
printf("多出左括号%c\n",top->ch);
}
三、队及其操作
//All copyright are preserved bycobby
//链队列的建立
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define NULL 0
typedef struct node //队列结点的基本数据结构，即队列中每个结点的类型
{
char c;
struct node *next;
}qnode,*basic_node;
typedef struct //队列实际上由头、尾两个结点指针构成，即头指针和尾指针唯一确定时，队列也被唯一确定
{
qnode *head;
qnode *rear;
}queue,*Q;
main()
{
Q q; //定义队列，结构体变量q中含有头指针head和尾指针rear，所以q是一个完整的队列（只不过队列为空）
//事实上，任何由Q定义的结构体变量都是一个独立完整的队列
basic_node p,l; //basic_node是基本结点类型，即是独立的结点，它是组成队列的基本元素。
//基本结点p,l和队列q的关系可由下图表示：
// (q->head)--->p--->l--->p--->l--->……--->p--->l--->(q->rear)
char ch;
q=(Q)malloc(sizeof(queue));
q->head=NULL; //初始化时队列为空
q->rear=NULL;
printf("输入队列元素:\n");
scanf("%c",&ch);
getchar();
while(ch!='!')
{
p=(qnode*)malloc(sizeof(qnode));
p->c=ch;
p->next=NULL; //新来的元素一定在队列的最后，它的后面没有其它元素
if(q->head==NULL)
{
q->head=p; //第一个元素入队时，队头指针指向它
l=q->head; //l指向第一个元素
}
l->next=p; //使前一个元素指向当前入队的新元素
l=p; //l移动到当前新元素，以备用下次入队操作
q->rear=p; //修改队尾指针，使其总是指向当前最后一个队列元素
scanf("%c",&ch);
getchar();
}
l=q->head;
while(l!=NULL)
{
printf("%c<--",l->c);
l=l->next;
}
printf("\n");
printf("头指针指向元素为%c\t尾指针指向元素为%c\n",q->head->c,q->rear->c );
}
//All copyright are preserved bycobby
//入队和出队
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define NULL 0
typedef struct node //队列结点的基本数据结构，即队列中每个结点的类型
{
char c;
struct node *next;
}qnode,*basic_node;
typedef struct //队列实际上由头、尾两个结点指针构成，即头指针和尾指针唯一确定时，队列也被唯一确定
{
qnode *head;
qnode *rear;
}queue,*Q;
main()
{
Q q; //定义队列，结构体变量q中含有头指针head和尾指针rear，所以q是一个完整的队列（只不过队列为空）
//事实上，任何由Q定义的结构体变量都是一个独立完整的队列
basic_node p,l; //basic_node是基本结点类型，即是独立的结点，它是组成队列的基本元素。
//基本结点p,l和队列q的关系可由下图表示：
// (q->head)--->p--->l--->p--->l--->……--->p--->l--->(q->rear)
char ch;
int choice;
q=(Q)malloc(sizeof(queue));
q->head=NULL; //初始化时队列为空
q->rear=NULL;
printf("输入队列元素:\n");
scanf("%c",&ch);
getchar();
while(ch!='!')
{
p=(qnode*)malloc(sizeof(qnode));
p->c=ch;
p->next=NULL; //新来的元素一定在队列的最后，它的后面没有其它元素
if(q->head==NULL)
{
q->head=p; //第一个元素入队时，队头指针指向它
l=q->head; //l指向第一个元素
}
l->next=p; //使前一个元素指向当前入队的新元素
l=p; //l移动到当前新元素，以备用下次入队操作
q->rear=p; //修改队尾指针，使其总是指向当前最后一个队列元素
scanf("%c",&ch);
getchar();
}
l=q->head;
while(l!=NULL)
{
printf("%c<--",l->c);
l=l->next;
}
printf("\n");
printf("头指针指向元素为%c\t尾指针指向元素为%c\n",q->head->c,q->rear->c );
//以上建立了一个队列
printf("输入1进行入队，输入2进行出队:\n");
scanf("%d",&choice);
getchar();
if(choice==1)
{
printf("\n输入要入队的元素:\n");
scanf("%c",&ch);
getchar();
p=(qnode*)malloc(sizeof(qnode)); //给新入队的元素分配内存空间
p->c=ch;
p->next=NULL; //新元素为最后一个元素
q->rear->next=p; //原来最后一个元素指向新入队的元素
q->rear=p; //修改队尾指针，使其指向当前最后一个元素
}
else if(choice==2)
q->head=q->head->next;
else
exit(0);
l=q->head;
while(l!=NULL)
{
printf("%c<--",l->c);
l=l->next;
}
printf("\n");
printf("头指针指向元素为%c\t尾指针指向元素为%c\n",q->head->c,q->rear->c );
}
//All copyright are preserved bycobby
//循环队列建立
#include<stdio.h>
#include<malloc.h>
#define MAX 8
typedef struct
{
char c[MAX]; //循环队列是顺序队列的一种，它的核心就是一个数组
int front; //整形变量，作为头指针用
int rear; //整形变量，作为尾指针用
}queue;
main()
{
queue *q;
char ch;
int i;
q=(queue*)malloc(sizeof(queue)); //生成一个空循环队列
for(i=0;i<MAX;i++)
q->c[i]='\0';
q->front=0;
q->rear=0;
printf("输入要入队的元素:\n");
scanf("%c",&ch);
getchar();
while(ch!='!')
{
if((q->rear+1)%MAX==q->front) //若队列已满
{
printf("队列已满，无法入队\n");
break;
}
else
{
q->c[q->rear]=ch; //rear指向当前可入队的数组元素位置
q->rear=(q->rear+1)%MAX; //修改尾指针，向后移动一个位置
//注意，不能简单使用q->rear++，不然会导致队列溢出
}
scanf("%c",&ch);
getchar();
}
for(i=q->front;i<q->rear;i=(i+1)%MAX) //能够用for循环，说明了顺序队列和链式队列的区别
printf("%c<--",q->c[i]);
printf("\n");
}
//All copyright are preserved bycobby
//循环队列的入队和出队操作
#include<stdio.h>
#include<malloc.h>
#define MAX 8
typedef structd
{
char c[MAX]; //循环队列是顺序队列的一种，它的核心就是一个数组
int front; //整形变量，作为头指针用
int rear; //整形变量，作为尾指针用
}queue;
main()
{
queue *q;
char ch;
int i,choice;
q=(queue*)malloc(sizeof(queue)); //生成一个空循环队列
for(i=0;i<MAX;i++)
q->c[i]='\0';
q->front=0;
q->rear=0;
printf("输入要入队的元素:\n");
scanf("%c",&ch);
getchar();
while(ch!='!')
{
if((q->rear+1)%MAX==q->front) //若队列已满
{
printf("队列已满，无法入队\n");
break;
}
else
{
q->c[q->rear]=ch; //rear指向当前可入队的数组元素位置
q->rear=(q->rear+1)%MAX; //修改尾指针，向后移动一个位置
//注意，不能简单使用q->rear++，不然会导致队列溢出
}
scanf("%c",&ch);
getchar();
}
printf("头指针指向元素为%d\t尾指针指向元素为%d\n",q->front,q->rear);
for(i=q->front;i<q->rear;i=(i+1)%MAX) //能够用for循环，说明了顺序队列和链式队列的区别
printf("%c-->",q->c[i]);
printf("\n");
//以上建立了一个循环队列
printf("输入1入队，输入2出队:\n");
scanf("%d",&choice);
getchar();
while(choice==1||choice==2)
{
if(choice==1)
{
printf("输入要入队的元素\n");
scanf("%c",&ch);
getchar();
if((q->rear+1)%MAX==q->front) //若队列已满
{
printf("队列已满，无法入队\n");
break;
}
else
{
q->c[q->rear]=ch; //rear指向当前可入队的数组元素位置
q->rear=(q->rear+1)%MAX; //修改尾指针，向后移动一个位置
//注意，不能简单使用q->rear++，不然会导致队列溢出
}
}
else if(choice==2)
{
if((q->front+1)%MAX!=q->rear) //队非空
{
q->c[q->front]='\0'; //删除元素
q->front=(q->front+1)%MAX; //修改队头指针
}
else
{
printf("队已清空\n");
break;
}
}
if(q->rear>q->front) //尾指针在头指针的右边
{
for(i=q->front;i<q->rear;i=(i+1)%MAX) //能够用for循环，说明了顺序队列和链式队列的区别
printf("%c<--",q->c[i]);
printf("\n");
}
else //尾指针在头指针的左边
{
for(i=q->front;i<(q->rear+MAX);i++) //能够用for循环，说明了顺序队列