<file_sep>#include "../head/LinkStack.h"
#include<stdio.h>
#include<stdlib.h>
Status initLStack(LinkStack *s) {
	s->top = (LinkStackPtr)malloc(sizeof(StackNode));
	if(!(s->top))
		return ERROR;
	s->top = NULL;
	s->count = 0;
	return SUCCESS;
}
Status isEmptyLStack(LinkStack *s) {
	if(!(s->top)) {
		printf("栈为空！\n");
		return ERROR; 
	}
	else {
		printf("栈不为空！\n");
		return SUCCESS; 
	}
}
Status getTopLStack(LinkStack *s,ElemType *e) {
	if(!(s->top)) {
		printf("栈为空！\n");
		return ERROR;
	}
	else {
		*e = s->top->data;
		printf("获取栈顶元素成功！\n");
		printf("栈顶元素为%d\n",*e); 
		return SUCCESS;
	}
}
Status clearLStack(LinkStack *s) {
	s->top = NULL;
	return SUCCESS;
}
Status destroyLStack(LinkStack *s) {
	StackNode *p;
	p = s->top;
	while(s->top) {
		s->top = p->next;
		free(p);
		p = s->top; 
	}
	return SUCCESS;
}
Status LStackLength(LinkStack *s,int *length) {
	StackNode *p;
	p = s->top;
	*length = 0;
	while(p) {
		(*length)++;
		p=p->next;
	}
	return SUCCESS;
}
Status pushLStack(LinkStack *s,ElemType data) {
	StackNode *p;
	p = (StackNode *)malloc(sizeof(StackNode));
	if(!p)
		return ERROR;
	p->data = data;
	p->next = s->top;
	s->top = p;
	s->count++;
	printf("入栈成功！\n"); 
	return SUCCESS; 
}
Status popLStack(LinkStack *s,ElemType *data) {
	StackNode *p;
	p = s->top;
	if(!p)
		return ERROR;
	if(!(s->top)) {
		printf("栈为空！\n");
		return ERROR;
	}
	*data = p->data;	
	s->top = p->next;
	s->count--;
	free(p);
	printf("出栈成功！\n");
	return SUCCESS; 
}
Status TraverseStack(LinkStack *s) {
 	int i;
 	StackNode *p = s->top;
 	if (!(s->top)) 
		return ERROR;
 	for(i=s->count;i>0;i--) {
		printf("%d ",p->data);
		p=p->next;
	}
	return SUCCESS;
}
int chnum(char *str) {
	int i,n,num=0;
	for(i=0;str[i]!='\0';i++){
		if(str[i]>='0'&&str[i]<='9') {
			num=num*10+str[i]-'0';
		}
	}
	return num;
}
<file_sep>driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///day01
username=root
password=<PASSWORD>
initialSize=5
maxActive=10
maxWait=3000<file_sep>#QG训练营后台组第四周周记：
2020年4月27日

## 生活随记
还有两天就最终考核了，完成了最后一次训练营的作业，也总算兑现了自己的承诺“坚持下来”，最终考核的结果怎么样谁也不知道，但是我觉得在这一个月内自己成长了很多，在训练营的日子也算痛并快乐着，期间踩了无数的坑，查各个网站的资料，不停的尝试，把一个个困扰着自己的问题解决掉，也是因为这样，在这种高压状态下学到了很多很多知识，独自解决问题的能力和抗压能力都在不断地提升，我也会时刻警醒自己少犯错，少走弯路，这样效率才会高，才会进步。

##一周总结
（1）在改进自己的登录注册页面，理解前后端的数据共享，同时也在学习Filter和Jquery相关的知识点。

（2）完成了这周的大组作业，掌握了数据结构二叉树的遍历，创建表达树，以及中缀表达式转前缀表达式等知识。
    
##存在问题
（1）最近时间分配的不太好，临近考核要学的东西很多，课内的作业有点跟不上。

（2）平时熬夜多，早上起来迟，作息不规律。

##下周规划
准备好奋斗最终考核的大项目。


<file_sep>#include "../head/SqStack.h"
#include<stdio.h>
#include<stdlib.h>
void main()
{
	SqStack *s;
	ElemType data,e;
	char a[100],b[100];int num,length;
	s=(SqStack *)malloc(sizeof(SqStack));
	s->size=100;
	initStack(s,s->size);
	while(1) {
		printf("****************************************************************\n");
		printf("*                                                              *\n");
		printf("*******************数据结构之数组栈程序设计********************\n");
		printf("*                                                              *\n");
		printf("***************作者:梁德钊(3119005103)软工三班******************\n");
		printf("*                      1.判断栈链是否为空                      *\n");
		printf("*                      2.得到栈顶元素                          *\n");
		printf("*                      3.清空栈                                *\n"); 
		printf("*                      4.销毁栈                                *\n"); 
		printf("*                      5.检测栈长度                            *\n"); 
		printf("*                      6.入栈                                  *\n"); 
		printf("*                      7.出栈                                  *\n");
		printf("*                      8.遍历栈                                *\n");
		printf("*                      0.退出程序                              *\n");
		printf("****************************************************************\n");  
		printf("请输入要执行的操作前的选项：");
		while(1) {
			gets(a);
			num=a[0]-'0';
			if(a[0]>='0'&&a[0]<='8')break; 
			printf("输入错误，请再次输入："); 
		}
		switch(num){
			case 1:
				system("cls");
				printf("*********************\n");
				isEmptyStack(s);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				printf("*********************\n");
				getTopStack(s,&e);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				clearStack(s);
				printf("*********************\n");
				printf("清空成功！\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				system("cls");
				destroyStack(s);
				printf("*********************\n");
				printf("销毁成功！\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				system("cls");
				stackLength(s,&length);
				printf("*********************\n");
				printf("栈长度为:%d\n",length);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				system("cls");
				printf("*********************\n");
				printf("请输入入栈的数据(data)：");
				gets(a);
				pushStack(s,chnum(a)); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				system("cls");
				printf("*********************\n");
				popStack(s,&data); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				system("cls");
				printf("*********************\n");
				printf("栈数据为："); 
				TraverseStack(s);
				printf("\n"); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
}
<file_sep>#QG训练营后台组第二周周记：
2020年4月12日

## 生活随记
最近的生活还是一如既往的紧凑哎，除了网课布置的作业，还得去跟上训练营的进度，不过有一点值得说的是心态好像平缓的好多，不像之前那样急躁。收到消息好像快要开学了，得好好把握这个月了，现在都这么忙估计回学校更加忙。

##一周总结
（1）最近这周在学JDBC和MYSQL，在不停的刷视频，但是还是有很多搞不懂的地方。

（2）在写大组作业的时候学会怎样巧用void*和void *memcpy(void *destin, void *source, unsigned n);
实现c语言的泛型。

##存在问题
1.在写队列的时候指针方面出错很多，然后花了很多时间去改。

2.小组作业写Java项目的时候的格式不太规范。

3.完成效率很慢了，基本上完成作业都要花上一天多。

##下周规划
1.呜呜呜这周的高数测验要来了，要好好备考高数第一次测验。

2.继续刷视频学servlet，学完的话再继续学下去。
<file_sep>#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

typedef enum Status 
{
	ERROR = 0, SUCCESS = 1
} Status;

typedef char ElemType;
typedef struct SqStack 
{
	ElemType *elem;
	int top;
	int size;
} SqStack;
typedef struct SqStack1 
{
	float *elem1;
	int top;
	int size;
} SqStack1;

Status destroyStack(SqStack *s);
Status initStack(SqStack *s,int sizes);
Status initStack1(SqStack1 *s,int sizes);
Status isEmptyStack(SqStack *s);
Status pushStack(SqStack *s,ElemType data);
Status pushStack1(SqStack1 *s,float data);
Status popStack(SqStack *s,ElemType *data);
Status popStack1(SqStack1 *s,float *data);
int chnum(char a);
void Calculate();
#endif
<file_sep>#include"../AQueue/AQueue.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void InitAQueue(AQueue *Q){
	int i;
	Q->length=MAXQUEUE;
	for(i=0;i<MAXQUEUE;i++) {
		Q->data[i] = (void *)malloc(20);
	}
	Q->front = 0;
	Q->rear = 0; 
	datatype[Q->rear]='i'; 
	printf("队列初始化成功！\n"); 
}

void DestoryAQueue(AQueue *Q) {
	int i;
	if(Q->data[0]==NULL) {
		printf("队列未初始化！\n");
		return;
	}
	for(i=0;i<MAXQUEUE;i++) {
		free(Q->data[i]);
	}
	printf("销毁队列成功！\n");
	Q->data[0]=NULL;
}

Status IsFullAQueue(const AQueue *Q) {
	if(Q->data[0]==NULL) {
		printf("队列未初始化！\n");
		return -1;
	}	
	return Q->front==(Q->rear+1)%MAXQUEUE ? TRUE:FALSE;
}

Status IsEmptyAQueue(const AQueue *Q) {
	int i;
	if(Q->data[0]==NULL) {
		printf("队列未初始化！\n");
		return -1;
	}
	return Q->rear==Q->front ? TRUE:FALSE;
}

Status GetHeadAQueue(AQueue *Q,void *e) {
	int flag;
	flag=IsEmptyAQueue(Q);
	if(flag==-1) return FALSE;
	memcpy(e,Q->data[Q->front],20); 
	printf("获取头元素成功！\n");
	return TRUE;
}

int LengthAQueue(AQueue *Q) {
	int len;
	if(IsEmptyAQueue(Q)==-1)
		return FALSE;
	len=(Q->rear+1-Q->front+Q->length)%Q->length;
	return len; 
}

Status EnAQueue(AQueue *Q, void *data) {
	int flag; 
	flag=IsFullAQueue(Q);
	if(flag==-1) return FALSE;
	if(flag==TRUE) {
		printf("队列已满!\n");
		return FALSE;
	}
	Q->rear=(Q->rear+1)%MAXQUEUE;
	memcpy(Q->data[Q->rear],data,20);
	return TRUE;
}

Status DeAQueue(AQueue *Q) {
	int flag; 
	flag=IsEmptyAQueue(Q);
	if(flag==-1) return FALSE;
	if(flag==TRUE) {
		printf("队列为空!\n");
		return FALSE;
	}
	Q->front=(Q->front+1)%MAXQUEUE;
	printf("出队成功！\n");
	return TRUE;
}

void ClearAQueue(AQueue *Q) {
	if(Q->data[0]==NULL) {
		printf("队列未初始化！\n");
		return;
	}
	Q->front=0;
	Q->rear=0; 
	printf("清空成功！\n");
}

Status TraverseAQueue(const AQueue *Q, void (*foo)(void *q,char type)) {
	int i,j,flag;
	j=0;i=Q->front;
	flag=IsEmptyAQueue(Q);
	if(flag==-1) return FALSE;
	while(j<=(Q->rear-Q->front+MAXQUEUE)%MAXQUEUE) {
		foo(Q->data[i],datatype[i]);
		i=(i+1)%MAXQUEUE;
		j++;
	}
	printf("\n");
	return TRUE;
}

void APrint(void *q,char type) {
	if(type=='d')
		printf("-->%lf",*(double *)q);
	else if(type=='c')
		printf("-->%c",*(char *)q);
	else if(type=='i')
		printf("-->%d",*(int *)q);
	else if(type=='s')
		printf("-->%s",(char *)q);
} 
<file_sep>#include "../head/duLinkedList.h"
#include<stdlib.h>
#include<stdio.h>
/**
 *  @name        : Status InitList_DuL(DuLinkedList *L)
 *	@description : initialize an empty linked list with only the head node
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status InitList_DuL(DuLinkedList *L) {
	*L=(DuLinkedList)malloc(sizeof(DuLNode));
	if(!(*L))
		return ERROR;
	(*L)->next=NULL;
	(*L)->prior=NULL;
	return SUCCESS; 
}

/**
 *  @name        : Status CreateList_DuL(DuLinkedList *L)
 *	@description : Create a new linked list with data
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status CreateList_DuL(DuLinkedList *L) {
	int n=0;
	char str[100],str1[100],end[3]="end";
	DuLNode *p1,*p2;
	p1=p2=(DuLinkedList)malloc(sizeof(DuLNode));
	printf("请输入节点的数据,输入end结束\n->");
	gets(str1);
	gets(str);
	p1->data=chnum(str);
	while(strcmp(str,end)) {
		n++;
		if(n==1) {
			(*L)->next=p1;
			p1->prior=(*L);
		}
		else {
			p2->next=p1;
			p1->prior=p2;
		}
		p2=p1;
		printf("->");
		p1=(DuLinkedList)malloc(sizeof(DuLNode));
		gets(str);
		p1->data=chnum(str);
	}
	p2->next=NULL;
	return SUCCESS;
}

/**
 *  @name        : void DestroyList_DuL(DuLinkedList *L)
 *	@description : destroy a linked list
 *	@param		 : L(the head node)
 *	@return		 : status
 *  @notice      : None
 */
void DestroyList_DuL(DuLinkedList *L) {
	DuLNode *p;
	while(*L) {
		p=(*L);
		(*L)=(*L)->next;
		free(p);
		if(*L)
			(*L)->prior=NULL;
	}	
}

/**
 *  @name        : Status InsertBeforeList_DuL(DuLNode *p, LNode *q)
 *	@description : insert node q before node p
 *	@param		 : p, q
 *	@return		 : status
 *  @notice      : None
 */
Status InsertBeforeList_DuL(DuLNode *p, DuLNode *q) {
	if(!p)
		return ERROR;
	p->prior->next = q;
	q->prior = p->prior;
	q->next = p;
	p->prior = q;
	return SUCCESS;
}

/**
 *  @name        : Status InsertAfterList_DuL(DuLNode *p, DuLNode *q)
 *	@description : insert node q after node p
 *	@param		 : p, q
 *	@return		 : status
 *  @notice      : None
 */
Status InsertAfterList_DuL(DuLNode *p, DuLNode *q) {
	if(!p)
		return ERROR;
	if(p->next){
		p->next->prior = q;
		q->next = p->next;
	}
	else {
		q->next=NULL;
	}
	q->prior = p;
	p->next = q;
	return SUCCESS;
}

/**
 *  @name        : Status DeleteList_DuL(DuLNode *p, ElemType *e)
 *	@description : delete the first node after the node p and assign its value to e
 *	@param		 : p, e
 *	@return		 : status
 *  @notice      : None
 */
Status DeleteList_DuL(DuLNode *p, ElemType *e) {
	DuLNode *q;
	if(!(p->next))
		return ERROR;
	q = p->next;
	*e = q->data;
	if(q->next)
		q->next->prior = p;
	p->next = q->next;
	free(q);
	return SUCCESS;
}

/**
 *  @name        : void TraverseList_DuL(DuLinkedList L, void (*visit)(ElemType e))
 *	@description : traverse the linked list and call the funtion visit
 *	@param		 : L(the head node), visit
 *	@return		 : Status
 *  @notice      : None
 */
void TraverseList_DuL(DuLinkedList L, void (*visit)(ElemType e)) {
	DuLNode *p=L->next;
	while(p) {
		if(p->next==NULL)
			(*visit)(p->data);
		else {
			(*visit)(p->data);
			printf("->");
		}
		p=p->next;
	}
}
/**
 *  @name        : void visit(ElemType e)
 *	@description : print e
 *	@param		 : e
 *	@return		 : None
 *  @notice      : None
 */
void visit(ElemType e) {
	printf("%d",e);
}

/**
 *  @name        : long int chnum(char *str)
 *	@description : String to integer
 *	@param		 : str
 *	@return		 : num
 *  @notice      : None
 */
int chnum(char *str) {
	int i,n,num=0;
	for(i=0;str[i]!='\0';i++){
		if(str[i]>='0'&&str[i]<='9') {
			num=num*10+str[i]-'0';
		}
	}
	return num;
}
<file_sep>#第一周周记
##初来到训练营的感受
经历了两轮的面试，有幸能够加入到QG训练营中去锻炼自己的能力，其实也不管那么多了，无论能不能进到QG工作室，我还是很开心的，起码能在训练营这段时间给自己施加压力去学新的知识。上周五的时候听完大组的培训后，开始了第一次作业，一开始慌得一批，主要是不清楚作业的要求，而且时间也挺紧的，本来自己的进度就不够别人快，四天内学git,github,markdown,实现双链表和单链表的各个接口。没办法只能硬着头皮去完成，智商不够时间来凑。
##学到的新知识
1.懂得了git和github的结构，怎样去提交自己的代码到本地仓库和远程仓库，在git bash里面输入命令行去实现各种文件的管理操作。

2.在实现duLinkedList.c和LinkedList.c中实现了链表的各种操作，刚开始搞不清楚形参为什么是二级指针，这个点疑惑了很久，原来如果形参是一级指针，那么只会改变指针指向的内容，传进来的指针是不会改变的，而在进行链表的操作时头指针的值经常会发生改变，所以需要传该指针的地址，形参定义二级指针。

3.记录一下选做偶数反转实现的方法和自己的理解

首先，需要判断链表的结点数是奇或偶

###图为改变节点指向的思路
![](1.png)

###偶数反转相关代码
    
	LNode* ReverseEvenList(LinkedList *L) {
	LNode *p1,*p2,*p3;
	p1=(*L)->next;
	(*L)->next=p1->next;		
	while(p1&&p1->next) {
		p2=p1->next;
		p3=p2->next;
		if(p2->next&&p2->next->next) {
			p1->next=p3->next;
		}
		else {
			p1->next=p2->next;
		}
		p2->next=p1;
		p1=p3;
	}
	return *L;
	}
##总结一下
平时的进度要加快，以后的项目更这次肯定难得多，还是要不断去坚持，规划好自己的学习计划。<file_sep>#QG训练营后台组第四周周记：
2020年4月19日

## 生活随记
距离考核的时间越来短了，在高压的工作状态中不得不快速学习接收大量的东西，不知道为什么感觉自己信心不是很足够，可能是因为自己的进度慢吧，担心自己完成不了，但没办法既然自己已经做出了选择，就一定要坚持下去，我希望自己真正能做到这一点，临近最终考核，自己更加要一步一步踏实地做好自己的事情。

##一周总结
（1）最近这周在学servlet&jsp。

（2）掌握了排序的各种算法，印象最深刻的就是用递归实现快排和归并，通过写非递归版的快排也让我更深刻理解到递归这个过程，栈和递归的原理差不多，都是先进后出，后进先出，那么递归的算法也就可以利用堆栈来实现。
    
记录一下快排（非递归版）的代码

	void QuickSort(int *a,long size) {
	int *stack;
	stack = (int *)malloc(sizeof(int)*size);
	int top,begin,end,mid;
	top=begin=0;end=size-1;
	mid = QuickSort_Recursion(a,begin,end);
	if(mid>begin+1) {
		stack[top++] = begin;
		stack[top++] = mid-1;
	}
	if(mid<end-1) {
		stack[top++] = mid+1;
		stack[top++] = end;
	}
	while(top>0) {
		end = stack[--top];
		begin = stack[--top];
		mid = QuickSort_Recursion(a,begin,end);
		if(mid>begin+1) {
			stack[top++] = begin;
			stack[top++] = mid-1;
		}
		if(mid<end-1) {
			stack[top++] = mid+1;
			stack[top++] = end;
		}
	}
	}

##存在问题
1.学servlet&jsp的时候遇到很多配置上的问题。

2.自己代码的分包不规范。

##下周规划
1.继续刷视频学下去，完成这周的作业任务。
<file_sep>#include"D:/QG训练营第五次培训/inc/BinaryTree.h"
#include"stdio.h" 
#include"stdlib.h"
#include"string.h"
void main()
{ 
	int i;
	int enter;
	char a[100]; 
	char *definition;
	BiTree T=NULL;
	while(1) {
		printf("*********************************************\n");
		printf("***************二叉树相关操作****************\n");
		printf("***            1.初始化二叉树             ***\n");
		printf("***            2.销毁二叉树               ***\n");
		printf("***            3.前缀表达式构造树         ***\n");
		printf("***            4.表达树求值               ***\n");
		printf("***            5.非递归遍历树             ***\n");
		printf("***            6.先序遍历                 ***\n");
		printf("***            7.中序遍历                 ***\n");
		printf("***            8.后序遍历                 ***\n");
		printf("***            9.层序遍历                 ***\n");
		printf("***            0.结束程序                 ***\n");
	    printf("*********************************************\n");
		printf("*********************************************\n");
		printf("请输入选项：");
		while(1) {
			gets(a);
			if(a[0]>='0'&&a[0]<='9') {
				enter=a[0]-'0';
				break;
			} 	
			printf("输入错误,请再次输入："); 
		}
		system("cls");
		switch(enter) {
			case 1:
				InitBiTree(&T);
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break; 
			case 2:
				if(T==NULL){
				 	printf("二叉树为空树！\n");
				}else{
					DestroyBiTree(&T);
					printf("销毁成功！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3: 
				if(T!=NULL) {
					printf("该二叉树已存在!如果要重新构造树请先销毁\n");
					break; 
				} 
				printf("请输入中缀表达式\n");
				definition=(char *)malloc(sizeof(int)*20);
				scanf("%s",definition);
				gets(a); 
 				change(definition);
				printf("转换得前缀表达式为:\n"); 
				for(i=0;definition[i]!='\0';i++){
					printf("%c ",definition[i]);
				}
				CreateBiTree(&T,definition);
				memset(definition,0,sizeof(definition));
				printf("\n");
				printf("构造二叉树成功!\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				if(T==NULL){
					printf("二叉树为空！\n");
				}else{
					printf("表达树为\n");
					PreOrderTraverse(T,visit);
					printf("\n");
					printf("求得表达树的值为%d\n",value(T)); 
				}
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				if(T==NULL) {
					printf("二叉树为空树！\n");
				}else{
					printf("遍历二叉树的结果为:\n");
					Traverse(T,visit);
				}
				printf("\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;	
			case 6:
				if(T==NULL){
					printf("二叉树为空！\n");
				}else{
					printf("遍历二叉树的结果为:\n");
					PreOrderTraverse(T,visit);
				}
				printf("\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				if(T==NULL){
					printf("二叉树为空！\n");
				}else{
					printf("遍历二叉树的结果为:\n");
					InOrderTraverse(T,visit);
				}
				printf("\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				if(T==NULL){
					printf("二叉树为空！\n");
				}else{
					printf("遍历二叉树的结果为:\n");
					PostOrderTraverse(T,visit);
				}
				printf("\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 9:
				if(T==NULL){
					printf("二叉树为空！\n");
				}else{
					printf("遍历二叉树的结果为:\n");
					LevelOrderTraverse(T,visit);
				}
				printf("\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0); 
		}
	}
}

<file_sep>#include"stdio.h"
#include"stdlib.h"
#include"string.h"
void main()
{		
	FILE *fp;
	int i;
	long num; 
	char fileName[100];
	printf("请输入要创建的文件名"); 
	gets(fileName);
	printf("已保存到当前目录里了哦\n");
	fp = fopen(fileName,"w");
	printf("请输入需要生成的随机数据的数量：");
	scanf("%ld",&num);
	fprintf(fp,"%d ",40000); 
	for(i=1;i<num;i++)
		fprintf(fp,"%d ",rand());
	printf("数据已生成啦！");
	fclose(fp);
}
<file_sep>#include"D:/QG训练营第五次培训/inc/BinaryTree.h"
#include"stdio.h" 
#include"stdlib.h"
#include"string.h"
Status visit(TElemType e){//打印结点元素 
	printf("%c ",e);
	return SUCCESS;
}
Status InOrderTraverse(BiTree T, Status (*visit)(TElemType e)) {//中序遍历T 
	if(T){
		InOrderTraverse(T->lchild,(*visit));
		(*visit)(T->data);
		InOrderTraverse(T->rchild,(*visit));
	}else{
		return ERROR;
	}
}
Status PostOrderTraverse(BiTree T, Status (*visit)(TElemType e)) {//后序遍历T 
	if(T){
		PostOrderTraverse(T->lchild,(*visit));
		PostOrderTraverse(T->rchild,(*visit));
		(*visit)(T->data);
	}else{
		return ERROR;
	}
}
Status PreOrderTraverse(BiTree T, Status (*visit)(TElemType e)) {//先序遍历T
	if(T){
		(*visit)(T->data);
		PreOrderTraverse(T->lchild,(*visit));
		PreOrderTraverse(T->rchild,(*visit));
	}else{
		return ERROR;
	}
}
Status InitBiTree(BiTree *T){//构造空二叉树T 
    *T=NULL;
    printf("二叉树初始化成功！\n");
    return SUCCESS;
}

Status DestroyBiTree(BiTree *T){//摧毁二叉树T
	if((*T)==NULL){
		return ERROR;
	} 
	DestroyBiTree(&((*T)->lchild));	
	DestroyBiTree(&((*T)->rchild));
	free(*T);
	*T=NULL;
	return SUCCESS;
} 
/*按前序输入二叉树中结点的值(一个字符)*/
/*definition为'#'表示空树，构造二叉链表表示二叉树T*/
Status CreateBiTree(BiTree *T, char* definition) {
	char data;
	data=nextToken(definition);
	(*T)=(BiTree)malloc(sizeof(BiTNode));
	if(!(*T)) return ERROR;
	(*T)->data=data;
	(*T)->lchild=NULL;
	(*T)->rchild=NULL;
	if(!isOpNum(data)) {
		CreateBiTree(&(*T)->lchild,definition);
		CreateBiTree(&(*T)->rchild,definition);
	}
	return SUCCESS;
} 
char nextToken(char *definition)//括号、操作数、操作符等都为一个字符 
{
	static int pos=0;
    while((definition[pos]!='\0')&&(definition[pos]==' ')){pos++;}//跳过空格 
	return definition[pos++];
}
int isOpNum(char ch)//判断是否是操作数 
{
	if(ch=='('||ch==')'||ch=='+'||ch=='-'||ch=='*'||ch=='/') {
    return 0;
	}
	return 1;
}
int value(BiTree T){
	if(T==NULL) {
		return ERROR;
	}
	if(!isOpNum(T->data)) {
		switch(T->data) {
			case '+': return value(T->lchild)+value(T->rchild);break;
			case '-': return value(T->lchild)-value(T->rchild);break;
			case '*': return value(T->lchild)*value(T->rchild);break;
			case '/': return value(T->lchild)/value(T->rchild);break;
		}
	}
	return T->data-'0';
}
void change(char *definition)
{
    char stack[100];
    int top=-1;
    int i = 0,len = 0;
    char str[200];char que[200];
    char arr[200];char tem[200];
    int rear=0,front=0;
    len = strlen(definition);
    for(i=0;i<len;i++){
		str[i]=definition[len-1-i];
		if(definition[len-1-i]=='(')str[i]=')';
		if(definition[len-1-i]==')')str[i]='('; 
	}
	i=0;
    while(str[i] != '\0')
    {
        if(str[i] == '+' || str[i] == '-')//如果str[i]是加号或减号，则先弹出栈顶直到栈已空或栈顶元素为左括号，再将str[i]压入栈
        {
            if(top==-1)//若栈已空时，栈顶指针为空，找不到其元素，故须单独讨论
            {
                stack[++top]=str[i];
            }
            else
            {
                while(stack[top] == '+' || stack[top] == '-' || stack[top] == '*' || stack[top] == '/')
                {
                    que[++rear]=stack[top--];
                }
                stack[++top]=str[i];
            }
        }
        else if(str[i] == '*' || str[i] == '/')//如果str[i]是乘号或除号，则只有栈顶也是乘除号时才需要弹出
        {
            if(top==-1)//若栈已空时，栈顶指针为空，找不到其元素，故须单独讨论
            {
                stack[++top]=str[i];
            }
            else
            {
                while(stack[top] == '*' || stack[top] == '/')
                {
                    que[++rear]=stack[top--];
                }
                stack[++top]=str[i];
            }
        }
        else if(str[i] == '(')//如果str[i]是左括号则直接压入栈
        {
            stack[++top]=str[i];
        }

        else if(str[i] == ')')//如果str[i]是右括号，则打印并弹出栈中第一个左括号前的所有操作符，最后将此左括号直接弹出
        {
            while(stack[top] != '(')
            {
                que[++rear]=stack[top--];
            }
            stack[top--];
        }
        else//如果str[i]不是操作符则直接打印
        {
            que[++rear]=str[i];
        }
        i++;
    }
    while(top!=-1)//遍历后如果栈不为空，则弹出所有操作符
    {
        que[++rear]=stack[top--];
    }
	for(i=0;i<=rear;i++){
		definition[i]='\0';
	}
    for(i=0;i<rear;i++){
		definition[i]=que[rear-i];
	} 
}
Status LevelOrderTraverse(BiTree T, Status (*visit)(TElemType e)) {//层序遍历 
	BiTree que[20];//创建储存树结点的队列 
	int front=0; 
	int rear=0;
	int len=20;
	que[0]=NULL;
	if(T==NULL){
		return ERROR;
	}
	que[++rear%len] = T;
	while(front!=rear) {
		if(que[front]!=NULL)
			(*visit)(que[front]->data);
		front=(front+1)%len;
		if(que[front]->lchild!=NULL)//如果左子树不为空则入列 
			que[++rear%len] = que[front]->lchild;
		if(que[front]->rchild!=NULL)//如果右子树不为空则入列 
			que[++rear%len] = que[front]->rchild;
	}	
	(*visit)(que[rear]->data); 
	return SUCCESS;
}

Status Traverse(BiTree T, Status (*visit)(TElemType e)) {//非递归排序 
	BiTree data[20];//定义顺序栈 
	BiTree p; 
	int top=-1;//定义栈顶坐标 
	if(T==NULL){
		printf("二叉树为空！\n");
		return ERROR;
	}
	data[++top] = T;
	while(top!=-1) {
		p = data[top--];
		(*visit)(p->data);
		if(p->rchild) {
			data[++top] = p->rchild;
		}   
		if(p->lchild) {
			data[++top] = p->lchild;
		}
	}
	return SUCCESS;
}
void menu(){
		printf("*********************************************\n");
		printf("***************二叉树相关操作****************\n");
		printf("***            1.初始化二叉树             ***\n");
		printf("***            2.销毁二叉树               ***\n");
		printf("***            3.前缀表达式构造树         ***\n");
		printf("***            4.表达树求值               ***\n");
		printf("***            5.非递归遍历树             ***\n");
		printf("***            6.先序遍历                 ***\n");
		printf("***            7.中序遍历                 ***\n");
		printf("***            8.后序遍历                 ***\n");
		printf("***            9.层序遍历                 ***\n");
		printf("***            0.结束程序                 ***\n");
	    printf("*********************************************\n");
		printf("*********************************************\n");
		printf("请输入选项：");
}






<file_sep>#include"../inc/qgsort.h"
#include"stdio.h"
#include"stdlib.h"
void insertSort(int *a,int n) {
 	int i,j,t;
 	for(i=1;i<n;i++) {
		t = a[i];
		for(j=i-1;j>=0;j--) {
			if(a[j]>t) 
				a[j+1] = a[j];
			else 
				break;
		}
		a[j+1] = t;
	}
}

void MergeArray(int *a,int begin,int mid,int end,int *temp) {
	int i,j,k;
	i=k=begin,j=mid+1;
	while(i<=mid&&j<=end) {
		temp[k++] = a[i]<a[j] ? a[i++]:a[j++];
	}
	while(i<=mid) {
		temp[k++] = a[i++];
	}
	while(j<=end) {
		temp[k++] = a[j++];
	}
	for(i=begin;i<=end;i++) {
		a[i]=temp[i];
	}
}

void MergeSort(int *a,int begin,int end,int *temp) {
	if(begin<end) {
		int mid = (begin+end)/2;
		MergeSort(a,begin,mid,temp);
		MergeSort(a,mid+1,end,temp);
		MergeArray(a,begin,mid,end,temp);
	}
}

int QuickSort_Recursion(int *a, int begin, int end) {
	int i,j,temp;
	i=begin;j=end;temp=a[begin];
	while(i<j) {
		while(i<j&&a[j]>temp)
			j--;
		if(i<j)
			a[i++] = a[j];
		while(i<j&&a[i]<temp)
			i++;
		if(i<j)
			a[j--] = a[i];
	}
	a[i] = temp;
	return i;
}

void Partition(int *a, int begin, int end) {
	if(begin<end) {
		int mid=QuickSort_Recursion(a,begin,end);
		Partition(a,begin,mid-1);
		Partition(a,mid+1,end);
	}
}

void QuickSort(int *a,long size) {
	int *stack;
	stack = (int *)malloc(sizeof(int)*size);
	int top,begin,end,mid;
	top=begin=0;end=size-1;
	mid = QuickSort_Recursion(a,begin,end);
	if(mid>begin+1) {
		stack[top++] = begin;
		stack[top++] = mid-1;
	}
	if(mid<end-1) {
		stack[top++] = mid+1;
		stack[top++] = end;
	}
	while(top>0) {
		end = stack[--top];
		begin = stack[--top];
		mid = QuickSort_Recursion(a,begin,end);
		if(mid>begin+1) {
			stack[top++] = begin;
			stack[top++] = mid-1;
		}
		if(mid<end-1) {
			stack[top++] = mid+1;
			stack[top++] = end;
		}
	}
}

void CountSort(int *a, long size , int max) {
	int *temp1,*temp2;
	int i,j,k;
	temp1 = (int *)malloc(sizeof(int)*(max+1));
	temp2 = (int *)malloc(sizeof(int)*size);
	for(i=0;i<=max;i++) temp1[i]=0;
	for(i=0;i<size;i++) temp1[a[i]]++; 
	for(i=1;i<=max;i++) {
		temp1[i]+=temp1[i-1];
	}
	i=size-1;
	for(i;i>=0;i--) {
		temp2[--temp1[a[i]]]=a[i];
	}
	for(i=0;i<size;i++) 
		a[i] = temp2[i];
}

void RadixCountSort(int *a,int size) {
	int *temp1,*temp2;
	int radix = 10;
	int count = 1; 
	int i,j,k,n;
	temp1 = (int *)malloc(sizeof(int)*(radix));//存放各个桶的元素个数，共10个桶 
	temp2 = (int *)malloc(sizeof(int)*size);//定义暂存元素数组temp2 
	n = 1;//记录基位 
	while(count<6) {
		for(i=0;i<radix;i++) temp1[i]=0;
		for(i=0;i<size;i++) {
			k = (a[i]/n)%10;
			temp1[k]++;
		}
		for(i=radix-1;i>=0;i--) {
			if(i>0) {
				for(j=i-1;j>=0;j--) {
					temp1[i] = temp1[i] + temp1[j];//统计小于等于该元素的个数 
				}
			}
		}
		i=size-1;
		for(i;i>=0;i--) {
			k = (a[i]/n)%10; 
			temp2[--temp1[k]]=a[i];
		}
		for(i=0;i<size;i++) 
			a[i] = temp2[i];
		n*=10;
		count++;
	}
} 

void ColorSort(int *a,int size) {
	int front,post,i,t;
	front = 0;
	post = size-1;
	for(i=0;i<=post;i++) { 
		if(a[i]==2) {
			t = a[i];
			a[i] = a[post];
			a[post] = t;
			post--;
		}
		if(a[i]==0) {
			t = a[i];
			a[i] = a[front];
			a[front] = t;
			front++;
			if(a[i]==2) {
				t = a[i];
				a[i] = a[post];
				a[post] = t;
				post--;	
			}
		}
	}
}

int FindSort(int *a,int begin,int end,int k){
	int index;
	if(begin==end) return a[begin];
	int par = QuickSort_Recursion(a,begin,end);
	index = end-par+1;
	if(index==k) {
		return a[par];
	}else if(index<k) {
		return FindSort(a,begin,par-1,k-index);
	}else{
		return FindSort(a,par+1,end,k);
	}
}
void CreateArray(int *a,int num1) {
 	int i;
 	a[0] = 40000;
 	for(i=1;i<num1;i++) {
  	a[i] = rand();
 	}
}
<file_sep>#include"../inc/qgsort.h"
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
void main()
{		
	char n[100];
	int **a;
	int temp[100];
	int i,j,max=40000;
	long num1; 
	clock_t start,time[6];
	while(1) {
		time[3]=0;
		printf("输入随机数组数量：");
		scanf("%ld",&num1);
		gets(n);
		a = (int **)malloc(sizeof(int *)*num1);
		for(i=0;i<num1;i++) {
			a[i] = (int *)malloc(sizeof(int)*100);
		} 
		CreateArray(a,num1);
		start = clock();	
		for(i=0;i<num1;i++) 
			insertSort(a[i],100); 
		time[0] = clock() - start;
		CreateArray(a,num1);
		start = clock();	
		for(i=0;i<num1;i++) 
			MergeSort(a[i],0,99,temp);
		time[1] = clock() - start;
		CreateArray(a,num1);
		start = clock();	
		for(i=0;i<num1;i++)
			Partition(a[i],0,99);
		time[2] = clock() - start;
		CreateArray(a,num1);
		for(i=0;i<num1;i++) {
			start = clock();
			CountSort(a[i],100,max);
			time[3] = time[3]+(clock() - start);	 
		} 
		CreateArray(a,num1);
		start = clock();	
		for(i=0;i<num1;i++) 
			RadixCountSort(a[i],100); 
		time[4] = clock() - start;
		CreateArray(a,num1);
		start = clock();	
		for(i=0;i<num1;i++) 
			QuickSort(a[i],100);
		time[5] = clock() - start;
		printf("- - - - - - - - - - - - - - - - 排序时间（单位：ms）- - - - - - - - - - - - - - - - -\n");
    	printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    	printf("|  + 插入 +  |  + 归并 +  |  + 快排 +  | + 快排(非递归) + |  + 计数 +  |  + 基数 +  |\n");
   		printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    	printf("|  +  %d  +   |  +   %d   +   |  +   %d   +  |  +  %d  +  |  +  %d  +  |  +  %d  +  |\n",time[0],time[1],time[2],time[5],time[3],time[4]);
    	printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
 		printf("输入0返回,输入1结束程序\n"); 
		while(1) {
			gets(n);
			if(n[0]=='0') break;
			if(n[0]=='1') exit(0); 
			printf("输入错误，请再次输入：");
		}
		system("cls");
	}
}
<file_sep>#include "..\代码和头文件\calculator.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{	while(1) {
	char enter[100],a[100],b[100][100],c;
	SqStack *s;SqStack1 *t;
	int i,j=0,k,h=0,flag=1,num;float k1=0,k2=0,temp=0,semp=0.1;
	s=(SqStack *)malloc(sizeof(SqStack));
	t=(SqStack1 *)malloc(sizeof(SqStack1));
	t->size=s->size=100;
	initStack(s,s->size);
	initStack1(t,t->size);
	printf("**********************************\n");
	printf("*        四则运算计算器          *\n");
	printf("**********************************\n");
	printf("请输入前缀表达式：");
	gets(a);
	if(chnum(a[0])==0) {
		system("cls");
		printf("输入错误\n");
		continue;
	} 
	for(i=0;a[i]!='\0';i++) {
		if(a[i]>='0'&&a[i]<='9') {
			b[j][h++]=a[i]; 
		} 
		if(a[i]=='.') {
			b[j][h++]=a[i];
		}
		if((chnum(a[i])!=1)&&(chnum(a[i])!=0)) {
			if(chnum(a[i-1])==1&&s->top==-1) j++;h=0;
			if(!isEmptyStack(s)) {
				pushStack(s,a[i]);
			}
			else {
				if(a[i]=='(') {
					pushStack(s,a[i]);
					
				}
				else if(a[i]==')') {
					for(k=s->top;k>-1;k--) {
						popStack(s,&c);
						if(chnum(c)!=4) {
							b[++j][0]=c; 
						}
						if(c=='(') break;
					}
				}
			 	else {
					for(k=s->top;k>-1;k--) {
						if(!isEmptyStack(s))
							break;
						if(chnum(a[i])<=chnum(s->elem[s->top])&&chnum(s->elem[s->top])!=4) {
							popStack(s,&c);
							b[++j][0]=c;
						}
						if(chnum(a[i])>chnum(s->elem[s->top])||chnum(s->elem[s->top]==4))
							break;	
					}
					pushStack(s,a[i]);j++;
				}
			}
		}	
	}
	for(i=s->top;i>-1;i--) {
		popStack(s,&c);
		b[++j][0]=c; 
	}
	
	printf("后缀表达式为：");
	for(i=0;i<=j;i++) {
		printf("%s ",b[i]);
	}
	for(i=0;i<=j;i++) {
		if(chnum(b[i][0])!=1) {
			switch(b[i][0]) {
				case '+':
					k1=(t->elem1[t->top-1])+(t->elem1[t->top]);
					popStack1(t,&k2);
					popStack1(t,&k2);
					pushStack1(t,k1);
					break;
				case '-':
					k1=(t->elem1[t->top-1])-(t->elem1[t->top]);
					popStack1(t,&k2);
					popStack1(t,&k2);
					pushStack1(t,k1);
					break;
				case '*':
					k1=(t->elem1[t->top-1])*(t->elem1[t->top]);
					popStack1(t,&k2);
					popStack1(t,&k2);
					pushStack1(t,k1);
					break;
				case '/':
					k1=(t->elem1[t->top-1]/t->elem1[t->top]);
					popStack1(t,&k2);
					popStack1(t,&k2);
					pushStack1(t,k1);
					break;
			}
		}
		else {
			for(k=0;k<strlen(b[i]);k++) {
				if(b[i][k-1]=='.') flag=0;
				if(flag&&b[i][k]!='.') 
					temp=temp*10+b[i][k]-'0';
				if(flag==0) {
					temp=temp+semp*(b[i][k]-'0');
					semp/=10;
				}
			}
			pushStack1(t,temp);
			temp=0,semp=0.1,flag=1;
		}	
	}
	popStack1(t,&k1);
	printf("\n结果为=%f",k1); 
	printf("\n输入1重置,输入0结束程序：\n"); 
		while(1) {
			gets(enter);
			num=enter[0]-'0';
			if(enter[0]=='0')
				exit(0);
			if(enter[0]=='1') {
				system("cls");
				break;
			} 
			printf("输入错误!请再次输入："); 
		}
	}
}
<file_sep>#include"../inc/qgsort.h"
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
void main()
{		
	FILE *fp;
	int num;
	int *a,*temp;
	long i,n,enter;//n为数据的个数，也是存储数据的数组长度 
	char path[100],inp[100];
	clock_t start,time[6];
	while(1) {
		while(1) {
			printf("请输入生成测试数据的文件路径：");
			gets(path);
			fp = fopen(path,"r"); 
			if(fp==NULL) {
				system("cls"); 
				printf("文件不存在！\n");
			}
			else break;
		}
		for(n=1;n<1000000;n++) {
			fscanf(fp,"%d",&num);
			if(num==0) {
				n-=1;
				break;
			}
			num = 0;
		}
		close(fp);
		fp = fopen(path,"r");
		a = (int *)malloc(sizeof(int)*n);
		for(i=0;i<n;i++) {
			fscanf(fp,"%d",&a[i]);
		}
		close(fp);
		printf("文件的数据已读取成功哦\n");
		printf("*********************************************\n");
		printf("************请选择那种方法排序***************\n");
		printf("***            1.插入排序                 ***\n");
		printf("***            2.归并排序                 ***\n");
		printf("***            3.快速排序                 ***\n");
		printf("***            4.快速排序(非递归)         ***\n");
		printf("***            5.计数排序                 ***\n");
		printf("***            6.基数排序                 ***\n");
		printf("***            0.结束程序                 ***\n");
	    printf("*********************************************\n");
		printf("*********************************************\n");
		printf("请输入选项：");
		while(1) {
			gets(inp);
			if(inp[0]>='0'&&inp[0]<='6') {
				enter=inp[0]-'0';
				break;
			} 	
			printf("输入错误,请再次输入："); 
		}
		system("cls");
		switch(enter) {
			case 1:
					start = clock();	
					insertSort(a,n); 
					time[0] = clock() - start;
					break;
			case 2:
					temp = (int *)malloc(sizeof(int)*n); 
					start = clock();	
					MergeSort(a,0,n-1,temp); 
					time[1] = clock() - start; 
					break;
			case 3:
					start = clock();	
					Partition(a,0,n-1);
					time[2] = clock() - start;
					break;
			case 4:
					start = clock();
					QuickSort(a,n);
					time[3] = clock()-start;
					break;
			case 5:
					start = clock();
					CountSort(a,n,40000);
					time[4] = clock()-start;
					break;
			case 6:
					start = clock();
					RadixCountSort(a,n);
					time[5] = clock()-start;
					break;
			case 0:
					exit(0);
		}
		system("cls");
		fp = fopen(path,"w");
		for(i=0;i<n;i++) fprintf(fp,"%d ",a[i]);
		close(fp);
		printf("- - - - - - - 排序成功 - - - - - - -\n");
		printf("|    +    排序用时: %dms    +    |\n",time[enter-1]);
		printf("- - - - - - - - - - -  - - - - - - -\n");
		printf("输入1读取新文件\n");
		printf("输入0则结束程序\n"); 
		while(1) {
			gets(inp);
			if(inp[0]=='1') break;
			if(inp[0]=='0') exit(0); 
			printf("输入错误，请再次输入：");
		}
		system("cls"); 
	}
}
<file_sep>#include"../head/SqStack.h"
#include<stdio.h>
#include<stdlib.h>
Status initStack(SqStack *s,int sizes) {
	s->top = -1;
	s->elem = (ElemType*)malloc(sizeof(ElemType)*sizes);
	return SUCCESS;
}
Status isEmptyStack(SqStack *s) {
	if(s->top==-1) {
		printf("栈为空！\n");
		return ERROR;
	}
	printf("栈不为空！\n"); 
	return SUCCESS; 
}
Status getTopStack(SqStack *s,ElemType *e) {
	if(s->top==-1) {
		printf("栈为空！\n");
		return ERROR;
	}
	else {
		*e = s->elem[s->top];
		printf("获取栈顶元素成功！\n");
		printf("栈顶元素为%d\n",*e); 
		return SUCCESS;
	}
}
Status clearStack(SqStack *s) {
	s->top = -1;
	return SUCCESS;
}
Status destroyStack(SqStack *s) {
	int i;
	for(i=s->top;i>-1;i--) {
		free(s->elem+i);
	}
	s->top=-1;
	return SUCCESS;
}
Status stackLength(SqStack *s,int *length) {
	*length =  s->top+1;
	return SUCCESS;
}
Status pushStack(SqStack *s,ElemType data) {
	if((s->top+1)==s->size) {
		printf("栈已满！\n");
	}
	s->elem[++s->top] = data;
	printf("入栈成功！\n");
	return SUCCESS; 
}
Status popStack(SqStack *s,ElemType *data) {
	if(s->top==-1) {
		printf("栈为空！\n");
		return ERROR;
	}
	*data = s->elem[s->top--];
	printf("出栈成功！\n");
	return SUCCESS;
}
Status TraverseStack(SqStack *s) {
 	int i;
 	if (s->top==-1) 
		return ERROR;
 	for(i=s->top;i>-1;i--) {
		printf("%d ",s->elem[i]);
	}
	return SUCCESS;
}
int chnum(char *str) {
	int i,n,num=0;
	for(i=0;str[i]!='\0';i++){
		if(str[i]>='0'&&str[i]<='9') {
			num=num*10+str[i]-'0';
		}
	}
	return num;
}
<file_sep>#include "../head/linkedList.h"
#include<stdio.h>
#include<stdlib.h>
void main()
{
	int num,i,n,m;
	char str[100],str1[100];ElemType e; 
	LinkedList L=NULL,q,p; 
	while(1) {
		printf("-----------单向链表的基本操作-----------\n");
		printf("|             1.创建链表               |\n"); 
		printf("|             2.销毁链表               |\n");
		printf("|             3.插入节点               |\n");
		printf("|             4.删除节点               |\n");
		printf("|             5.遍历链表               |\n");
		printf("|             6.搜寻节点               |\n");
		printf("|             7.反转链表               |\n");
		printf("|             8.判断环形               |\n");
		printf("|             9.偶数反转               |\n");
		printf("|            10.寻找中点               |\n"); 
		printf("|             0.退出程序               |\n");
		printf("----------------------------------------\n");
		printf("提醒：请输入0~9,否则自动退出程序！\n"); 
		printf("请输入要执行的操作前的选项：");
		while(1) {
			scanf("%d",&num);
			if(num>=0&&num<=10)break; 
			printf("输入错误，请再次输入："); 
		}
		switch(num)
		{
			case 1:
				InitList(&L);CreateList(&L);
				system("cls");
				printf("创建链表成功!\n");
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				if(!L) {
					printf("链表为空！\n");
				}
				else {
					DestroyList(&L); 
					printf("销毁链表成功!\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				if(!L) 
					printf("链表为空！\n"); 
				else {
					q=(LNode *)malloc(sizeof(LNode));
					printf("请输入插入节点的数据："); 
					gets(str1);
					gets(str);
					q->data=chnum(str);
					printf("请输入插入到第几个节点后面:");
					scanf("%d",&m);
					p=L->next;i=0;
					while(p) {
						i++;
						if(i==m){
							if(InsertList(p,q)) {
								printf("插入节点成功！\n");break;
							} 	
						}
						p=p->next;
					}
					if(i<m||m<0)
						printf("插入节点失败！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				system("cls");
				if(!L) 
					printf("链表为空！\n"); 
				else {
					printf("删除第几个节点后的第一个节点:");
					scanf("%d",&m);
					p=L->next;i=0;
					while(p) {
						i++;
						if(i==m){
							if(DeleteList(p,&e)) { 
								printf("删除节点成功！\n");break;
							} 
							else {
								printf("删除节点失败！\n");break;
							}	
						}
						p=p->next;
					}
					if(m<0||m>i) printf("删除节点失败！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				if(!L)
				 	printf("链表为空！\n");
				else {
					system("cls");
					printf("链表数据为:\n"); 
					TraverseList(L,visit);
				}
				printf("\n输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				system("cls"); 
				if(!L)
					printf("链表为空！\n");
				else {
					printf("请输入节点含有的数据：");
					scanf("%d",&e);
					if(SearchList(L,e)) 
						printf("存在该节点！\n"); 
					else 
						printf("不存在该节点！\n"); 
				} 
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				system("cls");
				if(!L)
					printf("链表为空！\n");
				else {
					ReverseList(&L);
					printf("链表反转成功！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				system("cls");
				if(!L)
					printf("链表为空！\n");
				else {
					if(IsLoopList(L)) {
						printf("该链表是循环链表\n");
					}
					else {
						printf("该链表不是循环链表\n");
					} 
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 9:
				system("cls");
				if(!L)
					printf("链表为空！\n");
				else {
					ReverseEvenList(&L);
					printf("偶数反转成功！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 10:
				 system("cls");
				if(!L)
					printf("链表为空！\n");
				else {
					printf("中点节点数据为：%d\n",FindMidNode(&L)->data);
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
} 
<file_sep>#include"../AQueue/AQueue.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{	
	void *e=NULL;
	char a[100],b4[100],b2;
	double b1;
	int flag=1,data=0,num,Judge,len,b3;
	AQueue *Q;
	Q=(AQueue *)malloc(sizeof(AQueue));
	Q->data[0]=NULL; 
	while(1) {
		printf("****************************************************************\n");
		printf("*                                                              *\n");
		printf("*****************数据结构之循环队列程序设计*********************\n");
		printf("*                                                              *\n");
		printf("***************作者:梁德钊(3119005103)软工三班******************\n");
		printf("*                      1.初始化队列                            *\n");
		printf("*                      2.销毁队列                              *\n");
		printf("*                      3.检查队列是否已满                      *\n"); 
		printf("*                      4.检查队列是否为空                      *\n"); 
		printf("*                      5.查看队头元素                          *\n"); 
		printf("*                      6.确定队列长度                          *\n"); 
		printf("*                      7.入队操作                              *\n");
		printf("*                      8.出队操作                              *\n");
		printf("*                      9.清空队列                              *\n");
		printf("*                     10.遍历队列                              *\n");
		printf("*                      0.退出程序                              *\n");
		printf("****************************************************************\n");  
		printf("请输入要执行的操作前的选项：");
		while(1) {
			gets(a);
			if(a[0]=='1'&&a[1]=='0') {
				num=10;
				break;
			}
			if(a[0]>='0'&&a[0]<='9') {
				num=a[0]-'0';
				break;
			} 	
			printf("输入错误，请再次输入："); 
		}
		switch(num){
			case 1:
				system("cls");
				printf("*********************\n");
				InitAQueue(Q);
				Q->data[0]=&data;
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				printf("*********************\n");
				DestoryAQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				printf("*********************\n");
				Judge=IsFullAQueue(Q);
				if(Judge==TRUE) 
				printf("队列已满/n");
				if(Judge==FALSE)
				printf("队列未满\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				system("cls");
				printf("*********************\n");
				Judge=IsEmptyAQueue(Q);
				if(Judge==TRUE) 
				printf("队列为空\n");
				if(Judge==FALSE)
				printf("队列非空\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				system("cls");
				printf("*********************\n");
				e=(void *)malloc(20);
				if(GetHeadAQueue(Q,e))
				APrint(e,datatype[Q->front]);
				printf("\n*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				system("cls");
				printf("*********************\n");
				len=LengthAQueue(Q);
				if(len!=-1)
				printf("队列长度为%d\n",len);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				system("cls");
				printf("************************\n");
				printf("请选择入队元素的数据类型\n");
				printf("************************\n");
				printf("*  1.double   2.char   *\n");
				printf("*  3.int      4.string *\n");
				printf("************************\n");
				printf("请输入选项：");
				while(1) {
					gets(a);
					if(a[0]>='1'&&a[0]<='4') break;
					printf("输入错误，请再次输入：");
				}
				num=a[0]-'0';
				switch(num){
					case 1:
						printf("请输入元素：");
						scanf("%lf",&b1);
						if(!EnAQueue(Q,&b1))
							break;
						datatype[Q->rear]='d';
						break;
					case 2:
						printf("请输入元素：");
						scanf("%c",&b2);
						if(!EnAQueue(Q,&b2))
							break;
						datatype[Q->rear]='c';
						break;
					case 3:
						printf("请输入元素：");
						scanf("%d",&b3);
						if(!EnAQueue(Q,&b3))
							break;
						datatype[Q->rear]='i';
						break;
					case 4:
						printf("请输入元素：");
						scanf("%s",b4);
						if(!EnAQueue(Q,b4))
							break;
						datatype[Q->rear]='s';
						break;
				}
				gets(a);
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				system("cls");
				printf("*********************\n");
				DeAQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 9:
				system("cls");
				printf("*********************\n");
				ClearAQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 10:
				system("cls");
				printf("*********************\n");
				TraverseAQueue(Q,APrint);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
}
<file_sep># QG训练营后台组第二周周记：
2020年4月5日

## 生活随记
这周时间太紧凑了，有点忙活不过来，心好累，写的代码BUG又多，又不知道哪里错了，所以进度好慢，匆匆忙忙完成大组作业又要补课内的作业了，这周也没时间去打球，略感遗憾。最近天气转冷了，写作业和打代码都瑟瑟发抖。


## 一周总结
掌握了栈的应用和栈的基本操作，完成四则运算计算器的实现，最近也一直在学Java。


## 存在问题
1.在编写四则运算计算器的时候，虽然能够实现四则运算和小数的计算，但是自己写的代码杂糅，还需要深入理解逆波兰表达式，再看看别人是如何编写的，来完善自己写的代码。

2.学习进度慢，无论是完成作业或者学新知识，花的时间都有点长，需要改进自己的学习习惯。

3.注意力不够集中，代码的BUG很多，需要改很久。
## 下周规划
1.完成小组作业

2.跟上后台训练营的学习进度


<file_sep>#include "..\代码和头文件\calculator.h"
#include<stdio.h>
#include<stdlib.h>
Status initStack(SqStack *s,int sizes) {
	s->top = -1;
	s->elem = (ElemType *)malloc(sizeof(ElemType)*sizes);
	return SUCCESS;
}
Status initStack1(SqStack1 *s,int sizes) {
	s->top = -1;
	s->elem1 = (float *)malloc(sizeof(float)*sizes);
	return SUCCESS;
}
Status destroyStack(SqStack *s) {
	int i;
	for(i=s->top;i>-1;i--) {
		free(s->elem+i);
	}
	s->top=-1;
	return SUCCESS;
}
Status isEmptyStack(SqStack *s) {
	if(s->top==-1) {
		return ERROR;
	} 
	return SUCCESS; 
}
Status pushStack(SqStack *s,ElemType data) {
	if((s->top+1)==s->size) {
		printf("栈已满！\n");
	}
	s->elem[++s->top] = data;
	return SUCCESS; 
}
Status popStack(SqStack *s,ElemType *data) {
	if(s->top==-1) {
		return ERROR;
	}
	*data = s->elem[s->top--];
	return SUCCESS;
}
Status pushStack1(SqStack1 *s,float data) {
	if((s->top+1)==s->size) {
		printf("栈已满！\n");
	}
	s->elem1[++s->top] = data;
	return SUCCESS; 
}
Status popStack1(SqStack1 *s,float *data) {
	if(s->top==-1) {
		return ERROR;
	}
	*data = s->elem1[s->top--];
	return SUCCESS;
}
int chnum(char a) {
	if(a=='('||a==')') 
		return 4;
	if(a=='*'||a=='/') 
		return 3;
	if(a=='+'||a=='-')
		return 2;
	if(a>='0'&&a<='9')
		return 1;
	return 0;
}

<file_sep>#ifndef TREE_H_INCLUDED
#define TREE_H_INCLUDED
typedef char TElemType;     // 假设二叉树结点的元素类型为字符
typedef struct  BiTNode {
    TElemType data;     // 数据域
    struct BiTNode  *lchild,*rchild;  // 左、右孩子指针
} BiTNode,*BiTree;   // 二叉链表

typedef  struct  LinkStack//链式栈 
{
	BiTree top;
}LinkStack;
typedef enum Status{
	ERROR,
	SUCCESS
}Status;


Status InitBiTree(BiTree *T);
//操作结果：构造空二叉树T
Status DestroyBiTree(BiTree *T);
//初始条件：二叉树T存在
//操作结果：摧毁二叉树T
Status CreateBiTree(BiTree *T, char* definition);
//初始条件： definition给出二叉树的定义
//操作结果：按definition构造二叉树T

//以下部分函数定义未指定参数类型
Status PreOrderTraverse(BiTree T, Status (*visit)(TElemType e));//先序遍历 
//初始条件：二叉树T存在，visit为对结点的操作的应用函数
//操作结果：先序遍历T，对每个结点调用visit函数一次且仅一次，一旦visit失败，则操作失败
Status InOrderTraverse(BiTree T, Status (*visit)(TElemType e));	//中序遍历
Status PostOrderTraverse(BiTree T, Status (*visit)(TElemType e));	//后序遍历
Status LevelOrderTraverse(BiTree T, Status (*visit)(TElemType e));	//层序遍历
int Value(BiTree T);			//构造出的二叉树求值
Status visit(TElemType e);      //打印元素值
char nextToken(char *definition);//跳过空格 
int isOpNum(char ch);//判断是否是操作数 
void change(char *definition);//中缀表达式转前缀表达式 
Status Traverse(BiTree T, Status (*visit)(TElemType e));//非递归遍历二叉树 
void menu();
/*
提示：可在结点结构体中设置个Tag值标志数字与操作符来构造二叉树，
可根据需要自行增加操作.
*/
#endif
<file_sep>#include"../LQueue/LQueue.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void main()
{
	void *e=NULL;
	char a[100],b4[100],b2;
	double b1;
	int data=0,num,Judge,len,b3;
	LQueue *Q;
	Q=(LQueue *)malloc(sizeof(LQueue));
	Q->front=NULL;
	while(1) {
		printf("****************************************************************\n");
		printf("*                                                              *\n");
		printf("*****************数据结构之链式队列程序设计*********************\n");
		printf("*                                                              *\n");
		printf("***************作者:梁德钊(3119005103)软工三班******************\n");
		printf("*                      1.初始化队列                            *\n");
		printf("*                      2.销毁队列                              *\n"); 
		printf("*                      3.检查队列是否为空                      *\n"); 
		printf("*                      4.查看队头元素                          *\n"); 
		printf("*                      5.确定队列长度                          *\n"); 
		printf("*                      6.入队操作                              *\n");
		printf("*                      7.出队操作                              *\n");
		printf("*                      8.清空队列                              *\n");
		printf("*                      9.遍历队列                              *\n");
		printf("*                      0.退出程序                              *\n");
		printf("****************************************************************\n");  
		printf("请输入要执行的操作前的选项：");
		while(1) {
			gets(a);
			if(a[0]>='0'&&a[0]<='9') {
				num=a[0]-'0';
				break;
			} 	
			printf("输入错误，请再次输入："); 
		}
		switch(num){
			case 1:
				system("cls");
				printf("*********************\n");
				InitLQueue(Q);
				Q->front->data=(void *)malloc(20);
				Q->front->data=&data;
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				printf("*********************\n");
				DestoryLQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				printf("*********************\n");
				Judge=IsEmptyLQueue(Q);
				if(Judge==TRUE) 
				printf("队列为空\n");
				if(Judge==FALSE)
				printf("队列非空\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				system("cls");
				printf("*********************\n");
				e=(void *)malloc(20);
				if(GetHeadLQueue(Q,e))
				printf("队头元素为：\n");
				LPrint(e,Q->front->datatype);
				free(e); 
				printf("\n*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				system("cls");
				printf("*********************\n");
				len=LengthLQueue(Q);
				if(len!=FALSE)
				printf("队列长度为%d\n",len);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				system("cls");
				printf("************************\n");
				printf("请选择入队元素的数据类型\n");
				printf("************************\n");
				printf("*  1.double   2.char   *\n");
				printf("*  3.int      4.string *\n");
				printf("************************\n");
				printf("请输入选项：");
				while(1) {
					gets(a);
					if(a[0]>='1'&&a[0]<='4') break;
					printf("输入错误，请再次输入：");
				}
				num=a[0]-'0';
				switch(num){
					case 1:
						printf("请输入元素：");
						scanf("%lf",&b1);
						if(!EnLQueue(Q,&b1))
							break;
						Q->rear->datatype='d';
						break;
					case 2:
						printf("请输入元素：");
						scanf("%c",&b2);
						if(!EnLQueue(Q,&b2))
							break;
						Q->rear->datatype='c';
						break;
					case 3:
						printf("请输入元素：");
						scanf("%d",&b3);
						if(!EnLQueue(Q,&b3))
							break;
						Q->rear->datatype='i';
						break;
					case 4:
						printf("请输入元素：");
						scanf("%s",b4);
						if(!EnLQueue(Q,b4))
							break;
						Q->rear->datatype='s';
						break;
				}
				gets(a);
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				system("cls");
				printf("*********************\n");
				DeLQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				system("cls");
				printf("*********************\n");
				ClearLQueue(Q);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 9:
				system("cls");
				printf("*********************\n");
				TraverseLQueue(Q,LPrint);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
} 
<file_sep>#include"../inc/qgsort.h"
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
void main()
{		
	char n[100];
	int a[10000],b[50000],c[200000];
	int *temp1,*temp2,*temp3;
	int i,max,num;
	clock_t start,time[6];
	while(1) {
		printf("---------------------------------------------\n");
		printf("-------------请选择测试数据个数--------------\n");
		printf("*1.10000    2.50000   3.200000    0.结束程序*\n");
		printf("---------------------------------------------\n");
		printf("---------------------------------------------\n");
		printf("请输入选项：");
		while(1) {
			gets(n);
			if(n[0]>='0'&&n[0]<='3') {
				num=n[0]-'0';
				break;
			} 	
			printf("输入错误,请再次输入："); 
		}
		system("cls");
		CreateArray(a,10000);
		CreateArray(b,50000);
		CreateArray(c,200000);
		switch(num) {
			case 1:
				max = a[0];
				temp1 = (int *)malloc(sizeof(int)*10000);
				printf("排序中，请耐心等待...............\n");
				start=clock();	insertSort(a,10000);		time[0]=clock()-start;	CreateArray(a,10000);
				start=clock();	MergeSort(a,0,9999,temp1);	time[1]=clock()-start;	CreateArray(a,10000);
				start=clock();	Partition(a,0,9999);		time[2]=clock()-start;	CreateArray(a,10000);
				start=clock();	QuickSort(a,10000);			time[3]=clock()-start;	CreateArray(a,10000);
				start=clock();	CountSort(a,10000,max);		time[4]=clock()-start;	CreateArray(a,10000);
				start=clock();	RadixCountSort(a,10000);	time[5]=clock()-start;	
				free(temp1);
				break;
			case 2:
				max = b[0];
				temp2 = (int *)malloc(sizeof(int)*50000);		
				for(i=0;i<50000;i++) {
					if(b[i]>max) max = b[i];
				}
				printf("排序中，请耐心等待...............\n");
				start=clock();	insertSort(b,50000);		time[0]=clock()-start;	CreateArray(b,50000);
				start=clock();	MergeSort(b,0,49999,temp2);	time[1]=clock()-start;	CreateArray(b,50000);
				start=clock();	Partition(b,0,49999);		time[2]=clock()-start;	CreateArray(b,50000);
				start=clock();	QuickSort(b,50000);			time[3]=clock()-start;	CreateArray(b,50000);
				start=clock();	CountSort(b,50000,max);		time[4]=clock()-start;	CreateArray(b,50000);
				start=clock();	RadixCountSort(b,50000);	time[5]=clock()-start;	
				free(temp2);
				break;
			case 3:
				max = c[0];
				temp3 = (int *)malloc(sizeof(int)*200000);
				printf("排序中，请耐心等待...............\n");
				start=clock();	insertSort(c,200000);		time[0]=clock()-start;	CreateArray(c,200000);
				start=clock();	MergeSort(c,0,199999,temp3);time[1]=clock()-start;	CreateArray(c,200000);
				start=clock();	Partition(c,0,19999);		time[2]=clock()-start;	CreateArray(c,200000);
				start=clock();	QuickSort(c,200000);		time[3]=clock()-start;	CreateArray(c,200000);
				start=clock();	CountSort(c,200000,max);	time[4]=clock()-start;	CreateArray(c,200000);
				start=clock();	RadixCountSort(c,200000);	time[5]=clock()-start;
				free(temp3);
				break;
			case 0:
				exit(0);
		}
		printf("- - - - - - - - - - - - - - - - 排序时间（单位：ms）- - - - - - - - - - - - - - - - -\n");
    	printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    	printf("|  + 插入 +  |  + 归并 +  |  + 快排 +  | + 快排(非递归) + |  + 计数 +  |  + 基数 +  |\n");
   		printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    	printf("|  +  %d  +   |  +   %d   +   |  +   %d   +  |  +  %d  +  |  +  %d  +  |  +  %d  +  |\n",time[0],time[1],time[2],time[3],time[4],time[5]);
    	printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
 		printf("输入0返回上一层：");
		while(1) {
			gets(n);
			if(n[0]=='0') break;
			printf("输入错误，请再次输入：");
		}
		system("cls");
	}
}
<file_sep>#include"../LQueue/LQueue.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void InitLQueue(LQueue *Q) {
	Node *p;
	p = (Node *)malloc(sizeof(Node));
	if (NULL == p)
		return;
	p->datatype='i';
	p->next = NULL;
	Q->front = p;
	Q->rear = p;
	printf("队列初始化成功！\n");
	return;
}


void DestoryLQueue(LQueue *Q) {
	Node *p;
	if(Q->front==NULL) {
		printf("队列未初始化！\n");
		return;
	}
	ClearLQueue(Q);
	p=Q->front;
	Q->front=Q->rear=NULL;	
	free(p);
	printf("队列销毁成功!\n");
}


Status IsEmptyLQueue(const LQueue *Q) {
	if(Q->front==NULL) {
		printf("队列未初始化！\n");
		return -1;
	}
	return Q->rear==Q->front ? TRUE:FALSE;
}


Status GetHeadLQueue(LQueue *Q, void *e) {
	int flag;
	flag=IsEmptyLQueue(Q);
	if(flag==-1) return FALSE;
	memcpy(e,Q->front->data,20); 
	printf("获取头元素成功！\n");
	return TRUE;
}


int LengthLQueue(LQueue *Q) {
	Node *p;
	int len=1;
	if(IsEmptyLQueue(Q)==-1)
		return FALSE;
	p=Q->front;
	while(p!=Q->rear) {
		p=p->next;
		len++;
	}
	return len; 
} 


Status EnLQueue(LQueue *Q, void *data) {
	Node *p;
	p=(Node *)malloc(sizeof(Node));
	if(Q->front==NULL) {
		printf("队列未初始化！\n");
		return FALSE;
	} 
	if(p==NULL)
		return FALSE;
	p->data=(void *)malloc(20);
	memcpy(p->data,data,20);
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
	return TRUE;
}

Status DeLQueue(LQueue *Q) {
	int flag; 
	Node *p;
	flag=IsEmptyLQueue(Q);
	if(flag==-1) return FALSE;
	if(flag==TRUE) {
		printf("队列为空!\n");
		return FALSE;
	}
	p=Q->front;
	Q->front=Q->front->next;
	p->next=NULL;
	free(p);
	printf("出队成功！\n"); 
	return TRUE;
}


void ClearLQueue(LQueue *Q) {
	Node *p,*q;
	if(Q->front==NULL) {
		printf("队列未初始化！\n");
		return;
	}
	Q->rear=Q->front;
	p=Q->front->next;
	while(p!=NULL) {
		q=p;
		p=p->next;
		free(q);
	} 
	Q->front->next=NULL;
	printf("队列已清空！\n");
	return;
}

Status TraverseLQueue(const LQueue *Q, void (*foo)(void *q,char type)) {
	int flag;
	Node *p; 
	flag=IsEmptyLQueue(Q);
	if(flag==-1) return FALSE;
	p=Q->front;
	while(p) {
		foo(p->data,p->datatype);
		p=p->next;
	}
	printf("\n");
	return TRUE;
}

void LPrint(void *q,char type) {
	if(type=='d')
		printf("-->%lf",*(double *)q);
	else if(type=='c')
		printf("-->%c",*(char *)q);
	else if(type=='i')
		printf("-->%d",*(int *)q);
	else if(type=='s')
		printf("-->%s",(char *)q);
}
<file_sep>#include "../head/duLinkedList.h"
#include<stdio.h>
#include<stdlib.h>
void main()
{
	int num,i,n,m;
	char str[100],str1[100];ElemType e; 
	DuLinkedList L=NULL,q,p; 
	while(1) {
		printf("-----------双向链表的基本操作-----------\n");
		printf("|             1.创建链表               |\n"); 
		printf("|             2.销毁链表               |\n");
		printf("|             3.插前节点               |\n");
		printf("|             4.插后节点               |\n");
		printf("|             5.删除节点               |\n");
		printf("|             6.遍历链表               |\n");
		printf("|             0.退出程序               |\n");
		printf("----------------------------------------\n");
		printf("提醒：请输入0~9,否则自动退出程序！\n"); 
		printf("请输入要执行的操作前的选项：");
		while(1) {
			scanf("%d",&num);
			if(num>=0&&num<=10)break; 
			printf("输入错误，请再次输入："); 
		}
		switch(num)
		{
			case 1:
				InitList_DuL(&L);CreateList_DuL(&L);
				system("cls");
				printf("创建链表成功!\n");
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				if(!L) {
					printf("链表为空！\n");
				}
				else {
					DestroyList_DuL(&L); 
					printf("销毁链表成功!\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				if(!L) 
					printf("链表为空！\n"); 
				else {
					q=(DuLNode *)malloc(sizeof(DuLNode));
					printf("请输入插入节点的数据："); 
					gets(str1);
					gets(str);
					q->data=chnum(str);
					printf("请输入插入到第几个节点的前面:");
					scanf("%d",&m);
					p=L->next;i=0;
					while(p) {
						i++;
						if(i==m){
							if(InsertBeforeList_DuL(p,q)) {
								printf("插入节点成功！\n");break; 
							} 	
						}
						p=p->next;
					}
					if(i<m||m<0) printf("插入节点失败！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				 system("cls");
				if(!L) 
					printf("链表为空！\n"); 
				else {
					q=(DuLNode *)malloc(sizeof(DuLNode));
					printf("请输入插入节点的数据："); 
					gets(str1);
					gets(str);
					q->data=chnum(str);
					printf("请输入插入到第几个节点后面:");
					scanf("%d",&m);
					p=L->next;i=0;
					while(p) {
						i++;
						if(i==m){
							if(InsertAfterList_DuL(p,q)) {
								printf("插入节点成功！\n");break;
							} 	
						}
						p=p->next;
					}
					if(i<m||m<0) printf("插入节点失败！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				system("cls");
				if(!L) 
					printf("链表为空！\n"); 
				else {
					printf("删除第几个节点后的第一个节点:");
					scanf("%d",&m);
					p=L->next;i=0;
					while(p) {
						i++;
						if(i==m){
							if(DeleteList_DuL(p,&e)) { 
								printf("删除节点成功！\n");break;
							} 
							else {
								printf("删除节点失败！\n");break;
							}	
						}
						p=p->next;
					}
					if(m<0||m>i) printf("删除节点失败！\n");
				}
				printf("输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				if(!L)
				 	printf("链表为空！\n");
				else {
					system("cls");
					printf("链表数据为:\n"); 
					TraverseList_DuL(L,visit);
				}
				printf("\n输入0返回上一层：");
				while(1) {
					scanf("%d",&n);
					if(n==0) break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
}
<file_sep>#include "../head/linkedList.h"
#include<stdio.h>
#include<stdlib.h>
/**
 *  @name        : Status InitList(LinkList *L);
 *	@description : initialize an empty linked list with only the head node without value
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status InitList(LinkedList *L) {
	*L=(LinkedList)malloc(sizeof(LNode));
	if(!(*L))
		return ERROR;
	(*L)->next=NULL;
	return SUCCESS; 
}
/**
 *  @name        : Status CreateList(LinkList *L);
 *	@description : Create a linked list with data
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status CreateList(LinkedList *L) {
	int n=0;
	char str[100],str1[100],end[3]="end";
	LNode *p1,*p2;
	p1=p2=(LNode *)malloc(sizeof(LNode));
	printf("请输入节点的数据,输入end结束\n->");
	gets(str1);
	gets(str);
	p1->data=chnum(str);
	while(strcmp(str,end)) {
		n++;
		if(n==1)(*L)->next=p1;
		else
			p2->next=p1;
		p2=p1;
		printf("->");
		p1=(LNode *)malloc(sizeof(LNode));
		gets(str);
		p1->data=chnum(str);
	}
	p2->next=NULL;
	return SUCCESS; 
}
/**
 *  @name        : void DestroyList(LinkedList *L)
 *	@description : destroy a linked list, free all the nodes
 *	@param		 : L(the head node)
 *	@return		 : None
 *  @notice      : None
 */
void DestroyList(LinkedList *L) {
	LNode *p;
	while(*L) {
		p=(*L);
		(*L)=(*L)->next;
		free(p);
	}
	*L=NULL;
}

/**
 *  @name        : Status InsertList(LNode *p, LNode *q)
 *	@description : insert node q after node p
 *	@param		 : p, q
 *	@return		 : Status
 *  @notice      : None
 */
Status InsertList(LNode *p, LNode *q) {
	if(!p)
		return ERROR;
	if(!(p->next)) {
		p->next=q;
		q->next=NULL;
	}
	else {
		q->next=p->next;
		p->next=q;
	}
	return SUCCESS;
}
/**
 *  @name        : Status DeleteList(LNode *p, ElemType *e)
 *	@description : delete the first node after the node p and assign its value to e
 *	@param		 : p, e
 *	@return		 : Status
 *  @notice      : None
 */
Status DeleteList(LNode *p, ElemType *e) {
	LNode *q;
	if(!(p->next))
		return ERROR;
	q=p->next;
	*e=q->data;
	p->next=q->next;
	free(q);
	return SUCCESS;
}

/**
 *  @name        : void TraverseList(LinkedList L, void (*visit)(ElemType e))
 *	@description : traverse the linked list and call the funtion visit
 *	@param		 : L(the head node), visit
 *	@return		 : None
 *  @notice      : None
 */
void TraverseList(LinkedList L, void (*visit)(ElemType e)) {
	LNode *p=L->next;
	while(p) {
		if(p->next==NULL)
			(*visit)(p->data);
		else {
			(*visit)(p->data);
			printf("->");
		}
		p=p->next;
	}
}

/**
 *  @name        : void visit(ElemType e)
 *	@description : achieve the funtion visit
 *	@param		 : e
 *	@return		 : None
 *  @notice      : None
 */
void visit(ElemType e) {
	printf("%d",e);
}
/**
 *  @name        : Status SearchList(LinkedList L, ElemType e)
 *	@description : find the first node in the linked list according to e
 *	@param		 : L(the head node), e
 *	@return		 : Status
 *  @notice      : None
 */
Status SearchList(LinkedList L, ElemType e) {
	LNode *p=L->next;
	if(!L)
		return ERROR;
	while(p) {
		if(p->data==e)
			return SUCCESS;
		else
			p=p->next;
	}
	return ERROR;
}

/**
 *  @name        : Status ReverseList(LinkedList *L)
 *	@description : reverse the linked list
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status ReverseList(LinkedList *L) {
	LNode *p1,*p2,*p3;
	if(!(*L))
		return ERROR;
	p1=(*L)->next;
	p2=p1->next;
	p1->next=NULL;
	p3=p2->next;
	while(p1) {
		p2->next=p1;
		p1=p2;p2=p3;
		if(p2==NULL)break;
		p3=p2->next;
	}
	(*L)->next=p1;
	return SUCCESS;
}

/**
 *  @name        : Status IsLoopList(LinkedList L)
 *	@description : judge whether the linked list is looped
 *	@param		 : L(the head node)
 *	@return		 : Status
 *  @notice      : None
 */
Status IsLoopList(LinkedList L) {
	LNode *slow,*fast;
	slow=fast=L;
	while(fast&&fast->next) {
		slow=slow->next;
		fast=fast->next->next;
		if(slow==fast)
			return SUCCESS;
	}
	return ERROR;
}

/**
 *  @name        : LNode* ReverseEvenList(LinkedList *L)
 *	@description : reverse the nodes which value is an even number in the linked list, input: 1 -> 2 -> 3 -> 4  output: 2 -> 1 -> 4 -> 3
 *	@param		 : L(the head node)
 *	@return		 : LNode(the new head node)
 *  @notice      : choose to finish
 */
LNode* ReverseEvenList(LinkedList *L) {
	LNode *p1,*p2,*p3;
	p1=(*L)->next;
	(*L)->next=p1->next;		
	while(p1&&p1->next) {
		p2=p1->next;
		p3=p2->next;
		if(p2->next&&p2->next->next) {
			p1->next=p3->next;
		}
		else {
			p1->next=p2->next;
		}
		p2->next=p1;
		p1=p3;
	}
	return *L;
}

/**
 *  @name        : LNode* FindMidNode(LinkedList *L)
 *	@description : find the middle node in the linked list
 *	@param		 : L(the head node)
 *	@return		 : LNode
 *  @notice      : choose to finish
 */
LNode* FindMidNode(LinkedList *L) {
	LNode *Mid,*p;
	Mid=p=*L;
	while(p->next&&p->next->next) {
		Mid=Mid->next;
		p=p->next->next;
	}
	return Mid;	
}
/**
 *  @name        : long int chnum(char *str)
 *	@description : String to integer
 *	@param		 : str
 *	@return		 : num
 *  @notice      : None
 */
int chnum(char *str) {
	int i,n,num=0;
	for(i=0;str[i]!='\0';i++){
		if(str[i]>='0'&&str[i]<='9') {
			num=num*10+str[i]-'0';
		}
	}
	return num;
}
<file_sep>#include "../head/LinkStack.h"
#include<stdio.h>
#include<stdlib.h>
void main()
{
	LinkStack *s;
	ElemType data,e;
	char a[100],b[100];int num,length;
	s=(LinkStack *)malloc(sizeof(LinkStack));
	initLStack(s);
	while(1) {
		printf("****************************************************************\n");
		printf("*                                                              *\n");
		printf("********************数据结构之链栈程序设计**********************\n");
		printf("*                                                              *\n");
		printf("***************作者:梁德钊(3119005103)软工三班******************\n");
		printf("*                      1.判断栈链是否为空                      *\n");
		printf("*                      2.得到栈顶元素                          *\n");
		printf("*                      3.清空栈                                *\n"); 
		printf("*                      4.销毁栈                                *\n"); 
		printf("*                      5.检测栈长度                            *\n"); 
		printf("*                      6.入栈                                  *\n"); 
		printf("*                      7.出栈                                  *\n");
		printf("*                      8.遍历栈                                *\n");
		printf("*                      0.退出程序                              *\n");
		printf("****************************************************************\n");  
		printf("请输入要执行的操作前的选项：");
		while(1) {
			gets(a);
			num=a[0]-'0';
			if(a[0]>='0'&&a[0]<='8')break; 
			printf("输入错误，请再次输入："); 
		}
		switch(num){
			case 1:
				system("cls");
				printf("*********************\n");
				isEmptyLStack(s);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 2:
				system("cls");
				printf("*********************\n");
				getTopLStack(s,&e);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 3:
				system("cls");
				clearLStack(s);
				printf("*********************\n");
				printf("清空成功！\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 4:
				system("cls");
				destroyLStack(s);
				printf("*********************\n");
				printf("销毁成功！\n");
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 5:
				system("cls");
				LStackLength(s,&length);
				printf("*********************\n");
				printf("栈长度为:%d\n",length);
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 6:
				system("cls");
				printf("*********************\n");
				printf("请输入入栈结点的数据：");
				gets(a);
				pushLStack(s,chnum(a)); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 7:
				system("cls");
				printf("*********************\n");
				popLStack(s,&data); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 8:
				system("cls");
				printf("*********************\n");
				printf("栈数据为："); 
				TraverseStack(s);
				printf("\n"); 
				printf("*********************\n");
				printf("输入0返回上一层：");
				while(1) {
					gets(a);
					if(a[0]=='0') break;
					printf("输入错误，请再次输入：");
				}
				system("cls");
				break;
			case 0:
				exit(0);break;
		}
	}
}
