itsbrqs

typedef struct{
	ElemType *elem;//首地址
     int length;//当前长度
     int listsize;//当前所占存储容量
}

/*算法思路
*1.空间分配
*2.判断分配是否成功
*3.初始化其他参数
*/
status Initlist_sq(Sqlist &L){
    //分配空间
    L.elem=(ElemType)* malloc(L * sizeof(ElemType));
   //判断分配是否成功 
    if(!L.elem) retrun -2;
   //初始化其他参数
    L.length=0;
    L.listszie=0;
    return 0;
}

/*算法思路
*1.检查i值合法性
*2.检查是否空间溢出及溢出空间再分配
*3.检查再分配是否成功
*4.取插入位置元素，整体向后移位
*5.表长加1
*/
status ListInsert_sq(Sqlist* L,int i,int e){
    int* newbase,q,p;
    //检查 i 值是否合法，是否会越界
    if(i<1||i>(L->length+1))
    	return ERROR;
	//长度超限时分配内存新空间用于存储
	if(L->length>=L->listsize){
		newbase=(int*)realloc(L->elem,(L->listsize+LISTINCREMENT)*
		sizeof(int));
     //检查存储是否分配失败
     if(!newbase)
		return (OVERFLOW);
	L->elem=newbase;
	L->listsize+=LISTINCREMENT;
	}
     q=&(L->elem[i-1]);//q 为插入位置
    if(L->length>0){
		for(p=&(L->elem[(L->length)-1]); p>=q; --p){
		*(p+1)=*p;
        }
    }
	*q=e;
	++(L->length);
	return OK;
};     

q=&(L->elem[i-1]);//q 为插入位置元素
    if(L->length>0){//检查是否为空
		for(p=&(L->elem[(L->length)-1]); p>=q; --p){
		*(p+1)=*p;//元素整体后移
        }
    }
*q=e;//插入元素

/*算法思路
*1.检查i值合法性
*2.取被删除元素位置
*3.被删除元素赋值给e
*4.取被删除元素的元素，整体向前移位
*5.表长减1
*/
//核心代码： 删除移位
q=&(L->elem[i-1]);//取被删除元素位置
*e=*p;//被删除元素赋值给e
q=L->elem+L->length-1;//表尾
for(++p;p<=q;++p)
	*(p-1)=*p;//向前移位

typedef struct LNode{
	Elemtype data;//数据域
	struct LNode *next;//指针域
}

Status InitList_L(LNode *L){
    L->next=NULL;//头结点next域置空非常重要
    return OK;
};

/*算法思路
*1.取插值前结点
*2.检查i值
*3.生成插值结点
*4.断开老结点插入插值结点
*/
Status ListInsert_L(LNode *L,int i,Elemtype e){
    int j=0;
    LNode *p;
    p=L;
    while(p&&j<i-1){
    p=p->next;
    j++;
    }
    if(!p||j>i-1){
    return ERROR;//i值检验，负值或大于表长加1值
    }
    
    LNode *s;
    s=(LinkLIst) malloc(sizeof(LNode));//空间分配！！！生成插值结点
    s->data=e;
    //开始插值
    s->next=p->next;//中部插值时必须
    p->next=s;
    return OK;
};

/*算法思路
*1.取删除值前结点
*2.检查i值
*3.生成删除结点
*4.断开老结点链接删除值后结点
*5.返回删除值，释放删除结点
*/
Status ListDelete_L(LNode *L,int i,Elemtype *e){
    int j=0;
    LNode *p;
    p=L;
    
    while(p&&j<i-1){
        p=p->next;
        j++;
    }
    if(!(p->next)||j>i-1){
        return ERROR;//i值检验，负值或大于表长加1值
    }
    
    LNode *q;
    q=(LinkLIst) malloc(sizeof(LNode));//空间分配！！！
    
    q=p->next;//获得被删除结点
    p->next=q->next;//越过被删除结点实现删除
    
    *e=q->data;
    free(q);
    return OK;
};

typedef struct stack{ 
    int stacksize; //栈的容量 
    struct stack *head; //栈顶指针 
    struct stack *base; //栈底指针
}

//插值 Push
Status Push(SqStack *S,SElemType e){
    if(S->top-S->base>S->stacksize){
        S->base=(SElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));//栈满追加分配空间
        if(!S->base)return -2;//分配失败
        S->top=S->base+S->stacksize;//栈顶指针移动
        S->stacksize+=STACKINCREMENT;
    }
    *(S->top)++=e;//插值之后栈顶指针上移，这里实际为两步操作
}
//删除 Pop
Status Pop(SqStack *S,SElemType *e){
    if(S->base==S->top){
        printf("error: SqStack NULL");
        return 0;//栈空
    }
    *e=*(S->top-1);
    S->top--;
    return 1;
}

typedef struct QNode{
    QElemType data;
    struct QNode *next;   
}QNode,*QueuePtr;

typedef struct 
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
    int len;
}LinkQueue;

//插值EnQueue 删除DEQueue
Status EnQueue(LinkQueue *Q,QElemType e){
    QNode *p=(QueuePtr)malloc (sizeof(QNode));
    p->data=e;
    p->next=NULL;
    if(Q->front==NULL){
        Q->front=Q->rear=p;
    }else{
        Q->rear->next=p;
        Q->rear=p;
    }
    Q->len++;
    return 1;
    }
Status DeQueue(LinkQueue *Q,QElemType *e){
    int isEmpty=QueueEmpty(Q);
    if(!isEmpty){
    QNode *p=Q->front;
    Q->front=p->next;
    printf("info: Queue delete head elem %d success\n",p->data);
    free(p);
    return 1;
    }{
    printf("error:Queue Empty \n");
    return 0;
    }
    Q->len--;
}

typedef struct
{
    int i,j;
    ElemType e;
}Triple
#三元组顺序表的C语言描述,稀疏矩阵
#define MAXSIZE 125000
typedef struct
{
Triple data[MAXSIZE+1;//矩阵包含的三元组表，data[0]未用
int mu,nu,t）;//mu行数nu列数tu非0元素数
}TSMatrix

/*------二叉树的二叉链表存储结构------*/
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode* left;
    struct BiTNode* right;
}BTNode,*BiTree;

struct Tree
{
    char  data;        //需要存储的数据 
    int num;
    int LisThread;//左右的标志,值为0或1
    int RisThread; 
    struct Tree *lchild,*rchild;    //左右孩子的指针
};

#图结构邻接矩阵存储结构代码实现
#define MAXVEX 20					//顶点最大数
#define INFINITY 65535 				//代指无限大 
typedef struct
{
	datatype data[MAXVEX];			//顶点表 
	edgetype arc[MAXVEX][MAXVEX];	//存储边的权的邻接矩阵 
	int numVertexes,numEdges;		//顶点数,边或弧的个数 
}MGraph;//图结构邻接矩阵
int visited[MAXVEX]; //访问数组

#define MAX_VERTEX_NUM 20 /* 最多顶点个数 */
typedef enum{DG, DN, UDG, UDN} GraphKind; /* 图的种类 */
 
/* 定义表头结点的类型 */
typedef struct VertexNode {
    VertexData data;    //数据域，存放顶点信息
    ArcNode * firstarc; //指针域，指向边表中第一个结点
} VertexNode;
 
/* 定义边结点的类型 */
typedef struct ArcNode {
    AdjType adjvex;           //邻接点域，边的终点在顶点表中的下标
    OtherInfo info;           //数据域，存放其它相关信息
    struct ArcNode * nextarc; //指针域，指向边表中的下一个结点
} ArcNode;

#include <stdio.h>
#include <malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OVERFLOW -2  
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
/*
动态线性表存储结构
*/
typedef struct{
	int* elem;
	int length;
	int listsize;
}Sqlist;
/*
初始化函数
*/
int InitList_Sq(Sqlist *L){
	L->elem=(int*) malloc(LIST_INIT_SIZE*sizeof(int));
	if (!(*L).elem)
		return (OVERFLOW);
	L->length=0;
	L->listsize=LIST_INIT_SIZE;
	printf("L.length=%d\tL.listsize=%d\n",L->length,L->listsize);
	return OK;
};
/*
删除函数
*/
int ListDElete_Sq(Sqlist *L,int i,int* e){
	int* p;
	int* q;
	//检查i值是否合法，是否会越界
	if(i<1||i>(L->length+1))
		return ERROR;
	p=&(L->elem[i-1]);
	*e=*p;//崩溃点
	q=L->elem+L->length-1;
	for(++p;p<=q;++p)
		*(p-1)=*p;
	--L->length;
	return OK;
};
/*
插值函数
i 插入到线性表的位置
e 插入的数值
*/
int ListInsert_Sq(Sqlist *L,int i,int e){
	int* newbase;
	int* q;
	int* p;
	//检查i值是否合法，是否会越界
	if(i<1||i>(L->length+1))
		return ERROR;
	//长度超限时分配内存新空间用于存储
	if(L->length>=L->listsize){
		newbase=(int*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(int));
	//检查存储是否分配失败
	if(!newbase)
		return  (OVERFLOW);
	L->elem=newbase;
	L->listsize+=LISTINCREMENT;
	}
	q=&(L->elem[i-1]);//q为插入位置
	if(L->length>0){

	for(p=&(L->elem[(L->length)-1]);  p>=q; --p){
		*(p+1)=*p;
	}
    }
	*q=e;
	++(L->length);
	return OK;
};
/*
打印函数
*/
int PrintList(Sqlist *L){
	int i;
	printf("\nprint start \n");
	for(i=0;i<L->length;i++)
		printf("a%d=%d\n",i+1,L->elem[i]);
	printf("print finish \n");
	return OK;
};
/*
索引函数
*/
int GetElem(Sqlist *L,int i,int* e){
	if(i<1||i>(L->length)){
		printf("index out of bounds\n");
		return ERROR;
	}
	*e=L->elem[i-1];
	return OK;
};
/*
元素存在判
*/
int LocateElem(Sqlist *L,int e){
	int i;
	for(i=0;i<(L->length);i++){
		if(e==(L->elem[i])){
			return i+1;//返回位置
		}
	}
	return FALSE;
};
/*
前索引
*/
int PriorElem(Sqlist *L,int cur_e,int *pre_e){
	//判断cur_e存在及其位序
	int i;
	i=LocateElem(L,cur_e);
	if(!i||i==1){
		printf("error:cur_e null or index=1\n ");
		return ERROR;
	}
	//返回前驱
	*pre_e=L->elem[i-2];
	return OK;
}/*
后索引
*/
int NextElem(Sqlist *L,int cur_e,int *next_e){
	//判断cur_e存在及其位序
	int i;
	int l;
	i=LocateElem(L,cur_e);
	if(!i||i==L->length){
		printf("error:cur_e null or index=len\n ");
		return ERROR;
	}
	//返回后继
	*next_e=L->elem[i];
	return OK;
}
int ListLenght(Sqlist *L){
	return L->length;
}

int main(){
	Sqlist LA;
	int i;
	int e;
	InitList_Sq(&LA);//初始化
	//printf("初始化测试:LA.lenght=%d,LA.listsize=%d,LA.elem=%d\n",LA.length,LA.listsize,LA.elem);//初始化测试
	/*
	插值测试
	*/
	for(i=0;i<11;i++){
		ListInsert_Sq(&LA,i,i+1);
	}
	PrintList(&LA);//打印测试
	/*
	删除测试
	
	printf("开始删除，此时表长为%d",LA.length);
	for(i=0;i<10;i++){
	ListDElete_Sq(&LA,1,&e);//删除
	}
	PrintList(&LA);//打印测试
	printf("结束删除，此时表长为%d\n",LA.length);
	*/
	/*
	测试索引
	
	int j; 
	for(i=0;i<12;i++){
		j=GetElem(&LA,i,&e);
		printf("\tj=%d\n",e);
	}
	*/
	/*
	测试locate
	
	printf("%d",LocateElem(&LA,100));

	*/ 
	/*
	测试前驱
	PrintList(&LA);
	printf("执行是否成功：%d,前驱为%d\n",PriorElem(&LA,4,&e),e);
	printf("前驱为%d",e);
	*/
	/*
	测试后继
	*/
	PrintList(&LA);
	printf("执行是否成功：%d,",NextElem(&LA,0,&e));
	printf("后继为%d",e);
	
}

#include <stdio.h>
#include <malloc.h>
#define OVERFLOW -2  
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
/*
typedef
*/
typedef int Elemtype;
typedef int Status;
typedef struct LNode
{
    Elemtype data;
    struct  LNode *next;
}LNode,*LinkLIst;
/*
链表初始化
*/
Status InitList_L(LNode *L){
    L->next=NULL;//头结点next域置空非常重要
    return OK;
};
/*
链表插值
*/
Status ListInsert_L(LNode *L,int i,Elemtype e){
    int j=0;
    LNode *p;
    p=L;
    while(p&&j<i-1){
        p=p->next;
        j++;
    }
    if(!p||j>i-1){
        return ERROR;//i值检验，负值或大于表长加1值
    }
    //开始插值
    LNode *s;
    s=(LinkLIst) malloc(sizeof(LNode));//空间分配！！！
    s->data=e;
    s->next=p->next;//中部插值时必须
    p->next=s;
    return OK;
};
/*
链表删除
*/
Status ListDelete_L(LNode *L,int i,Elemtype *e){
    int j=0;
    LNode *p;
    p=L;
    while(p&&j<i-1){
        p=p->next;
        j++;
    }
    if(!(p->next)||j>i-1){
        return ERROR;//i值检验，负值或大于表长加1值
    }
    LNode *q;
    q=(LinkLIst) malloc(sizeof(LNode));//空间分配！！！
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
};
/*
链表打印
*/
Status PrintList_L(LNode *L){
    
    LNode *p;
    int j=0;
    p=L->next;
    printf("开始打印链表:\n");
    if(p==NULL){
        printf("空表\n");
        return OK;
    }
	while (p!=NULL)
	{    
		printf("a[%d]=%d\n",j,p->data);
		p = p->next;
		j++;
	}
	return OK;
};
/*
链表查找
*/
Status LocateElem_L(LNode *L,Elemtype e){
    LNode *p;
    int i=1;
    p=L->next;
    while(p){
        if(p->data==e){
            printf("链表元素%d所在位序为%d\n",e,i);
            return i;
        }
        i++;
        p=p->next;
    }
    if(p==NULL){
        printf("链表为空或元素不存在\n");
        return ERROR;
    }
};
/*
链表求后继
*/
Status NextElem_L(LNode *L,Elemtype e){
    LNode *p;
    p=L->next;
    while(p){
        if(p->data==e){
            if(p->next==NULL){
                printf("后继不存在\n");
                return ERROR;
            }
            printf("链表元素%d后继为%d\n",e,p->next->data);
            return p->next->data;
        }
        p=p->next;
    }
    if(p==NULL){
        printf("链表为空\n");
        return ERROR;
    }
}
/*
链表求前驱
*/
Status PriorElem_L(LNode *L,Elemtype e){
    LNode *p;
    LNode *q;
    int i=1;
    int j=1;
    p=L->next;
    while(p){
        if(p->data==e){
            break;
        }
        i++;
        p=p->next;
    }
    if(i==1){
        printf("空表或前驱不存在\n");
        return ERROR;
    }
    q=L->next;
    while(q){
        if(j==i-1){
            printf("链表元素%d前驱为%d\n",e,q->data);
            return q->data;
        }
        j++;
        q=q->next;
    }
};
/*
链表合并
*/
Status MergeList_L(LNode *LA,LNode *LB,LNode *LC){
    LNode *p;
    LNode *q;
    LNode *r;
    p=LA->next;
    q=LB->next;
    r=LC;
    while(p||q){
        //空表尾插
        if(p==NULL){
            r->next=q;
            return OK;
        }
        if(q==NULL){
            r->next=p;
            return OK;
        }
        //非空插值
        if(p->data>=q->data){
            r->next=q;
            q=q->next;
            r=r->next;
        }else{
            r->next=p;
            p=p->next;
            r=r->next;
        }
    }
};
Status main(){
    LNode LA;
    LNode LB;
    LNode LC;
    int i;
    Elemtype e;
    InitList_L(&LA);//初始化
    InitList_L(&LB);
    InitList_L(&LC);
    for(i=1;i<5;i++){
        ListInsert_L(&LA,i,i);
    }
    for(i=1;i<5;i++){
        ListInsert_L(&LB,i,2*i);
    }
    MergeList_L(&LA,&LB,&LC); 
    PrintList_L(&LC);
    printf("stop");
	return 1;
}

#include <stdio.h>
#include <malloc.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int SElemType; 
typedef int Status;
typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
/*
init
*/
Status InitStack(SqStack *S){
//构造空栈
S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S->base) return 0;
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
return 1;
}
//插值 Push
Status Push(SqStack *S,SElemType e){
    if(S->top-S->base>S->stacksize){
        S->base=(SElemType *)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));//栈满追加分配空间
        if(!S->base)return -2;//分配失败
        S->top=S->base+S->stacksize;//栈顶指针移动
        S->stacksize+=STACKINCREMENT;
    }
    *(S->top)++=e;//插值之后栈顶指针上移，这里实际为两步操作
}
//删除 Pop
Status Pop(SqStack *S,SElemType *e){
    if(S->base==S->top){
        printf("error: SqStack NULL");
        return 0;//栈空
    }
    *e=*(S->top-1);
    S->top--;
    return 1;
}
//取栈顶 GetTop
Status GetTop(SqStack *S,SElemType *e){
    if(S->base==S->top){
        printf("error: SqStack NULL");
        return 0;//栈空
    }
    *e=*(S->top-1);//不改变S->top栈顶指针
    return 1;
}
//求栈长 StackLength
Status StackLength(SqStack *S){
    printf("info: SqStack Length=%d\n",(S->top)-(S->base));
    return (S->top)-(S->base);
}
//判空 StackEmpty
Status StackEmpty(SqStack *S){
    if(S->base==S->top){
    printf("info: SqStack Empty True\n");
    return 1;
    }else{
    printf("info: SqStack Empty False\n");
    return 0;
    }

}
//置空 ClearStack
Status ClearStack(SqStack *S){
    S->top=S->base;
    return 1;
}
//销毁 Destory
Status DestoryStack(SqStack *S){
    free(S->base);
    S->base=NULL;
    S->top=NULL;
    S->stacksize=0;
    return 1;
}
//10到8进制转换
int DecOctConv(int input){
    int s,i,e;
    SqStack SA;
    InitStack(&SA);
    for(i=input;i!=0;i=i/8){
        Push(&SA,i%8);
    }
    i=StackLength(&SA);
    printf("info:开始转换，转换前十进制值为%d，转换后的八进制为",input);
    for(s=0;s<i;s++){
        GetTop(&SA,&e);
        printf("%d",e);
        Pop(&SA,&e);
    }
    printf("(8)\n");
}
//10到16进制转换
int DecHexConv(int input){
    int s,i,e;
    SqStack SA;
    InitStack(&SA);
    for(i=input;i!=0;i=i/16){
        Push(&SA,i%16);
    }
    i=StackLength(&SA);
    printf("info:开始转换，转换前十进制值为%d，转换后的十六进制为",input);
    for(s=0;s<i;s++){
        GetTop(&SA,&e);
        switch (e)
        {
            case 10:{
                printf("A");
                break;
            }
            case 11:{
                printf("B");
                break;
            }
            case 12:{
                printf("C");
                break;
            }
            case 13:{
                printf("D");
                break;
            }
            case 14:{
                printf("E");
                break;
            }
            case 15:{
                printf("F");
                break;
            }
            default:{
                printf("%d",e);
                break;
            }       
        }
        Pop(&SA,&e);
    }
    printf("(16)\n");
}
//栈打印 print
void print(SqStack *S){
    int i=0;
    printf("info: stack print elem start\n  ");
    while((S->base+i)!=(S->top)){
        printf("%-4d",*(S->base));
        i++;
    }
    printf("\ninfo: stack print elem end\n  ");

}
void menu(){
    printf("栈操作菜单:输入数字进行操作\n");
    printf("[1]:init 初始化\n");
    printf("[2]:push 栈顶插值\n");
    printf("[3]:pop 栈顶删除\n");
    printf("[4]:gettop 获取栈顶元素\n");
    printf("[5]:stacklength 求栈长度\n");
    printf("[6]:stackempty 判空\n");
    printf("[7]:stackclear 置空\n");
    printf("[8]:destroystack 销毁\n");
    printf("[9]:DecOctConv 10到8进制转换\n");
    printf("[10]:DecHexConv 10到16进制转换\n");
    printf("[11]:print 打印栈元素\n");
    printf("[0]:退出\n");
}
int main(){
    SqStack SA;
    int i=0,c;
    menu();
    while(1){
        scanf("%d",&c);
        if(c==0){
            break;
        }
        switch(c){
            case 1:{
                InitStack(&SA);
                printf("info: init success\n");
                break;
            }
            case 2:{
                printf("input e:\n");
                scanf("%d",&i);
                Push(&SA,i);
                printf("info: pop success\n");
                break;
            }
            case 3:{
                Pop(&SA,&i);
                printf("info: delete top %d success\n ",i);
                break;
            }
            case 4:{
                GetTop(&SA,&i);
                printf("info: top= %d \n ",i);
                break;
            }
            case 5:{
                StackLength(&SA);
                break;
            }
            case 6:{
                StackEmpty(&SA);
                break;
            }
            case 7:{
                ClearStack(&SA);
                printf("info: clear success\n");
                break;
            }
            case 8:{
                DestoryStack(&SA);
                printf("info: destory success\n");
                break;
            }
            case 9:{
                int input;
                printf("info: input data\n");
                scanf("%d",&input);
                DecOctConv(input);
                break;
            }
            case 10:{
                int input;
                printf("info: input data\n");
                scanf("%d",&input);
                DecHexConv(input);
                break;
            }
            case 11:{
                print(&SA);
                break;
            }
            default:{
                printf("error: options Null,reselect\n");
                break; 
            }
        }
        printf("\n\n");
        menu();
    }
    return 1;
}

#include <stdio.h>
#include <malloc.h>
typedef int QElemType; 
typedef int Status;
typedef struct QNode{
    QElemType data;
    struct QNode *next;
    
}QNode,*QueuePtr;
typedef struct 
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
    int len;
}LinkQueue;
Status InitQueue(LinkQueue *Q){
    Q->rear=Q->front=NULL;
    Q->len=0;
    return 1;
}
Status EnQueue(LinkQueue *Q,QElemType e){
    QNode *p=(QueuePtr)malloc (sizeof(QNode));
    p->data=e;
    p->next=NULL;
    if(Q->front==NULL){
        Q->front=Q->rear=p;
    }else{
        Q->rear->next=p;
        Q->rear=p;
    }
    Q->len++;
    return 1;
}
Status PrintQueue(LinkQueue *Q){
    QNode *p=Q->front;
    while(p!=Q->rear->next){
        printf("%d\n",p->data);
        p=p->next;
    }
    return 1;
}
Status QueueEmpty(LinkQueue *Q){
    if(Q->front==Q->rear){
        printf("info: Queue empty true\n");
        return 1;
    }else{
        printf("info: Queue empty false\n");
        return 0;
    }
}
Status DeQueue(LinkQueue *Q,QElemType *e){
    int isEmpty=QueueEmpty(Q);
    if(!isEmpty){
    QNode *p=Q->front;
    Q->front=p->next;
    printf("info: Queue delete head elem %d success\n",p->data);
    free(p);
    return 1;
    }{
    printf("error:Queue Empty \n");
    return 0;
    }
    Q->len--;
}
Status DestoryQueue(LinkQueue *Q){
    while(Q->front){
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    Q->len=0;
    return 1;
}
Status ClearQueue(LinkQueue *Q){
    InitQueue(Q);
    return 1;
}
Status QueueLength(LinkQueue *Q){
    printf("info:Queue Length = %d\n",Q->len);
    return Q->len;
}
Status QueueHead(LinkQueue *Q,QElemType *e){
    int isEmpty=QueueEmpty(Q);
    if(!isEmpty){
        QNode *p=(QueuePtr)malloc (sizeof(QNode));
        p=Q->front;
        *e=p->data;
        printf("info:Queue Head = %d\n",*e);
        return 1;
    }else{
        printf("error:Queue Empty \n");
        return 0;
    }
}
Status QueueLast(LinkQueue *Q,QElemType *e){
    int isEmpty=QueueEmpty(Q);
    if(!isEmpty){
        QNode *p=(QueuePtr)malloc (sizeof(QNode));
        p=Q->rear;
        *e=p->data;
        printf("info:Queue Last = %d\n",*e);
        return 1;
    }else{
        printf("error:Queue Empty \n");
        return 0;
    }
}
int main(){
    LinkQueue QA;
    int e;
    QueueEmpty(&QA);
    InitQueue(&QA);
    EnQueue(&QA,1);
    EnQueue(&QA,2);
    EnQueue(&QA,3);
    QueueLength(&QA);
    PrintQueue(&QA);
    DeQueue(&QA,&e);
    QueueLength(&QA);
    QueueHead(&QA,&e);
    QueueLast(&QA,&e);
    DestoryQueue(&QA);
    QueueEmpty(&QA);
    QueueLength(&QA);
    printf("stop");
}

#include <stdio.h>
#include <malloc.h>
#define MAXQSIZE 100//最大队列长度
#define QISTINCREMENT 10//动态增量
typedef int QElemType; 
typedef int Status;
typedef struct {
    QElemType *base;//初始化动态分配空间
    int front;//队头下标
    int rear;//队尾下标
}SqQueue;
/*
init 初始化
*/
Status InitQueue(SqQueue *Q){
    Q->base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q->base) {
        printf("error: malloc false \n");
        return -2;
    }
    Q->front=Q->rear=0;
    return 1;
}
/*
QueueLength 队列长度
*/
Status QueueLength(SqQueue *Q){
    printf("info:Queue Length = %d\n",Q->rear-Q->front);
    return Q->rear-Q->front;
}
/*
enqueue 入队
*/
Status EnQueue(SqQueue *Q,QElemType e){
   int l=QueueLength(Q);
   if(l>=MAXQSIZE){
    QElemType *newbase;
    printf("warning: Exceed the maximum length, reallocate space\n");
    newbase=(QElemType*)realloc(Q->base,(MAXQSIZE+QISTINCREMENT)*sizeof(QElemType));
    Q->base=newbase;
   }
   Q->base[l]=e;
   Q->rear++;
   printf("info:enque elem %d success \n",e);
   return 1; 
}
/*
DeQueue 删除
*/
Status DeQueue(SqQueue *Q,QElemType *e){
    int l=QueueLength(Q);
    if(l){
        *e=Q->base[l];
        Q->base[l]=NULL;
    }else{
        printf("error:Queue delete fail ,Queue NULL\n");
        return 0;
    }
    printf("info:Queue elem %d sucess\n",*e);
    Q->rear--;
    return 1;
}
/*
PrintQueue 遍历打印
*/
Status PrintQueue(SqQueue *Q){
    int l=QueueLength(Q);
    int i;
    if(l){
        printf("info: print queue start:\n");
        for(i=0;i<l;i++){
            printf("Q[%d]=%d\n",i,Q->base[i]);
        }
        printf("info:print queue end\n");
        return 1;
    }else{
        printf("error:queue null\n");
        return 0;
    }
}
/*
QueueHead 取队头
*/
Status QueueHead(SqQueue *Q){
    int l=QueueLength(Q);
    if(l){
        printf("info:queue head elem = %d\n",Q->base[Q->front]);
        return 1;
    }else{
        printf("error:queue null\n");
        return 0;
    }
}
/*
QueueLast 取队尾
*/
Status QueueLast(SqQueue *Q){
    int l=QueueLength(Q);
    if(l){
        printf("info:queue last elem = %d\n",Q->base[Q->rear]);
        return 1;
    }else{
        printf("error:queue null\n");
        return 0;
    }
}
/*
QueueEmpty 判空
*/
Status QueueEmpty(SqQueue *Q){
    int l=QueueLength(Q);
    if(l){
        printf("info:queue empty true\n");
        return 1;
    }else{
        printf("nfo:queue empty false \n");
        return 0;
    }
}
/*
Queueclear 置空
*/
Status QueueClear(SqQueue *Q){
    Q->front=Q->rear=0;
    printf("info:queue clear success \n");
    return 1;
}
/*
QueueDestory 摧毁
*/
Status QueueDestory(SqQueue *Q){
    free(Q->base);
    Q->front=Q->rear=0;
    printf("info:queue Destory success \n");
    return 1;
}
int main(){
    SqQueue QA;
    InitQueue(&QA);
    int i=0;
    int e;
    for(i=0;i<20;i++){
        EnQueue(&QA,i);
    }
    for(i=0;i<20;i=i+5){
        DeQueue(&QA,&e);
    }
    PrintQueue(&QA);
    QueueLength(&QA);
    QueueDestory(&QA);
    QueueLength(&QA);

}

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef char TElemType;
typedef int Status;
/*------二叉树的二叉链表存储结构------*/
typedef struct BiTNode
{
    TElemType data;
    struct BiTNode* left;
    struct BiTNode* right;
}BTNode,*BiTree;
typedef BTNode *QDataType;
 /*函数声明*/
BTNode* InitBTNode(TElemType x);//二叉树初始化
BTNode* BTNodeCreate(TElemType* a, int n, int* pi) ;// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
void BTNodeDestroy(BTNode** root);// 二叉树销毁
int BTNodeSize(BTNode* root);// 二叉树节点个数
int BTNodeLeafSize(BTNode* root);// 二叉树叶子节点个数
int BTNodeLevelKSize(BTNode* root, int k);// 二叉树第k层节点个数
BTNode* BTNodeFind(BTNode* root, TElemType x);// 二叉树查找值为x的节点
void BTNodePrevOrder(BTNode* root);// 二叉树前序遍历
void BTNodeInOrder(BTNode* root);// 二叉树中序遍历
void BTNodePostOrder(BTNode* root);// 二叉树后序遍历
void BTNodeLevelOrder(BTNode* root);// 层序遍历
int BTNodeComplete(BTNode* root);// 判断二叉树是否是完全二叉树
int BTNodeHeight(BTNode* root);//求二叉树的高度
BTNode * getParents(BTNode* root,BTNode* i);//求双亲
BTNode * getlc(BTNode* root,BTNode* i);//求左孩子
BTNode * getrc(BTNode* root,BTNode* i);//求右孩子
BTNode * getlb(BTNode* root,BTNode* i);//求左兄弟
BTNode * getrb(BTNode* root,BTNode* i);//求右兄弟
/*------队列的顺序存储结构------*/
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;
typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;
/*函数声明*/
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
BTNode* InitBTNode(TElemType x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);
    node->data = x;
    node->left = NULL;
    node->right = NULL;
    return node;
}
BTNode* BTNodeCreate(TElemType* a, int n, int* pi)
{
    if(a[*pi] == '#' || *pi >= n)
    {
        printf("NULL ");
        (*pi)++;
        return NULL;
    }
    BTNode *dst= InitBTNode(a[*pi]);
    printf("%c ",dst->data);
    (*pi)++;
    dst->left = BTNodeCreate(a,n,pi);
    dst->right = BTNodeCreate(a,n,pi);
    return dst;
}
//先序遍历
void BTNodePrevOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    printf("%c ",root->data);
    BTNodePrevOrder(root->left);
    BTNodePrevOrder(root->right);
}
// 二叉树中序遍历
void BTNodeInOrder(BTNode* root)
{
    BTNodePrevOrder(root->left);
    if(root == NULL)
    {
        return;
    }
    printf("%c ",root->data);
    BTNodePrevOrder(root->right);
}
// 二叉树后序遍历
void BTNodePostOrder(BTNode* root)
{
    BTNodePrevOrder(root->left);
    BTNodePrevOrder(root->right);
    if(root == NULL)
    {
        return;
    }
    printf("%c ",root->data);
}
// 层序遍历
void BTNodeLevelOrder(BTNode* root)
{
    Queue q;
    QueueInit(&q);
    assert(root);
    QueuePush(&q, root);
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        printf("%c ",temp->data);
        if(temp->left)
        {
            QueuePush(&q,temp->left);
        }
        if(temp->right)
        {
            QueuePush(&q,temp->right);
        }
 
        QueuePop(&q);
    }
    QueueDestory(&q);
}
// 二叉树节点个数
int BTNodeSize(BTNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    return BTNodeSize(root->left)+BTNodeSize(root->right)+1;
}
// 二叉树查找值为x的节点
BTNode* BTNodeFind(BTNode* root, TElemType x)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->data==x)
    {
        return root;
    }
    BTNodeFind(root->left, x);
    BTNodeFind(root->right,x);
}
// 二叉树第k层节点个数
int BTNodeLevelKSize(BTNode* root, int k)
{
    if(root==NULL)
    {
        return 0;
    }
    if(k==1)
    {
        return 1;
    }
    return BTNodeLevelKSize(root->left, k-1)+BTNodeLevelKSize(root->right, k-1);
}
// 二叉树叶子节点个数
int BTNodeLeafSize(BTNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->left==NULL&&root->right==NULL)
    {
        return 1;
    }
    return BTNodeLeafSize(root->left)+BTNodeLeafSize(root->right);
} 
// 判断二叉树是否是完全二叉树
int BTNodeComplete(BTNode* root)
{
    if(root==NULL)
    {
        return 1;
    }
    Queue q;
    QueueInit(&q);
    QueuePush(&q,root);
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp==NULL)
        {
            break;
        }
        QueuePush(&q,temp->left);
        QueuePush(&q,temp->right);
 
    }
    while(!QueueEmpty(&q))
    {
        BTNode *temp= QueueFront(&q);
        QueuePop(&q);
        if(temp!=NULL)
        {
            printf("info:该二叉树不是完全二叉树\n");
            return 0;
        }
    }
    printf("info:该二叉树是完全二叉树\n");
    return 1;
}
// 二叉树销毁
void BTNodeDestroy(BTNode** root)
{
    if(root==NULL)
    {
        return ;
    }
    if(*root==NULL)
    {
        return;
    }
    BTNodeDestroy(&((*root)->left));
    BTNodeDestroy(&((*root)->right));
    free(*root);
    *root=NULL;
    return;
}
//求二叉树的高度
int BTNodeHeight(BTNode*root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->right==NULL&&root->left==NULL)
    {
        return 1;
    }
    return (BTNodeHeight(root->left)>=BTNodeHeight(root->right) ? BTNodeHeight(root->left)+1 :BTNodeHeight(root->right)+1);
}
//队列的创建
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
 
    pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    assert(newnode);
 
    newnode->data = x;
    newnode->next = NULL;
 
    if (pq->tail == NULL)
    {
        assert(pq->head == NULL);
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
}
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(pq->head && pq->tail);
 
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* next = pq->head->next;
        free(pq->head);
        pq->head = next;
    }
}
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL;
}
size_t QueueSize(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    size_t size = 0;
    while (cur)
    {
        size++;
        cur = cur->next;
    }
 
    return size;
}
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->head);
    return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->tail);
 
    return pq->tail->data;
}
//求双亲
BTNode * getParents(BTNode* root,BTNode* i){
    if(!root||!i||root==i){
        return NULL; 
    }
    if(root->left==i||root->right==i){
        return root;
    }
    BTNode *temp=getParents(root->left,i);
    if(temp){
        return temp;
    }else{
        return getParents(root->right,i);
    }
}
//求左孩子
BTNode * getlc(BTNode* root,BTNode* i){
    if(!root||!i||!i->left){
        return NULL; 
    }
    if(root->left==i||root->right==i||root==i){
        return i->left;
    }
    getlc(root->left,i);
    getlc(root->right,i);
}
//求右孩子
BTNode * getrc(BTNode* root,BTNode* i){
    if(!root||!i||!i->right){
        return NULL; 
    }
    if(root->left==i||root->right==i||root==i){
        return i->right;
    }
    getlc(root->left,i);
    getlc(root->right,i);
}
//求左兄弟
BTNode * getlb(BTNode* root,BTNode* i){
    if(!root||!i||i==root){
        return NULL; 
    }
    if(root->left==i||root->right==i){
        return root->left;
    }
   BTNode *temp=getlb(root->left,i);
    if(temp){
        return temp;
    }else{
        return getlb(root->right,i);
    }
}
//求右兄弟
BTNode * getrb(BTNode* root,BTNode* i){
    if(!root||!i||i==root){
        return NULL; 
    }
    if(root->left==i||root->right==i){
        return root->right;
    }
   BTNode *temp=getrb(root->left,i);
    if(temp){
        return temp;
    }else{
        return getrb(root->right,i);
    }
}

int main() {
    char a[17]={'A','B','D','#','#','E','#','H','#','#','C','F','#','#','G','#','#'};
    int b=0;
    int *pi=&b;
    BTNode *Btree=BTNodeCreate(a, 16, pi);
    printf("\n");
//前序遍历
    printf("info:该二叉树前序遍历为");
    BTNodePrevOrder(Btree);
    printf("\n");
//中序遍历
    printf("info:该二叉树中序遍历为");
    BTNodeInOrder(Btree);
    printf("\n");
//后序遍历
    printf("info:该二叉树后序遍历为");
    BTNodePostOrder(Btree);
    printf("\n");
//层序遍历
    printf("info:该二叉树层序遍历为");
    BTNodeLevelOrder(Btree);
    printf("\n");
//输出二叉树结点数
    int number=BTNodeSize(Btree);
    printf("info:该二叉树结点数为%d\n",number);
//查找为x的结点
    BTNode *find=BTNodeFind(Btree, 'A');
    printf("info:查找结果的根结点为%c\n",find->data);
//查询第k层的结点个数
    int w=BTNodeLevelKSize(Btree, 3);
    printf("info:该二叉树第3层结点数为%d\n",w);
//查询叶子结点的个数
    int count=BTNodeLeafSize(Btree);
    printf("info:该二叉树叶子结点个数为%d\n",count);
//判断当前是否为一棵完全二叉树
    int r=BTNodeComplete(Btree);
//求二叉树的高度
    int x=BTNodeHeight(Btree);
    printf("info:该二叉树的高度是%d\n",x);
//求双亲
    printf("info:该测试结点的双亲结点的前序遍历为");
    BTNodePrevOrder(getParents(Btree,Btree->right->left));
    printf("\n");
//求左孩子
    printf("info:该测试结点的左孩子结点的前序遍历为");
    BTNodePrevOrder(getlc(Btree,Btree->right));
    printf("\n");
//求右孩子
    printf("info:该测试结点的右孩子结点的前序遍历为");
    BTNodePrevOrder(getrc(Btree,Btree));
    printf("\n");
//求左兄弟
    printf("info:该测试结点的左兄弟结点的前序遍历为");
    BTNodePrevOrder(getlb(Btree,Btree->right->right));
    printf("\n");
//求右兄弟
    printf("info:该测试结点的右兄弟结点的前序遍历为");
    BTNodePrevOrder(getrb(Btree,Btree->left));
    printf("\n");
//销毁二叉树
    BTNodeDestroy(&Btree);
    printf("info:该二叉树已销毁\n");
    return 0;
}