数据结构树

---

树

二叉树

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

//先序遍历    根左右
void PreOrder(BiTree T){
	if(T != NULL){
		visit(T);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}

//中序遍历    左根右
void InOrder(BiTree T){
	if(T != NULL){
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild);
	}
}

//后序遍历	左根右
void PostOrder(BiTree T){
	if(T != NULL){
			PostOrder(T->lchild);
			PostOrder(T->rchild);
	}
}

二叉链表

typedef struct BiTNode{
	char data;
	struct BiTNode *lchild;
	struct BiTNode *rchild;
}BiTNode, *BiTree;

void creat(BiTree &T){
	char ch;
	ch = getchar();
	if(ch == '#') 	T = NULL;
	else{
		T = new BiTNode;
		T->data = ch;
		creat(T->lchild);
		creat(T->rchild);
	}
}
//求叶子结点个数
int countleaf(BiTree T){
	if(T == NULL){
		return ERROR;
	}
	if(T->lchild == NULL && T->rchild){
		return 1;
	}
	if(T->lchild != NULL && T->rchild == NULL){
		return countleaf(T->lchild);
	}
	if(T->lchild == NULL && T->rchild != NULL){
		return countleaf(T->rchild);
	}
	return countleaf(T->lchild) + countleaf(T->rchild);
}
//求度为1的结点个数
int NodeCount(BiTree T){
	if(T->lchild == NULL && T->rchild == NULL) return 0
	if(T->lchild != NULL && T->rchild == NULL){
		return 1+ NodeCount(T->lchild);
	}
	if(T->lchild == NULL && T->rchild != NULL){
		return 1 + NodeCount(T->rchild);
	}
	return NodeCount(T-lchild) + NodeCount(T->rchild);
}
//二叉树的深度
int Depth(BiTree T){
	int m, n;
	if(T == NULL){
		return 0;
	}else{
		m = Depth(T->lchild);
		n = Depth(T->rchild);
		
		if(m > n){
			return (m+1);
		}else{
			return (n+1);
		}
	}
}


//结点x的查找
BiTree search(BiTree t,ElemType x){
	if(T == NULL){
		return NULL;
	}else{
		if(T->data == x) return T;
		if(p = search(T->lchild, x)) return p; //在左子树查找
		if(p = search(T->rchild, x)) return p; //在右子树查找
	}
}



void creat(BiTree &Tr){
	char ch;
	ch = gerchar()
	if(ch == '#'){
		T = NULL;
	}else{
		T = new BiTree;
		T->data = ch;
		creat(T->lchild);
		creat(T->rchild);
	}
}
//中序遍历
void InOrder(BiTree T){
	if(T != NULL){
		InOrder(T->lchild);
	}
	print("%c", T->data);
	InOrder(T->rchild)
}

哈夫曼树

typedef struct{
    int weight;   //结点的权重
    int parent, lchild, rchild;   //结点的双亲，左孩子，右孩子下标
}HTNode, *HuffmanTree;

typedef char **HuffmanCode;   //哈夫曼编码

//选择权值最小的两棵树
void Select(HuffmanTree HT, int len, int &s1, int &s2){
    int i, min1 = 32767, min2 = 32767;
    for(i = 0; i <= len; i++){
        if(HT[i].weight < min1 && HT[i].parent == 0){
            s2= s1;
            min2 = min1;
            min1 = HT[i].weight;
            s1 = i;
        }else if(HT[i].w)
    }
}

void CreateHuffman_tree(HuffmanTree &HT, int n){
	int m, s1, s2, i;
	m = 2*n - 1;
	if(n <= 1){
		return;
	}
	HT = new HTNode[m + 1];
	for(i = 1; i < m; ++i){
		HT[i].parent = 0;
		HT[i].lchild = 0;
		HT[i].rchild = 0;
	}
	for (i = 1; i <= n; ++i){
		scan("%d", &HT[i].weight);
	}
	for (i = n + 1; i <= m ; ++i){
		Select(HT, i-1; s1, s2);
		HT[s1].parent = i;
		HT[s2].parent = i;
		HT[i].lchild = s1;
		HT[i].rchild = s2;
		HT[i].weight = HT[s1].weight + HT[s2].weight;
	}
}


void Huffman_code(HuffmanTree HT, HuffmanCode &HC,int n){
	HC = new char*[n+1];
	char* cd = new char[n];
	cd[n-1] = '\0';
	for(int i = 1; i <= n; i++){
		int start = n- 1;
		int c= i;
		int f = HT[i].parent;
		while( f !=  0){
			--start;
			if(HT[f].lchild == c){
				cd[start] = '0';
			}
			else cd[start] = '1';
			c = f;
			f = HT[f].parent;
		}
		HC[i] = new char[n - start];
		strcpy(HC[i], &cd[start]);
	}
	delete cd;
}