temp

/*
孩子兄弟（左边指向第一个孩子）（右边指向右边的兄弟）表示法 求叶子个数
设置一个全局变量，从根点节点遍历，如果节点的右孩子的是空的则为叶子节点，变量+1 
输入：树的根节点
输入：叶子的个数 
*/
int cnt=0;
void fun(struct node * root){
	if(root){
		if(root->lchild){
			cnt++;
		}
		fun(root->lchild);
		fun(root->rchild);
	} 
} 
/*
计算二叉树的所有叶子节点 
*/
int cnt=0;
void fun(struct node * root){ 
	if(root){
		if(root->lchild==NULL&&root->rchild==NULL){
			cnt++;
		}else{
			fun(root->lchild);
			fun(root->rchild);	
		}
	} 
} 
/*
L1拆成2个链表，一个链表头是L1（尾插）连接奇数序号，另一个L2（头插）连接偶数序号 
输入：链表头指针L1
输入：链表头指针L1、L2
*/
void fun(struct node *L1){
	//新建一个L2
	(struct node *)L2=(struct node *)molloc(sizeof(struct node));
	L2->next=NULL; 
	int i =1;
	//遍历链表，将偶数序号头插入L2 
	struct node * p = L1; 
	while(p){
		if(i%2==0){ 
			//将节点从L1上取下 
			struct node * q =p->next;
			p->next=q->next;
			//将节点插入L2
			q->next=L2->next;
			L2->next=q; 
		}
		p=p->next;
		i++;
	}
} 
/*
递增单链表删除重复值 
思路：链表从头开始遍历，碰到值相同则删除后面一个节点（对最后一个节点的进行特殊处理） 
输入：代处理的单链表头结点
输出：处理后的单链表的头结点 
*/ 
struct node * fun(struct node*L){
	struct node p=L;
	struct node q=L->next;
	while(q){
		//删除q 
		if(q->data==p->data){
			//q是最后一个节点 
			if(q->next==NULL){
				p->next=q->next;
				free(q);
				break;
			}else{
				p->next=q->next;
				free(q); 
				q=p->next;		
			}
		}else{
			p=q;
			q=q->next;	
		}	
	}
	return L;
}
/*
是否是完全二叉树
思路：
按层序遍历二叉树，所有根节点为空，则直接判定是完全二叉树 
将不是空指针的节点放入队列中，碰到空指针则遍历队列中剩余的元素，若存在一个不是空的节点则不是完全二叉树
若最后从外层的循坏调出，则为完全二叉树 
*/
bool fun(struct node * root){
	queue<struct node *> q;
	if(!root){
		return true;	
	}
	q.push(root);
	struct node * temp;
	while(!q.empty()){
		temp=q.front();
		q.pop();
		if(p){
			q.push(q->lchild);
			q.push(q->rchild);
		}else{
			//如果节点是NULL，则后面所有的节点应该都是NULL 
			while(!q.empty()){
				temp=q.front();
				q.pop();
				if(temp!=NULL){
					return false;
				}
			}
		}
	}
	return true;
	return 1;
} 
/**
线性表的排序
冒泡排序(向前冒泡)
*/
for(int i =0;i<n-1;i++){//趟数 n-1趟
	flag=false;
	for(int j=n-1;j>i;j--){//从最后一个元素开始 
		if(A[j-1]>A[j]){
			swap(A[j-1],A[j]);
			flag=true;
		}
	} 
	if(!false)break;
}
//快速排序
int pfun(int A[],int low,int high){
	int num=A[low];
	while(low<high){
		while(low<high&&A[high]>=num)high--;
		A[low]=A[high];
		while(low<high&&A[low]<=num)low++;
		A[high]=A[low];
	}
}
void fun(int A[],int low,int high){
	if(low<high){
		p=pfun(A,low,high);
		fun(A,low,p-1);
		fun(A,p+1,high);
	}
} 
//简单选择排序 一趟进行一次交换 
for(int i =0 ;i<n-1;i++){//和冒泡一样
 	int min=i;//标记 
 	for(int j=i+1;j<n;j++){
 		min=j; 
	}
	if(min!=i)swap(A[i],A[min]);
} 
//堆排序
//建立大根堆 (从1开始放)
void build(int A[],int len){
	for(int i=len/2;i>0;i++){
		HeadAdjust(A,i,len);
	} 
} 
void HeadAdjust(int A[],int k,int len){
	A[0]=A[k];
	for(int i=2*k;i<len;i++){//从左孩子出发 
		if(i<len&&A[i]<A[i+1]){//比较左右孩子 
			i++;
		}
		if(A[0]>=A[i])break;//比两个孩子都大直接跳出 
		else{//大的上移 
			A[k]=A[i];
			k=i;
		}
	}
	A[k]=A[0];
} 
void HeapSort(int A[],int len){
	build(A,len);
	for(int i=len;i>1;i--){
		swap(A[i],A[1]);//大的放最后 
		HeadAdjust(A,1,i-1);//调整第一个元素 
	}
} 
//插入排序
void fun(int A[],int len){
	for(i=1;i<len;i++){
		if(A[i]<A[i-1]){
			temp=A[i];
			for(int j=i-1;j>=0&&A[j]>temp;j--)A[j+1]=A[j];//向后移动
			A[j+1]=temp; 
		}
	}
} 
void fun(int A[],int len){
	for(d=len/2;d>=1;d=d/2){
		for(i=d+1;i<=n;i++){
			if(A[i]<A[i-d]){
				A[0]=A[i];
				for(j=i-d;j>0&&A[j]>A[0];j-=d)A[j+d]=A[j];
				A[j+d]=A[0];
			}
		}
	} 
} 
//归并排序 
void merge(int A[],int low,int mid,int high){
	for(int k=low;k<=high;k++){
		B[k]=A[k];
	} 
	for(int i=low,j=mid+1,k=i;i<=mid&&j<high;k++){
		if(B[i]<=B[j]){
			A[k]=B[i++];
		}else{
			A[k]=B[j++];
		}
	}
	while(i<=mid) A[k++]=B[i++];
	while(j<=mid) A[k++]=B[j++];
}
void sort(int low,int high){
	if(low<high){
		int mid=(low+high)/2;
		sort(A,low,mid);
		sort(A,mid+1,high);
		Merge(A,low,mid,high);
	}
}