算法篇----树

1. 求二叉树中叶子节点的个数（12年，17年）

	int Leave(BiTree *BT){
		if(BT==null)   
			return 0;
		else {
			if(BT->lchild==null && BT->rchild==null)
				return 1;
			else
				return(Leave(BT->lchild)+Leave(BT->rchild));	
		}
	}

2. 从大到小输出二叉排序树中所有的值不小于x的关键字（19年）

	void OutPut(BSTnode *bt,KeyType k){
		if(bt==null)
			return ;
		if(bt->rchild!=null)
			OutPut(bt->rchild,k);
		if(bt->data>=k)
			printf("%d",bt->data);
		if(bt->lchild!=null)
			OutPut(bt->lchild,k);			
	}

3. 假设二叉树采用二叉链存储，编写一个非递归算法，输出先序序列中第k个节点的数据值（18年）

	void PreOrder(Btnode *bt,int k){
		Btnode *p;
		SqStack sq;
		InitStack(sq);
		p=bt;
		int i=1;
		while(!StackEmpty(sq) || p!=null){
			while(p!=null){
				if(i==k)
					printf("%d",p->data);
				Push(sq,p);
				p=p->lchild;
				i++;
			}
			if(!StackEmpty(sq)){
				Pop(sq,p);
				p=p->rchild;
			}
		}
	}

4. 二叉树按二叉链表形式存储，设计一个非递归算法求二叉树的高度

	int BtDepth(BiTree T){
		if(!T)
			return 0;
		int fornt=-1,rear=-1;
		int last=0,level=0;
		BiTree Q[maxsize];
		Q[++rear]=T;
		BiTree p;
		while(front<rear){
			p=Q[++front];
			if(p->lchild)
				Q[++rear]=p->lchild;
			if(p->rchild)
				Q[++rear]=p->rchild;
			if(front==last){
				level++;
				last=rear;
			}
		}
		return level;
	}

5. 构造哈夫曼树，并求编码（16年）

	#define MAXBIT      100
	#define MAXVALUE  10000
	#define MAXLEAF     30
	#define MAXNODE    MAXLEAF*2 -1
	typedef struct {
    		int bit[MAXBIT];
    		int start;
	}HCodeType;        // 编码结构体
	typedef struct {
    		int weight,parent,lchild;
    		int rchild,value;
	}HNodeType;        // 结点结构体

	void HuffmanTree (HNodeType HuffNode[MAXNODE], int n{ 
    /* m1、m2：构造哈夫曼树不同过程中两个最小权值结点的权值,x1、x2：两个最小权值结点在数组中的序号。*/
    		int i, j, m1, m2, x1, x2;
   // 初始化存放哈夫曼树数组 HuffNode[] 中的结点
    for (i=0; i<2*n-1; i++){
        HuffNode[i].weight = 0;//权值 
        HuffNode[i].parent =-1;
        HuffNode[i].lchild =-1;
        HuffNode[i].rchild =-1;
        HuffNode[i].value=i;
    } 
    // 输入 n 个叶子结点的权值
    for (i=0; i<n; i++)
    		scanf ("%d", &HuffNode[i].weight);
    // 循环构造 Huffman 树
    for (i=0; i<n-1; i++){
        m1=m2=MAXVALUE;     
        // m1、m2中存放两个无父结点且结点权值最小的两个结点
        x1=x2=0;
        // 找出所有结点中权值最小、无父结点的两个结点，合并
        for (j=0; j<n+i; j++){
            if (HuffNode[j].weight<m1 && HuffNode[j].parent==-1){
                m2=m1; 
              	  x2=x1; 
                m1=HuffNode[j].weight;
                x1=j;
            }
            else if (HuffNode[j].weight<m2 && HuffNode[j].parent==-1){
                m2=HuffNode[j].weight;
                x2=j;
            }
        } 
        // 设置找到的两个子结点 x1、x2 的父结点信息
        HuffNode[x1].parent  = n+i;
        HuffNode[x2].parent  = n+i;
        HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n+i].lchild = x1;
        HuffNode[n+i].rchild = x2;
 }
	//解码
	void decodeing(char string[],HNodeType Buf[],int Num){
  		int i,tmp=0,code[1024];
  		int m=2*Num-1;
  		char *nump;
 		char num[1024];
 		for(i=0;i<strlen(string);i++){
  			if(string[i]=='0')
  				num[i]=0;        
  			else
  				num[i]=1;                    
 		 } 
  		i=0;
 	 	nump=&num[0];
  		while(nump<(&num[strlen(string)])) {
  			tmp=m-1;
  			while((Buf[tmp].lchild!=-1)&&(Buf[tmp].rchild!=-1)){
		if(*nump==0){
    			tmp=Buf[tmp].lchild ;          
   		} 
   		else 
   			tmp=Buf[tmp].rchild;
  			nump++;
        
 		} 
 	printf("%d",Buf[tmp].value);                                  
	}
}

参考文章：https://blog.csdn.net/u012675150/article/details/43152483

6. 删除二叉排序树中存在关键字等于k的数据元素（19年）

	typedef struct BTNode{
		ElemType data;
		struct BTNode *lchild,*rchild;
	}BTNode,*BTree;
	status DeleteBST(BTree &T,KeyType key){
		if(!T) return false;
		else {
			if(EQ(key,T->data.key)) 
				return Delete(T);
			else if(LT(key,T->data.key))
				return DeleteBST(T->lchild,key);
			else 
				return DeleteBST(T->rchild,key);
		}
	}
	
	Status Delete(BTree &p){
		BTree q,s;
		if(!p->rchild){
			q=p;p=p->lchild;free(q);} //右子树空则只需重接左子树
		else if(!p->lchild){
			q=p;p=p->rchild;free(q);}
		else {
			q=p;s=p->lchild;
			while(s->rchild){
				q=p;s=p->rchild;} //转左，向右走到尽头
			p->data=s->data;
			if(q!=p){
				q->rchild=s->lchild;}
			else{
				q->lchild=s->lchild;}
			free(s);
		}
		return true;	
	}

7. 中序遍历线索二叉树T（16年）

	Typedef enum PointerTag{Tag,thread};
	typedef struct BTnode{
		elemtype data;
		struct BTnode *lchild,*rchild;
		PointerTag LTag,RTag;
	}BTnode,*BTree;
	status InOder(BTree T,status(*visit)(elemtype e)){
		BTnode *p;
		p=T->lchild;
		while(p!=T){
			while(p->LTag==link)
				p=p->lchild;
			if(!visit(p->data))  
				return error;
			while(p->RTag==Thread && p->rrchild!=T){
				p=p->rchild;
				visit(p->data);
			}
			p=p->rchild;
		}
		return ok;
	}