`# 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);
		}
	 } 
}

`