`# 1996 #

//编写程序建立的单链表
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
	int data;
	struct Node *next;
 } Node;
 Node *createlist(void);//创建
 void display(Node *head);
 int main()
 {
 	Node *head;
 	head=createlist();
 	display(head);
 return 0;	
 }
Node *createlist(void)//不带头结点的单链表 
{
	Node *head=null,*p,*tail=null;
	int n;
	while(scanf("%d",&n)==1)
	{
		*p=(Node *)malloc(sizeof(Node));
		if(head==null)
		{
			p=head;
		}
		else
		{
			tail->next=p;
			p->data=n;
			p->next=null;
			tail=p;
		}
		return head;
	}
}
//显示单链表
void display()
{
	node *p;
	p=head;
	while(p!=null)
{
	ptintf("%d",p->data);
	p=p->next;
		}
		printf("\n");
}

//判断是否为回文数，采用递归算法
int huiwen(char*s,int n)
{
if(n<2)
return 1;
if(*s!=*(s+n-1))
return 0;
return huiwen(s+1,n-2); 
}

//删除字符串s中出现的所有字符串t
#include<stdio.h>
#define M 10
#define N 2 
int delSubstr(char *str,char *substr)
{
	int i,j;
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
		{
			if(*(str+i+j)==*(substr+j))
			{
				k++;
			}
			if(k==N)
			{
				for(j=0;j<N;j++)
				{
					*(s+i+j)=null;//主串中所有出现字串的位置赋值为空 
				 } 
			}
		}
	}
}
int main()
{
	char *str[M];
	char *substr[N]; 
	int i;
	char *c,*p;
	for(i=0;i<N;I++)
    {
        scanf("%c",&b[i]);
    }
    for(i=0;i<M;I++)
    {
        scanf("%c",&a[i]);
    }
}

//汉诺塔移动递归
int move(char a,char b)
{
	printf("%c->%c",a,b)
 } 
 int func(int n,char a,char b,char c)
 {
 	if(n==1)
 	move(a,c);
 	else
 	{
 		func(n-1,a,c,b);
 		move(a,c);
 		func(n-1,b,a,c);
	 }
 }
 int main()
 {
 	int n;
 	scanf("%d",&n);
 	f(n,a,b,c);
 }

//数据结构
//合并链表
int Merge(List la,List lb,List lc,int m,int n)
{
	list p;
	list t;
	if(m<0||n<0||(m==0&&n==0))
	return null;
	if(m<n)
	{
		if(m==0)
		return L2;
	}
	else{
		p=L1;
		while(p->next!=null)
		{
			p=p->next;
			
		}
		p->next=L2->next;
		While(t->next!=null)
		{
			t=t->next;
		}
		t->next=L1; 
		free(L2);
	}
 } 
 else{
 	if(n==0)
 	{
 		return L1;  
	 }
 }
 //

//递增有序顺序存储，
//查找值为x的结点找到与后继互换，找不到插入
int search(int array[],int low,int high,int x)
{
	int mid;
	int low=0;
	int high=
	array[low]
	while(low<high)
	
	mid=(low+high)/2;
	if(array[mid]==x)
	temp=array[mid];
	arrat[mid+1]=array[mid];
	array[mid]==temp;
}
else if(array[mid]>x)
{
	high=mid-1;
	
}
else{
	low=mid+1;
}
move=high;//此时未找到元素，需要插入，此时low+1为插入位置，low与high之间的元素都要后移一位 
while(move>=low+1)
{
	array[move+1]=array[move];
	move--; 
}
array[low+1]=x;
}

//交换树的左右孩子
int swap(Bitree T)
{
	if(T==NULL)
	return 0;
	if(T!=null)
	{
		temp=T->lchild;
		
		T->rchild=T->Tlchid; 
		T->rchild=temp;
	 } 
	 swap(T->lchild);
	 swap(T->rchild);
	 } 

//利用直接插入原则将单链表整理成有序的
int insert(Linklist *L)
{
	LNode *p=L->next;
	 LNode *pre;
	LNode *r=p->next;//r记录p后继结点指针，保证不锻炼
	p->next=null;//初始只保存一个结点
	while(p!=null)
	r=p->next;
	pre=L;
	whilr(pre->next!=null&&pre->next->data<p->data)
	pre=pre->next;
	p->next=pre->next;
	pre->next=p;
	p=r; 
 } 

1997

//数组循环右移k个位置
#include<stdio.h>
inlcude<stdlib.h>
#define M 10
#define N 3;
#define Maxsize N+K
int move(int array[],int k)
{
	int i=0;
	p=p+M-1;
	for(i=n-1;i>=0;i++)
	*(p+k)=*p;
	*p=1;//移动后数据域清零 
 } 
 void show(int *p)
 int i=0;
 for(i=0;i<M+k;i++)
 {
 	printf("%d"p[i]);
  } 
  int main()
  {
  	int array[Maxsize];
  	printf("输入n个整数\n");
  	for(int i=0;i<N;i++)
  	{
  		scanf("%d",p+i);
  		printf("%d",*(p+i));
	  }
	  move(array);
	  show(array);
  }
  //递归进行循环移动
void reverse(int R[],int start,int end)
{
    int i,temp;
    for(i=0;i<(end-start+1)/2;i++)
    {
        temp=R[start+!];//交换操作
    }
}
void Converse(int R[],int n,int p)
{
reverse(R,0,p-1);
    reverse(R,p,n-1);
    reverse(R,0.n-1);
}

 //数据结构
  //把所有奇数置于所有偶数前
  //利用快排的思想
 int Move(int arrayp[],int n)
 {
 	int i=0;
 	int j=n-1;
 	int temp=array[0];
 	while(i<j)
 	if(array[i]%2!=0&&i<j)
 	{
 		i++;
	 }
	 if(array[i]%2==0&&i<j)
	 {
	 	j--;
	 }
	 if(i<j)
	 temp=array[i];
	 a[i]=array[j];
	 array[j]=temp;
	 i++;
	 j--;
  }  

//将两个链表中相同结点倒置
  int reverse(linklist la,linklist lb)
  {
  	lnode *p=la->next;
  	lnode *q=lb->next;
  	lnode s=la;//s记录前驱。保证不断链 
  	while(p&&q)
  	{
  		if(p->data==q->data)
  		{
  			p=p->next;
  			q=q->next;//匹配后移 
		  }
		  else{
		  	s=s->next;//不匹配,与la下一个进行比较， 
		  	p=p->next;
		  	q=l2->next;//lb从头开始 
		  }
	  }
	  //头插法进行逆置操作、
	  if(q->next==null)//如果lb到达末结点
	  {
	  	m=p->next;//匹配结点前驱 
		r=m->next; //第一个匹配结点
		while(r->next!=q)
		{
			t=r->next;//记录第一个匹配结点后继防止断链 
			r->next=p->next;
			p->next=r;
			r=t;
		 } 
	   } 
   } 

//树高为k,结点为n,先序递归遍历
 void preorder(int a[],int i,int n)
 {
 	if(i<n)
 	printf("%d",a[i]);
 	preorder(a,2*i,n);
 	preorder(a,2*i+1,n);
  } 
//打印输出最大叶子结点所有祖先结点
void print( int a[],int n)
{
	n=n/2;
	if(n>=1)
	{
		printf("%d",a[n]);
		print(a,n);
	}
 } 
 

1998

//1998
//将自然数表示成质因数的乘积
int func(int m,int n)
{
	printf("亲输入自然数\n");
	int n;
	scanf("%d",&n);
	if(n==1)
	printf("1不是指数，输入错误，请重新输入\n");
		scanf("%d",&n);
		if(m>=n)
		{
			if(m%n!=0)
			{
				func(m,n+1);
			}
			else{
				printf("%d",n);
				if(m!=n)
				{
					printf("*");
				}
				func(m/n,n);
			}
		}
 } 

//所有值为负数的移动到正数前
int move(int array[n],int low,int high,int n)
{
	int low=0;
	int high=n-1;
	int temp=array[low];
	while(low<high)
	{
	while(i<j&&array[j]>0)
	{
		j--;
	}
	if(i<j)
	{
		array[i]=array[j];
		i++;
	}
	while(i<j&&array[j]>0)
	
		i++;

	if(i<j)
	{
		array[i]=array[j];
		j--;
	}
	}
 } 

//数据结构
//将所有结点倒置
 int reverse(linkist *L,int i)
 {
 	lnode *p=L->next;
 	lnode *pre=L;
 	int count=; 
 	while(count<i)
 	{
 		pre=p;//i的前驱结点 
 		p=p->next;
 		count++;
	 }
	 q=p->next;//结点i 
	 while(m-i)
	 {
	 	p->next=q->next;
	 	q->next=pre->next;
	 	pre->next=q;
	 	q=p->next;
	 	m--;
	 }
	p->next=pre->next;//首尾相接 
  } 

//二叉排序树删除有左右结点的孩子
  int delchild(int array[],int n,int i)
  {
  	int del_l=2*i;
  	int del_l_r=del_l;//待删除结点左子树最右下结点
	  while(del_l_l*2+1<=n)
	  del_l_r=del_l_r*2+1;
	  a[i]=a[del_l_r];//填入被删除结点
	  int empty=del_l_r;
	  if(del_l_r*2<n)
	  {
	  	a[del_l_r]=a[del_l_r*2];
	  	empty=del_l_r;
	   } 
   } 

1999

//将数组循环右移n个元素
int move(int array[] int number, int n)
{
	int temp; 
	if(n>=1)
	{
	for(int i=0;i<n;i++)
	{
		temp=array[number-1];
		for(j=number-1;j>=0;j--)//从末尾开始把每个元素向后移动一位 
		{
			array[j+1]=array[j]
					}
					*array=temp;
	}
 } 
 void enter(int *array,int number)
 {
 	int i=0;
 	printf("请输入数据\n");
 	for(i=0;i<number;i++)
	 {
	 	scanf("%d",&array+i);
	  } 
 }
 int main()
 {
 	int array[maxsize];
 	int i=0;
 	int n=0;
 	p
 }
      //递归进行循环移动
void reverse(int R[],int start,int end)
{
    int i,temp;
    for(i=0;i<(end-start+1)/2;i++)
    {
        temp=R[start+!];//交换操作
    }
}
void Converse(int R[],int n,int p)
{
reverse(R,0,p-1);
    reverse(R,p,n-1);
    reverse(R,0.n-1);
}

//查找子串在主串中最后一次出现的位置
 int search(char*str,char *substr)
 {
 	int *p=str;
	 int *q=substr;
	 while(p!='\0')
	 {
	 	s=p;//保存起始位置 
	 	while(*s==*q&&*q!='\0')
	 	{
	 		p++;q++;
		 }
		 if(q!='\0')
		 {
		 	index=p; 
		 }
	  } 
	  p++;
  } 
  return index;
}

//数据结构
//判断二叉树是否为平衡二叉树
int getdepth(Bitree t)
{
	if(t==null)
	return 0;
	int ldepth,rdepth,depth;
	ldepth=getdepth(T->rchild);
	rdepth=getdepth(T->rchild);
	depth=ldepth>rdepth?ldepth+1:rdepth+1;
	return depth;
 } 
 int balanceTree(Bitree T)
 {
 	int lchilddepth,rchilddepth;
 	lchildrepth=getdepth(t->rchild);
 	rchilddepth=getdepth(t->rchild);
 	if(abs(lchilddepth-rchilddepth)<=1)
 	return balanceTree(t->lchlld)&&balanceTree(t->rchild);
 	else
 	return 0;
 }
 

//将二叉树叶子结点链接成为双链表
int connect(btnode *L)
{
	Btnode head=(Btnode*)malloc(sizeof(Btnode));//给头结点分配空间
	*pre=head; 
	if(t!=null)
	if(t-rchild==null&&t->lchild==null)
	{
		pre->rchild=p;
		p->lchild=pre;
		pre=p;
	}
	else{
		connect(p->lchild);
		connect(p->rchild);
	}
	return head;
	 
 } 

//图的邻接表存储
 #define MaxbertexNum 100
 typedef struct ArcNode{//邻接结点 
 	int adjvex;
	 struct ArcNode *next; 
 }ArcNode;
 typedef struct VNode
 {
 	int data;
 	ArcNode *firstarc;
  } VNode,Adjlist[MaxvertexNum];
  typedef struct
  {
  	Adjlist vertuces;
  	int vertex;
  	int arcnum;
  }ALGraph;
  
//拓扑排序
bool topSort(Graph G)
{InitStack(S);
	for(int i=0;i<G.vexnum;i++)
	{
		if(indegree[i]==0)
		push(S,i);
		int count=0;//记录当前已经输出的顶点数
		while(!IsEmpty(S))
		{
			pop(S,i);
			print[count++]=i;
			for(p=G.vertices[i].firstarc;p;p=p->nextarc)
			{
				v=p->adjvex;
				if(!(--indegree[v]))
				push(S,v);
			 } 
			 if(count<G.vexnum)
			 return false;
			 else
			 return true;
		 } 
	}
 } 

2000

 //判断是否有环
 //拓扑排序
 void topsort(Graph G)
 {
 	InitStack(S);
 for(int i=0;i<G.vexnum;i++)
 {
 	if(!(indegree[i]))
 	{
 		push(S,i);
	 }
	 while(!Isempty(S))
	 {
	 	pop(S,i);
	 	print[count++]=i;
	 	for(p=vertices[i].firstarc;p;p=p.nextarc)
	 	{
	 		v=p->adjvex;
	 		if(!(--indegree[v]))
	 		push(S,v);
		 }
		 if(count<G.vexnum)
			 return false;
			 else
			 return true;
	 }
 }
  } 

//删除二叉排序树中值为x的结点
  int deleteNode(Bitree bt,int x)
  {
	  if(x<p->data)
	  {
	  	q=p;
	  	p=p->lchild;
	  }
	  else{
	  	q=p;
	  	p=p->rchild;
	  }
	  if(p==null)
	  {
	  	return flase;//没有找到x结点 
	  }
	  else if(p->lchild==null){//待删除结点左子树为空； 
	  	q=p;//q指向待删除结点 
		  p=p->rchild;
		  free(q); 
	  } 
	  else if(p->rchild==null)
	  {
	  	q=p;
	  	p=p->lchild;
	  	free(q);
	  }
	  else{//左右子树都不为空；
	  q=p;
	  s=p->lchild;
	  while(s->rchild)
	  {
	  	q=s;
	  	s=s->rchild;//遍历左子树最右下结点 
	  	p->data=s->data; 
	   } 
	  	if(q!=p)
	  	{
	  		q->rchild=s->lchild;//
		  }
	  }
   } 
   

2001

//求字符串a与b最长公共子串
int search(char *a,char *b)
{
	int i=0;
	int m=0;
	char *max;
	char *p;
	char *q=b;
	while(*a!='\0'&&*q!='\0')
	{
		p=a;
		while(*a!='\0'&&*q!='\0'){
			
			if(*a==*q){
				a++;q++;
			i++;
			}
			q++; 
		}
		if(i>m)
		{
			max=p;
			mm=i;
		}
		a++;
		q=b; 
	}
	for(j=0;j<mm;j++)
	{
		printf("%c",*max);
	}
 } 
 int main()
 {
 	int i=;
 	char a[10];
 	char b[10];
 	scanf("%c",&a)
 	puts(a);
 		scanf("%c",&b)
 	puts(b);
 	search(a,b);
 }

//排序后每一行最大值，是各行最大值中最小的，最后一行最大值是各行最大中最小的
 #include<stdio.h>
 #include<stdlib.h>
int main()
{
	int cloumn=5;//列数
	int row=4;
	int matrix[4][5]={{2,3,6,8,3},{}} 
}
//查找每行最大值 
int seekMaxelement(int *( array)[],int column)
{
	int max_element=*(array+0);//首先认为第一个元素最大 
	for(int i=0;i<5;i++)
	{
		if(max_element<*(array+i)) 
		{
			max_element=*(array+i); 
		}
		return max_element; 
	}
}

void sortmatrix(int (*array)[],int column,int row)
{
	for(int i=0;i<row;i++)
	{
		for(int j=0;j<row;j++)
		{
			//求当前行的最大值 
			max_element_before=Seek(array+j,5);
					//求下一行最大值
					max_element_later=seek(Array+j+1,5);
					if(max_element_before>max_element_later) 
		Exchange(array+j,array+j+1); 
			}
	}
 } 
 //交换两行对应位置元素 
 void exchange(int (*array1)[5],int (*array2)[5],int column)
 {
 	int i=0;
	 int temp=0;
	 for(i=0;i<column;i++)
	 {
	 	temp=*(*(array1+i));
	 	*(*(array1+i))=*(*(array2+i));
	 	*(*(array2+i))=temp;
	  } 
 }
 //打印数组结果 
 int print()
 {
 	int i,j;
 	for(i=0;i<row;i++)
 	{
 		for(j=0;j<column;j++)
 		{
 			ptintf("%d" array[i][j]);
 			printf(" ")
		 }
		 printf("\n");
	 }
 }

 //判断二叉树是否相似
 int compare(Bitree t1,Bitree t2) 
 {
 	if(t1==null&&t2==null||t1==t2)
 	return 1;
 	else if(t1->data==t2->data&&compare())
 }

void preTopost(ElemType pre[],int l1,int h1,ElemType post[],int l2,int h2)
//pre先序数组 post后续数组 l1 h1先序序列起始和结尾 l2 h2 后序序列起始和结尾 
{
    int half;//中间一半结点处
	if(h1>=l1)
	{
		post[h2]=pre[l1];//交换根结点
		preTopost(pre l1+1,l1+half,post,l2,l2+half-1); 
		preTopost(pre half+l1+1,h1,post,l2+half,h2-1);
	 } 
}

//后续线索二叉树的非递归遍历
//利用前驱线索逆向先序遍历 即遍历序列成为根右左，在反向输出即为后序序列
void preReverse(Bitree T)
{
    p=T->lchild;//T为头结点，T的左链指向根
    while(p!=T)
    {
        printf(p->data);
if(p->rtag==0)
    p=p->rchild;
        else{
p=p->lchild;
            reverse()//反向输出
        }
}

2002

int create(list L,list la,list lb,list lc)
 {
 	lnode *s=L;
 	lnode *p,*q,*r;
 	while(l!=null)
 	{
 		if(l->data>=0&&l->data<=9)
 		{
 			*p=(lnode*)malloc(sizeof(lnode));
 			p->data=l->data;
 			p->next=la->next;
 			la->next=p;
		 }
	 }
 }
 //从右向左释放叶子结点
int array[Maxsize]=0;
int count=0;
 in release(Bitree bt)
 {
 	
 	while(bt!=null)
 	{
 		if(bt->lchild==null&&bt-<rchild==null)
 		{
 		  bt->rchild==null;
		   bt->lchild==null;
	array[count++=bt->data;	
		 }
		 else{
		 	release(bt->lchild);
		 	release(bt->rchild);
		 }
	 }
  } 
  

//求解二叉树平衡因子
int getdepth(Bitree bt)
{
	int depth;
	int ldepth,rdepth;
	if(bt==null)
	return 0;
	else{
		ldepth=getdepth(bt->lchild);
		rdepth=getdepth(bt->rdepth);
		return ldept>rdepth ? (ldepth:rdepth)+1;
	}
 } 
 void Balance(Bitree bt)
 {
 	if(bt)
 	{
 		Balance(bt->lchild);
 		Balance(bt->rchild);
 		m=getdepth(bt-lchild);
 		n=getdepth(bt->rchild);
		 T->bf=m-n;
		 printf(T-<bf); 
	 }
 }

//逆邻接表存储结构定义
 #define vertex MaxvertexNum;
 typedef struct ArcNode{//邻接表结点 
 	int adjvex;
	 struct ArcNode *next; 
 }ArcNode; 
 typedef struct VNode{//顶点表结点 
 	Elemtype data;
	 struct VNode *firstarc;
 }VNode,Adjlist[MaxvertexNum];
typedef struct
{
	Adjlist vertices;
	int arcnum;
	int vexnum;
 }ALGraph; 
 //逆邻接表的拓扑排序只需要每次挑选出度为0的点
 void topsort(Graph G)
 {
 	InitStack(S)
 	{
 		for(int i;i<G.vexnum;i++)
 		{
 			if(outdegree[i]==0)
 				push(S,i);
 				int count=0;
 			
		 }
		 while(IsEmpty(S))
		 {
		 	pop(S,i);
		 	print[count++]=i;
		 	for(p=G.vertice[i].firstarc;p;p=p->nextarc)
		 	{
		 		v=p->adjvex;
		 		if(!(--outdegree[v]))
		 		{
		 			push(S,v);
				 }
			 }
			 if(count<vexnum)
			 return false;
			 else
			 return true;
		 }
		 
	 }
  } 
  

2003

//单链表递增就地排序 
int sort(List L)
{
	list p,q;
	int temp;
	for(q=L->next;q!=null;q=q->next)
	{
		for(p=q->next;p!=null;p=p->next)
		{
			if(q->data>p->data)
			temp=q->data;
			q->data=p->data;
			p->data=temp;
		}
	}
 } 
 return L;
}

//中序线索二叉树结点结构
//二叉树中序线索化 
void InTherd(Bitree *T)
{
	Bitree *p,*pre//前驱线索
	if(p!=null)
	{
		InThread(p->lchild);
		{//递归线索化左子树 
		
		if(p->lchild==null)//左子树为空建立前驱线索 
		{
		p->lchild=pre;
		 p->ltag=1;//ltag=1表示无左孩子指向前驱 
		 } 
		 if(pre!=null&&pre->rchild==null)
		 {
		 	pre-rchild=p;//后继指向当前访问结点
		 	pre->rtag=1;
		  } 
		  pre=p;
		  InThread(p->rchild);
	 } 
 } 
    //前序遍历
    void firstTra(Bitree *T)
 {
 	Bitree *p;
 	p=T->lchild;//p为根节点，T为头结点
 	while(p!=T)
    {
        printf("%4d\n",p->data);
    }
        while(p->ltsg==0)
        {
            p=p->lchild;
            printf("%4d\n",p->data);
        }
        if(p->rtag==1)
        {
            p=p->rchild;
        }if(p->rtag==0)
        {
            p=p->rchlild;
        }
 	
 }
    //中序遍历线索二叉树（递归）
 void FirstNode(ThreadNode *p=T)
    while(p!=null)
    {
        if(p->ltag==0)
        {
            p=p->lchild;
        }
        return p;
    }
void NextNode(ThreadNode *T)
{{
    if(p->rtag=0)
    {
        return (FirstNode(p->rchlid));
    }
    return p;
}
void InOrder(ThreadNode *T)
{
  for(ThreadNode *p=FirstNode(T);p!=null;p=NextNode(p));
    visit(p);
}
  
 void PostOrder(ThreadNode T)//后续线索二叉树遍历
 {
     ThreadNode pre;
     while(T!=null&&T->ltag==0)
     {
         p=p->left;
     }
     while(T!=null)
     {
if(T->rtag==1)//右结点为线索
{
    printf("%d",p->data);
    pre=node;//记录已经访问过的结点
    p=p->next;
}//循环跳出条件，p为空，左单只情况，2有右子树，结点为根节点
     }
     //跳出循环判断是否为根节点
     if(p==T&&p->rchild==pre)//只存在一个根节点
     {
         printf("%d",p->data);
         return ;
     }
     //非根节点
     while(pp->rchild==prev)
     {
         printf("%d",p->data);
         pre=p;
         p=p->rchild;
     }
     if(p&&p->rtag==o)
     {
p=p->rchild;
     }
 }

2004

//括号匹配问题
 char stack[50]={0};
 char string[50];
 int match(char *m,char *n)//m指向栈顶。n指向表达式 
 {
 	char str[2][3]={'{','[','(',')',']','}'};
 	int post;
 	if(*n!=='\0')
 	{
 		if(*m=='\0')
 		return 1;
	 }
	 else{
	 	return 0;
	 }
	 else if(in(t,b))//当前为左括号，入栈 
	 {
	 	*(p++)=*t++;//优先级相同，从右往左计算，但因为++位于后 
	 return (m,t)//匹配下一个 
	 }
	 else if(post=in(t,b+1)>=0){//此处b+1是数组向下移动一行 
	 	if(*p==*(*b+ost))
	 	{//匹配 
	 		p--;//出战
			 t++; 
		 }
		 return match(p,t);
	 } else{
	 	return 0;
	 }
  } 
  int in(char*p,char(*t)[3])//char 类型指针 ，行指针 
{
	int i=0;
	for(i=0;i<3;i++)
	{
		if(*p==*(*t+i))
		{
			return i;
		}
	}
	return -1;
 } 

//一个升序一个降序，合并为有序链表
void sort(Link LA,link LB)
 {
 	link *p=la->next;
 	link *q=lb->next;
 	la->next=null;
 	while(p&&q)
 	{
 		if(p->data<=q->data)
 		{
 		r=p->next;
 		p->next=la->next;
 		la->next=p;
 		p=r;
		 }else{
		 	r=q->next;
		 	q->next=lb->next;
		 	lb->next=q;
		 	q=r;
		 }
		 if(pa)
		 pb=pa;
		 while(lb){
		 	r=pb->next;
		 	pb->next=la->next;
		 	la->next=lb;
		 	lb=r;
		 }
		 free(lb;)
	 }
  } 
  

//数据结构
//插入手机价格重新排序
ypedef struct Node
  {
  	int pricel;
  	int num; 
  	struct *Node next;
  }Node,*Linklist;
  void insert(*LinkList,int n)
  {
  	for(i=0;i<n;i++)
  	{
  		scanf(&price);
  		s=(linklist)malloc(sizeof(Node));
  		s->price=price;
  		s->num=1;
  		p=l->next;
  		if(p->value<s->value)
  		{
  			s->next=l->next;
  			l->next=s;
		  }
		  else{
		  	while(p->next&&(p->next->value>s->value))
		  	{
		  		p=p->next;
			  }
			  if(!p->next)
			  {
			  	s->next=p->next;
			  	p->next=s;
			  }
			  else if(p->next->value==s->value){
			  	p->next->num++; 
			  }
		  }
	  }
   } 
   

2005

/*编写算法，从字符串S中删除所有和字符串t相同的字符*/

#include<iostream>
#include<string>
using namespace std;


void compare(char *str,char *t)
{

	while(*str!='\0')//查找下一个匹配子串 
	{
 char *p=str;
	char *s=p;//记录长串第一个匹配位置 
	int flag=1;
	char*q=t;
	while(q!='\0')//子串不为空
	{
		if(*p!=*q)//不匹配 
		{
			flag=0;
			break;
		 } 
		 else{//匹配往后移动指针 
		 	p++;q++;
		 }
	 } 
	 if(flag=1)
	 {
	 	return s; 
	 }
	 
	 ++str;
		 } 
	 if(*str=='\0')
	 {
	 	return str;
	  } 
	  
}
void delete(char *index,int t_length)
{
	char *tail;
	tail=index+t_length;//待删除子串后的第一个字母地址
	while(*tail!='\0')
	{
		*index=*tail;
		++index;++tail;
	 } 
 } 

//2005年
//从哈希表中删除关键字为k的记录 
int delete(Hashtable &H,int k)
{
	int location=H(key);//位置下标 
	Hashtable *p=H.elem[location]->next;//哈希表首地址元素 
	while(p!null)
	{
		if(p->data==key)
		{
			t->next=p->next;
			free(p);
			return true;
		}
		else{
			t=p;
			p=p->next;
		}
	 } 
}

//求祖先
int ancestor(Bitree *T,int x)
{
	if(T!=null&&T->data==x)
	{
		
		return false;
	}
	else if(ancestor(T->rchild,x)||ancestor(T->rchild,x))
	{
		printf("%d",T->data);
		return true; 
	}
	return false;
 } 

 //深度优先遍历是否存在v到j的路径
 void Travserse(Graph G)
 {
 	for(int v=0;v<G.vexnum;v++)
 	{
 		visited[v]=fasle;
	 }
	 for(v=0;v<G.vexnum;v++)
	 {
	 	if(!visited[v])
	 	{
	 		DFS(G,v);
		 }
	 }
  } 
  int visited[MaxSIZE]={0};//访问标记数组 
  void DFS(Graph G,int v)
  
  {
  	visit(v);
  	visited[v]=true;
  	for(w=FirstNeighbor(G,w);w;w=NextNeighbor(G,v,w))
  	{
  		if(!visited[w])
  		{
  			if(vi-vj)
  			{
  				printf("success");
			  }
  			DFS(G,v);
		  }
	  }
  }

 //基于广度优先判断路径是否达
int visited[maxsize]={0};
int BFS(Graph G,int i,int j)
{
	initQueue(s);
	enqueue(G,i);//i入队
	while(!(QueueIsempty(s)))
	{
		Dequeue(G,v);//队头出队 
		visited[v]=true;
		if（v==j)//路径可达 
		return 1; 
		for(int p=firstNeighbor(G,i);p;p=nextNeighbor(G,v,p))
		{
			if(p==j)
			return 1;
			if(!visited[p]){
			
			enqueue(G,p);
			visited[p]=true;
		 } 
	 } }
 } 

2006

 //编写函数判断n个单词是否按字典排序
 #include<stdio.h>
 #include<stdlib.h>
 #define N 50
 int oderByDic(char word[N][20],int n)
 {
 	if(n<2)
 	{
 		return 1;
	 }
	 if(strcmp(word[n-2],word[n-1]<=0))//strcmp 参数类型 const char *
	 {
	 	if(!oderByDic(word,n-1))
	 	{
	 		return 0;
		 }
		 else{
		 	return 0
		 }
		 return 1;
	  } 
     
    } //strcmp(const char *)
 int main()
  {
  	char word[N][20];
  	int i,j;
  	char c;
  	while((c=getchar())!='\n')
  	{
  		if (c==' ')
  		{
  			word[i][j]='\0';//一行单词已经结束进入下一行 
  			j=0;
  			i++;
		  }
		  else{
		  	word[i][j]=c;
		  }
	  }
  }

//三个链表，删除A中出现在b和c的所有结点
typedef struct Node
{
	int data;
	struct Node *next;
}Node,*LinkList;
int create(*LinkList L)//创建链表 
{
	L=(Linklist)malloc(sizeof(LinkList));
	L->next=NULL;
	Lnode *p,*s;

	scanf("%d",&n);//输入链表数据 
	 while(n!=-1)
	 {
	 	s=(*LNode)malloc(sizeof(LNode));
	 	s->data=n;
	 	s->next=L->next;
	 L->next=s;
	 scanf("%d",&n);	
	 }
	 return L;
 } 
int delete(Linklist La,Linklist Lb,Linklist Lc)
{
	Lnode *p,*q,*r;
	p=la->next;
	q=lb->next;
	r=lc->next;
	*pre=La;
while(q!=null)
{
	while(r!=null){
	
	if(q->data==r->data)
	{
		array[k]=q->data;//使用数组保存在B在C的结点 
		k++; 
	}
	r=r->next;
}
r=lc->next;
q=q->next;
}		
while(p!=null)
{
	for(i=0;i<k;i++)
	{
		if(p->Data==array[i])
		s=p->data;
		pre->next=p->next;
		free(p);
		p=pre->next;
		if(p==null)
		break;
	}
	}	
	if(p==null)
	break;
	pre=p;
	p=p->next;
		}
		return La;
	}
 } 
 int main()
 {
 	
 }           
 

//数据结构
 //利用栈和队列判定回文
 int judge(Linklist *L,int n)
 {
 	linklist *p;
 	int count=0;
 	int e;
 	InitStack(S);
 	InitQueue(Q);
 	p=L->next;
 	count+=1;
 	while(p!=null&&)
 	{
 		push(S,p);
 		enQueue(Q,p);
 		p=p->next;
 		count++;
	 }
	 while(!QueueIsEmpty(Q)&&!IsEmpty(S))
	 {
	 	if(Deque(Q,&e)!=Pop(S,&e))
	 	{
	 		return 0;
		 }
		 return 1;
	 }
				}

//求二叉树平衡因子
int getDepth(Bitree T)
{
	int depth,ldepth,rdepth;
	if(T==null)
	return 0;
	if(T!null)
	{
		ldepth=getDepth(T->lchild);
		rdepth=getDepth(T->rchild);
		return (ldepth>rdepth? ldepth:rdepth)+1;
	}
												
}
int balance(Bitree T)
{
	if(T)
	{
		balance(T->lchild);
		balance(T->rchild);
		m=getDepth(T->lchild);
		n=getDepth(T->rchild);
		
		printf(T->bf=m-n);
	}

int BfsTopSort(Graph G)
{
	InitStaack(S);
	int count=1;
	for(i=0;i<G.vexnum;i++)
	{
		if(!indegree[i])
		{
			push(G,i);//出度为0，入栈 
		}
		while(!IsEmpty(S))
		{
			pop(G,i);
			label(G,i,count);//对节点进行编号
			for(w=FirstNeighbor(G,i);w;w=nextNeighbor(G,i,w)) 
			{
				if(!(--indegree[w]))
				{
					push(G,w);
				}
			}
		 } 
	}
		}	

2007

//约瑟夫环的问题
int main()
{
	int i
	printf("请输入约瑟夫环大小\n");
	scanf("%d",&n);
	for(i=0;i<N;i++)
	/*用数组长度为N的数组存储N个人，并将数组全部初始化为1,用以记录第n-1个人在圈内还是圈外*/ 
	//1为圈内，0为圈外 
	{
		a[i]=1;
	}
	while(out!=n-1)
	{
		if(a[i]==1)
		{
			n++;//记录圈内报数情况 
		}
		if(n==3)
		{
			a[i]=0;//出圈
			n=0;
			out++ 
		 } 
		 i++;
		 if(i==N)
		 {
		 	I=0;
		 }
	 } 
				for(i=0;i<N;i++)
				{
					if(a[i]==1)
					{
						pritnf
					}
				}
		}		
}

//建立图的邻接表存储
#define 
typedef struct ArcNode{
	int adjvex;
	struct *ArcNode next;
}ArcNode;
typedef struct VNode
{
	int data;
	ArcNode *firstarc;//指向第一条依附该顶点弧的指针 
}VNode,AdjList[MaxVertexNum];
typedef struct
{
	AdjList vertices;
	int arcnum;
	int vexnum;
}ALGraph;
void Create(Graph G)
{
	AdjList vertices;
	int arcnum,vexnum;
	printf("请输入图的顶点数和边数");
	scanf("%d%d",&vexnum,&arcnum);
	getchar();
	printf("请输入顶点信息：\n");
	for(int i=0;i<G.vexnum;i++)
	{
		scanf("%c",&G.vertice[i].data);//输入顶点数据
		G.vertice[i].firstarc=null;//此时顶点表指向邻接点为空 
	 } 
	 getchar();
	 printf("请输入一条边依附的起点和终点序号");
	 for(i=1;i<G.arcnum;i++)
	 {
	 	scanf("%d",&s);
	 	scanf("%d",&e);
	 	getchar();
		 p=(*ArcNode)malloc(sizeof(ArcNode));
		  p->adjvx=e;
		  p->nextarc=G.vertice[s].firstarc;
		  G.vertices[s].fitstarc=p;
	  } 
}
void Reverse(Graph &A,Graph &B)
{
	B.arcnum=A.arcnum;
	B.vexnum=A.vexnum;
	for(i=1;<G.vexnum;i++)
	{
		scanf("%d",&B.vertices[i].data);
		B.vertices[i].firstarc=null;
	}
	for(i=1;i<A.arcnum;i++)
	{
		p1=A.vertices[i].firstarc;//p1的出度 
	 while(p1)
	 {
	 	k=p1.adjvex;
	 	p2=(*ArcNode)malloc(sizeof(ArcNode));
		 p2->adjvex=i;//此处的i是p2的出度指向另一个依附该顶点的边 
		 p2->nextarc=B.vertices[k].firstarc;
		 B.vertices[k].firstarc=p2;
		 p1=p1->nextarc;
	 }
	}															}	
	

//合并两颗平衡二叉树
void Insert(bitree T,int value)															
{
	if(T==null)
	{
		T=new Bitree;
		T->rchild=T-lchild=null;
		T->data=key;
		return 1;
		if(key==T>data)
		return;
		if(value>T->data)
		{
			insert(T->rchild,value);
		}
		else{
			insert(T->lchild,value);
		}
}
}
void preOrder(Bitree T)
{
	if(T)
	{
		preOrder(T->lchild);
		printf("%d",T->data);
		preOrder(T->rchild);
	}
}
void merge(Bitree T1,Bitree T2)
{
	if(T2){

	merge(T1,T2->lchild);
	insert(T1,T2->data);
	merge(T1,T2->rchlid);
		}
}

2009

//删除循环单链表中结点x的直接前驱结点
typedef struct{
	int data;
	struct LNode *next;
	struct LNode *prior; 
}LNode,*Linllist;
int delete(Linklist *x)
{
if(x->next==x)
{
	pritnf("Error");
	return ;
}
else{
	LNode *p=x;
	while(p->next->next!=null)
	{
		p=p->next;
	}
	LNode *s=p->next;
	free(s);
	p->next=x;
}
 } 

2010

//2010年
 int judege(Linklist *L)
 {
 	LNode *p=L->next;
 	while(p->next->next!=null&&p->data==(p->next->data+p->next->next->data))
 	{
 		p=p->next;
	 }
	 //如果循环在倒数三个结点之前就退出说明链表不符合题意
	 if(p->next->next->next)//此地循环还没有到达末端节点
	 {
	 	return 0; 
	  } 
	  else{
	  	return 1;
	  }
  } 

//后序遍历计算表达式的值
float calculate(Bitree T)
{
	float lnum,rnum;
	lnum= calculate(T->lchild);
	rnum=calculate(T->rchild);
	switch(T->optr)
	{
		case '+':value=lnum+rnum;break;
		case '-':value=lnum+rnum;break;
		case '*':value=lnum+rnum;break;
		case '/':value=lnum+rnum;break;
	}
}

//类似于BFS
void D(Graph G,int v)
{
	InitStack(S);
	visit(v);
	visited[v]=true;
	push(G,v);
	while(!IsEmpty(S))
	{
		pop(G,v);
		for(w=FirstNeoghbor(G,v);w;w=NextNeighbor(G,v,w))
		{
			if(visited[w])
			{
				visited[w]=true;
				visit(w);
				push(S,w);
			 } 
		}
	}

}

2011

/将穿str1中第i个字符到第j个之间字符替换成str2;
char *stuff(char *str1,char *str2,int i ,int j)
{
	int len1=strlen(str1);
	int len2=strlen(str2);
	int len=len1-(j-i+1)+len2;//替换之后的字符串长度
	h=(char *)malloc(sizeof(len+1));//扩展字符空间
	strcpy(h,str1);//拷贝i之前的字符
	strcpy(h+i-1,str2);
	strcpy(h+i-1+len2,str1+j); 
 } 

//找二维数组鞍点
int main() 
{
	int max=0;
	int array[3][3];
	for(int i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
		{
			if(array[i][j]>max)
			{
				max=a[i][j];
				p=j;
			}
			else{
				max=max;
				p=p;
			}
		}
	}
	if(for k=0,min=a[i][p];k<3;k++)
	{
		if(a[k][p]<min)
		{
			min=a[k][p];
			q=k;
		}
		else{
			min=min;
			q=q;
		}
	}
	if(i==q)
	{
        printf("%d",a[i][p]);
		(printf("输出鞍点"))
        break;
	}
}
if(i==3&&i!=q)
{
    printf("鞍点不存在")；
        return 0;
}

//递增建立单链表
int create(Linklist *L)
{
	LNode *p=L->next;//此时只有一个结点
	L->next==null;
	pre=L;
	r=p->next;//r保存p的后继防止断链
	p=r;
	while(p!=null)
	{
		r=p->next;
		pre=L;
		while(pre->next!=null&&pre->next<p->data)
			pre=pre->next;
			
		p->next=pre->next;
		pre->next=p;
		p=r; 			
	 } 
 } 

//求二叉树中第i层和i+1层叶子节点个数
 int count(Bitree T,int i)
 {
 	int leaf=0;int depth=0;
 	if(T)
	 {
	 	depth+=1;
	 	if(depth==i||depth==i+1&&(p->lchild==null&&p->rchild==null))
	 	{
	 		leaf+=1;
		 }
		 
	  } 
	  count(T->lchild,int i);
	  depth-=1;先序遍历玩左节点回退到父亲节点，高度-1
	  count(T->rchild,int i);
	  depth-=1; 
  } 

//求连通分量，并打印每一个分量的值 
void DFS(Graph G,int v)
  {
  	visit(v);
  	visited[v]=true;
  	printf("%d",&v);
  	for(w=firstNeighbor(G,w)w;w=nextNeighbor(G,v,w))
  	{
  		if(!visited[w])
		  {
		  	DFS(G,w);
		   } 
	  }
   } 
   void getPart(Graph G)
   {
   	for(v=0;v<G.vexnum;v++)
   	{
   		visited[v]=flase;
	   }
	   for(v=0;v<G,vexnum;v++)
	   {
	   	if(!visited[v])
	   	{
	   		printf("此连通分量包含节点：");
			   DFS(G,v); 
		   }
	   }
   }

2013

int f(int n,int m)
{
	result;
	if(m==0||m>n)
	{
		return 0;
	}
	if(m==1||m==n)
	{
		return 1;
	}
	sum=m+f(n-1.m)-f(n-1.m-1);
	return sum;
}

//九宫格
int judge(int (*array)[3],int row,int col)
{
	tri_sum=0;
	col-sum=0;
	row_sum=0;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		{
			if(i==j)
			{
				tri_sum+=array[i][j];
			 } 
			 row_sum+=array[i][j];
		}
		if(row_sum!=15)
		{
			return 0; 
		}
	 } 
	 for( int i=0;i<3;i++)
	 {
	 	for(j=0;j<3;j++)
	 	{
	 		col_sum+=array[j][i];
		 }
	 }
 } 
 

//删除第i个元素起共len个元素
 int delete(Linklist *L,int i)
 {
 	LNode *p=L->next;
 	pre=L;int count=0;
while(p)
{
	p=p->next;
	count++;
}
if(count>=i&&<(i+len)){
	
	pre=pre->next;
	pre->next=p->next;
	free(p);
	p=pre->next;
	
}
else{
	pre=p;
	p=p->next;
}
count++;
  } 
  

//查找x的值，求出该节点层数 
int search(Bitree T,int x)
  {
  	int count;
 if(T)
 {
 	count+=1;
 	if(T->data==x)
 	return count;
 }
 else{
 	search(T->lchild);
 	count-=1;
 	search(T->rchild);
 	count-=1;
 }
  }

//判断图是否存在根，即某一结点到其他所右结点均可达
void Dfs(Graph G,int v)
{
	visit(v);
	visited[v]=true;
	print(v);
	for(w=FirstNeighbor(G,w);w;w=NextNeighbor(G,v,w))
	{
		if(!visited[w])
		{
			count+=1;
			Dfs(G,w)
		}
	}
}
void traverse(Graph G,int v)
{
	for(v=0;v<G.vexnum;v++)
	{
		visited[v]=false;
	}
	for(v=0;v<G.vexnum;v++)

{
	if(visited[v])
	{
		DFS(G,v);
	}
	if(count==G.vexnum)
	{
		printf("%d",G.Adjlist[i].data);
	}
	for(v=0;v<G.vexnum;v++)
	{
		visited[v]=false;
	}
}}

2014

//2014
//统计大小写字母将大写反序输出
int calculate(char *str)
{
	int max=0,min=0;
	char *p=str;
	while(p)
	{
		if(*p>='A'&&*p<='Z')
		{
			max++;
		}
		if(*p>='a'&&*p<='z')
		{
			min++;
		}
		p=p+1;
	}
}
void reverse(char *str)
{
	char *p=str;
	while(p)
	{
		p++;
	 } 
	 p=p-1;
	 if(*p>='A'&&*p<='Z')
	 {
	 	printf("%c",*p);
	 	p--;
	 }
}

//行最大列最小
//找二维数组鞍点
int main() 
{
	int max=0;
	int array[3][3];
	for(int i=0;i<3;i++)
	{
		for(j=0;j<3;j++)
		{
			if(array[i][j]>max)
			{
				max=a[i][j];
				p=j;
			}
			else{
				max=max;
				p=p;
			}
		}
	}
	if(for k=0,min=a[i][p];k<3;k++)
	{
		if(a[k][p]<min)
		{
			min=a[k][p];
			q=k;
		}
		else{
			min=min;
			q=q;
		}
	}
	if(i==q)
	{
        printf("%d",a[i][p]);
		(printf("输出鞍点"))
        break;
	}
}
if(i==3&&i!=q)
{
    printf("鞍点不存在")；
        return 0;
}

ge（SeqList a; int n)∥
{i=0; j=n-1; ∥// i,j为工作指针（下标），初始指向线性表a的第1个和第n个元素。

t=a[0]; /∥//暂存枢轴元素。

while(i<j)

{ while(i<j && a[j]>=0) j--; ∥// 若当前元素为大于等于零，则指针前移。

if(i<j){a[i]=a[j];i++;} ∥ //将负数前移。

while(i<j &&a[i]<0)i++; ∥ //当前元素为负数时指针后移。

if(i<j) a[j--]=a[i]; ∥ //正数后移。

}

a[i]=t; ∥//将原第一元素放到最终位置。

}

//求二叉树中以x为值的结点作为根节点子树深度
int getdepth(Bitree T,int x)
{
	int count=0;
	if(T!=null&&T->data==x&&T->lchild!=null&&T-rchild!=null)
	return 1;
	else{
		int ldepth=getdepth(T->lchild) ;
		int rdepth=getdepth(T-rchild);
		return (ldepth>rdepth?ldepth:rdepth)+1; 
	}
 } 
 int calculate(Bitree T,int x)
 {
 	
 }

//输出u到v长度为len的简单路径 
 int path[];
 int length=0;
 void DFS(Graph G,int start,int u,int v,int len)
 {
 	visit(start);
 	visited[start]=true;
 	path[length++]=start;
 	for(w=FirstNeighbor(G,start);w;w=NextNeighbor(G,start,w))
 	{
 		if(!visited[w])
 		{
 			if(w==vlength==len)
 			pritnf(path);
		 }
		 else{
		 	DFS(g,w,v);
		 	visited[v]=false;
		 }
	 }
  } 
  

2015

//字符串的复制
int copy(char *str1, char *str2,int k)
{
	char *p=str;
	int end=strlen(str1)-1;
	int count=1;
	while(p)
	{
		p=p++;
		count++;
		if(count==k)
		{
			while(*p)
			{
				*p=*str2;
				p++;
				str2++;
			}
		}
	}
	*str2='\0';
 } 

//判断链表值是否有序
 //此处还应该添加判断递增有序还是递减有序 
 int judege(LinkList L)
 {
 	LNode *P=L->next;
 	while(p)
 	{
 		if(p->data<p->next)
 		{
 			p=p->next;
		 }else{
		 	return 0;
		 }
	 }
  } 
  

//求二叉树最大密度
int MaxLeaf(Bintree T)
{
Bitree p;
InitQueue(Q);//初始化队列
Q.front=q.rear=-1;//空队列
Q.rear++;//队列指针后移
Q.data[Q.rear]=b;//根入队
Q.level[Q.rear]=1;//根节点层次为1
int count=1;
while(!IsEmpty(Q))
{
	dequeue(Q,T);//根出队
	k=level;
	if(T->lchild!=null)
	{
		enqueue(T->lchild);
		level=k+1;
		count++;
	 } 
	if(T->lchild!=null)
	{
		enqueue(T->rchild);
		level=k+1;
			count++;
	 } 
 } 
 max=0;//保存同一层最多结点数
 k=1;
 while(int i<count)
 {
 	n=0;
	 while(i<count&&)
  } 
 } 

//BFS下的单源最短路径
 void BFS(Graph G,int v ,int k)
 {
 	
 	InitQueue(Q);
 	for(int i=0;i<G,vexnum;i++)
 	{
 		d[i]=;//初始化路径长度 
	 }
	 visited[v]=true;d[v]=0;
	 enqueue(G,u);
	 while(!IsEmpty(Q))
	 {
	 	DEqueue(G,u);
	 	for(w=firstNeighbor(G,u);w;w=NextNeighbor(G,u,w))
	 	{
	 		if(!visited[w])
	 		{
	 			visited[w]=true;
	 			d[w]=d[u]+1;
	 			if(d[w]==k)
	 			{
	 				printf("")
				 }
				 else{
				 	Enqueue(G,w);
				 }
			 }
		 }
	  } 
  } 

2016

//查找给定字符串在字符串首次出现的位置，

char search(char *str,char substr)
{
char *p=str;
    int index=1;
    while(p)
    {
        printf("*******");
        if(*p==substr)
            return index;
        p++;
        index++;
    }
}
int main()
{
    char substr;
    char str[Maxsize];
    int index;
    printf("请输入字符串");
    scanf("%s",substr);
    substr=getchar();
    putchaar(substr);
    printf("")
}

#define //查找字符串首次出现位置
char index(char *str1,char *str2)
{
	char *p=str1;
	int index=1;
	while(p)
	{
		printf("---------");
		if(*p=*str2){
			return index;
		}
		p++;
		str2++;
	}
	return 0;
}
int main()
{
	char str2;
	char str[Maxsize]={0};
	int index;
	printf("Enter str2.\n");
	str2=getchar();
	putchar(str2);
	putchar('\n');
	printf("Enter a string\n");
	scanf("%c",str);
}

//访问频度递减
int locate(Linklist L,int x)
{
	LNode *p=L->next;
	int freq=0;
	 LNode head=L;
	while(p!=head)
	{
		if(p->data==x)
		{
			p->freq=p->freq+1;
		
		r=head->next;//一边遍历一边翻转 ,此时r指向首元结点 
		//找到x在表头 
		while(r!=q) 
		{
			if(r->freq<p->freq)
			{
				p->prior->next=p->next;
				p->next->prior=p->prior;
				r->prior->next=p;
				p->prior=r->prior;
				p->next=r;
				r->prior=p;
				return true;
			 } 
			 r=r->next;
		}
		return true;
	}
	p=p->next;
}}

//求二叉树结点的层次 
int count=0;
int PreOrder(Bitree T,int x)
{
	count++;
	if(t!=null)
	{
		if(T->data==x)
		printf("%d",&count)
		return true;
	}
	else{
		Preorder(T->lchild);
		count-=;
		PreOrder(T->rchild);
		count--;
	}
 } 

//查找所有联通分量
 void Connect(Graph G,int v)
 {
 	for(int i=0;i<G.vexnum;i++)
 	{
 		if(!visited[i])
 		{
 			DFS(G,i);
 			count++;
		 }
	 }
	 printf("连通分量个数为"\d"",count); 
  } 
void DFS(Graph G,int v)
{
	visit(v);
	visited[v]=true;
	print(v);//函数输出结点 
	for(w=FirstNeighbor(G,V);w;NextNeighbor(G,v,w))
	{
		if(!visited[w])
		{
			DFS(G,w);
		}
	 } 
}

2017

typedef struct student
{
	int number;
	int grade;
	int studentID;
 }Student;
 int create(Student **list)
 {
 	Student *p=list->next;
 	list->next=null;
 	int A=0;
	 B
	 C
	 D
	 E
	 float grade=0;
	 int studentID=0;
	 printf("Enter StudentID:");
	 if(StundetID<0)
	 {
	 	printf("链表构建失败"); 
	 }
	 printf("Enter grade:") 
	 scanf("%f",&grade);
	 if(score<0||score>100)
	 {
	 		printf("链表构建失败"); 
	 }
	 while(score>0&&score<100&&StundetID>=0)
	 {
	 	if(score>=90&&score<=100)
	 	{
	 		A++;
		 }
		 else if(score>=90&&score<=100){
		 	B++;
		 }
		  else if(score>=80&&score<90){
		 	C++;
		 }
		  else if(score>=70&&score<80){
		 	D++;
		 }
		  else {
		 	E++;
		 }
	 }
	 Student *s=(Student*)malloc(sizeof(Student));//为结点分配空间
	 s->score=score;
	 s-StudentID=StudentID; 
	 s->next=list->next;
	 list->next=s;
	 
 }
  printf("Enter StudentID:");
	 if(StundetID<0)
	 {
	 	break;
	 }
	 printf("Enter grade:") 
	 scanf("%f",&grade);
	 if(score<0||score>100)
	 {
	 	break;
	 }
	 if(p)==null{
	 printtf("链表数据为空，构建失败"); 
	 }
	 printf();
}

//回文数和完数判断
int huiwen(int *a)
 {
 	printf("请输入整数");
	 scanf("%d",&number);
	 while(number){
	 	a[length++]=number/10;
	 	
	 	length+=1;
	 	number=number/10;
	 }
	 int i=0;j=length-1;
	 while(i<j)
	 {
	 	if(a[i]==a[j])
	 	{
	 		i++;j--;
		 }
		 else{
		 	break;
		 }
		 if(i<j)
		 {
		 	printf("不是回文");
			 		 }
			 		 else{
			 		 	printf("Yes");
					  }
	for(i=1;i<number;i++)
	{
		if(number%i==0)
		{
			sum+=i;
		}
		if(sum==number)
	}
	 }
	 
 }
 

 //线性表删除多余重复元素
 #define MaxSize 100
 int delete (int array[],int n)
 {
 	for(int i=0;i<n;i++)
 	{
 		if(a[i]==a[i+1])
 		{
 			a[i]=a[i+1];
		 }
	 }
	 return ;
  } 
int treeDegree(Bitree T)
{
	int degree=0;int MaxDegree;
	if(T==NULL)
	{
		return 0;
	}
	while(p)
	{
		MaxDegree++;
		T=t
	}
}

//逆邻接表的构建
void reverse(Graph *G1，Graph *G2)
{
	G2.vexnum=G1.vexnum;
	G2.arcnum=G1.arcnum;
	copy(G1.vertices,G2.certices)
	for(i=0;i<G.vexnum;i++)
	{
		for(p=G1.vertices[i].firstarc;p;p=p->nextarc){
			k=p->adjvex;
			*q=(ArcNode *)malloc(sizeof(ArcNode));
			q->Aajvex=i;
		}
		q->next=G1.vertices[k].firstarc;
		g2.vertices[k].firstarc=q;
	
	}
 } 

2018

 //查找最长单词
int main()
{
	char a[3000];
	char b[3000],char[3000];
	for(int i=0;i<3000;i++)
	{
		if(a[i]!=32&&a[i]!='\0')
		{
			len++;//记录单词长度 
		}
		if(a[i]!=32a[i+1]==32)
		{
			c[j]=i;//记录单词末尾位置
			b[j=len;
			len=0; 
			j++; 
		 } 
		 if(a[i]=='\0')//到达末尾
		 {
		 	c[j]=i;
			 b[j]=len; 
		  } 
	}
	for(i=1;i<=j;++)
	{
		if(b[i]>b[max])
		{
			max=i;
		}
		for(i=0;i<=j;i++)
		{
			if(b[i]==b[max])
			break;
			
		}
		for(j=c[i]-b[i];j<c[i];j++)
		{
			printf("%c",c[j]);
		}
	}
	return 0;
 } 

typedef struct Salary{
 	char id[10];//编号 
 	char name;//名字 
 	float wage;//工资 
 	struct salary *next; 
 };
 
 int create(Salary *L)
 {
 	L=(Salary*)malloc(sizeof(Salary));
 	L->next==null;
 	printf("请输入员工工资：")
 	for(int i=0;i<n;i++)
 	{
 		Salary *p=(Salary*)malloc(sizeof(Salary));
 		scanf("%f,%s",&(p->wage,p->id));
 		p->next=L->next;
 		L->next=p;
 		
	 }
	 return L;
 }
void BubbleSort(Salary *L)
 {
 	Salary *p,*q;
 	P=L->next;
 	for(p=L->next;p;p=p->next)
	 {
	 	for(q=p->next;q;q=q->next)
	 	{
	 		if(p->wage>q->wage)
	 		{
	 			temp=q;
	 			p=q;
	 			p=temp;
			 }
		 }
	  } 
  } 
int main()
{
	
}
//

int judge(char A[],int n)//判断出入栈序列是否合法
{
	int i;
	ElemType x;
	InitStack(S);
	for(i=0;i<n;i++)
	{
		if(A[i]=='D')
		push(S,A[i]);
		else if(A[I]=='A')
		pop(S,A[i]);
	}
}

//二叉树是否等
typedef struct Node{
	int data;
	struct node *lchild;
	rchild;
}Bitree;
int equal(Bitre T1,bitree T2)
{
	if(T1==NULL&&T2==NULL)
	{
		return 1; 
	}
	if(!t1||!t2)

return 0;
if(T1->data==t2->data)
{
	return equal(T1->lchild,t2->lchild)&&equal(t1->rchild,t2->rchild);
}
else{
	return 0;
}
 } 
 

2019

 //2019
 //自守数
 int main()
 {
 	for(int i=1;i<10000;i++)
 	{
 		if((i*i)/10==i)
 		{
 			printf("%d ",i);
		 }
	 }
  } 
  int judge(unsigned int num)
  
{
	unsigned int pow=num*num;
	while(num)
	{
		if(num%10!=pow%10)
		return 0;
		num/=10;pow/=10;
	}
	return 1;
}
int main()
{
	for(int i=1;i<=10000;i++)
	if(judge(i))
	printf("%d\n",i);
}

//是否满足上三角行列式
#define N 3
int judge(int array[][])
{
	for(int i=0;i<N;i++)
	{
		for(int j=0;j<i;j++)
		{
			if(array[i][j]!=0)
			{
				return 0; 
			}
			return 1;
		}
	}
}

//求递增或递减子序列
int func(Linklist *L)
{
	if((!L)||(!L->next))
	return 0;
	if(!L->next->next)
	return 1;
	Lnode *p=L->next->next;
	*q=L->next;
	int count=0;
	while(p->next)
	{
		if(p->data>p->next->data&&(p->data>q->data)||)
		{
			count++;
			p=p->next;
			q=q->next;
		}
	}
 } 

2020

//求由N个1组成的可以被1221整除的最小的数
int func(int n)//返回n个一形成的整数 
{
	if(n==1)
	return 1;
	return 10*func(n-1)+1;
}
int main()
{
	int i=0;
	do{
		i++;
	} while(fun(i)%1221==0)
	printf("%d",fun(i));
 } 

//键盘输入500个数存入数组，求相差最小的两个
 #define Maxsize 500
 int func( int *array)
 {
 	int min;
 	for(int i=0;i<N;i++)
 	{
 		scanf("%d",&a[i]);
		 min=abs(a[0]-a[i]);
		 for(i=0;i<N;i++){
 		for(int j=i+1;j<i;j++)
 		{
 		if(abs(a[i]-a[j]<min))
 		{
 			min=a[i]-a[j];
		 }
		 }}
	 }
	 printf("%d",min);
 }

typedef struct score{
 	char sport[100];//项目名称
	 int athlete;//运动员编号
	 char college[50];//学院名称；
	 int palce;//名次
	 float result; 
 }Score;
 #define N 100
 void total (struct score record[N])
 {
 	int i;num[10];
 	for(int i;i<N;i++)
 	{
 		if(record.place<=6)//前六名
		 {
		 	num[record[i].college[0]-65]++;
			 printf("%s学院运动员编号为%d的成绩为%f排名为%d",record[i].college,record[i].athlete,
			 record[i].result,record[i].place); 
		  } 
	 }
	 for(i=0;i<10;i++)
	 {
	 	printf("%c"); 
	 }
 }

 int search(Linklist L)//查找倒数第m个位置元素
 {
 	LNode *p,*q;
 	p=L->next;
	 q=L->next;
	 int count=0;
	 while(p)
	 {
	 	if(count<m)
	 	{
	 		count++;
	 		p=p->next;
		 }
		 else{
		 	q=q->next;
		 	p=p->next;
		 }
	  } 
	  if(count<k)
	  return 0;
	  else
	  printf("%d",q->data);
  } 

Graph G,int s,int d)//单源最短路径
{
	for(int i=0;i<G,vexnum;i++)
	{
		path[i]=无穷;
	}
	Initqueue(Q);
	visited[s]=true;path[s]=0;
	dequeue(Q,s);
	for(w=firstNeighbor(G,w);w;w=NextNeignbor(G,s,w))
	{
		if(visited[w])
		{
			visited[w]=true;
			path[w]=path[s]+1;
			enqueue(G,w);
			BFS(G,w,d);
		}
	 } 
}

`