简单的树的递归、非递归创建,前序中序后序遍历
扩展问题
问题1.给定前序遍历结果和中序遍历结果，重建二叉树
递归构造就可以了。
Tree* create_by_order(int* pre,int* in,int size){ if(size<=0||pre==NULL||in==NULL){ return NULL; } int i=0; Tree* rt = malloc(sizeof(Tree)); rt->value = pre[0];
//在中序中查找根节点位置 while(i<size){ if(pre[0]==in[i]){ break; }else{ i++; } } rt->left = create_by_order(pre+1,in,i); rt->right = create_by_order(pre+1+i,in+i+1,size-i-1); return rt; }
问题2.二叉树镜像
Tree* mirror(Tree* rt){ if(rt!=NULL){ //交换左右子树的指针 Tree* temp; temp = rt->right; rt->right = rt->left; rt->left = temp; rt->left = mirror(rt->left); rt->right = mirror(rt->right); } return rt; }
问题3.求二叉树节点最大距离
分三种情况
情况1.如第一个图所示，左深度加上右深度
情况2.如第二个图所示，左子树中节点的最大距离
情况3.将图二镜像一下，右子树中节点的最大距离
最后结果就是求这三个中较大的。
int depth(Tree* rt){ if(rt!=NULL){ int l_depth = depth(rt->left)+1; int r_depth = depth(rt->right)+1; return l_depth>r_depth ? l_depth:r_depth; } return 0; } int max(int a,int b,int c){ if(a>b&&a>c){ return a; } if(b>a&&b>c){ return b; } if(c>a&&c>a){ return c; }
return a; } int max_distance(Tree* rt){ if(rt!=NULL){ int l_distance = max_distance(rt->left); int r_distance = max_distance(rt->right); int l_depth = depth(rt->left)+1; int r_depth = depth(rt->right)+1; return max(l_distance,r_distance,l_depth+r_depth); } return 0; }
问题4.求两个节点的最近公共父节点(没有指向父节点指针，树为一般二叉树)
分三种情况
1.如果p1,p2节点分别在root->left,root->right，那么root为p1,p2的祖先
2.如果p1,p2都在root->left，那边将root=root->left 转换为子问题
3.如果p1,p2都在root->right, 那么将root=root->right 转换为字问题
/** *** 查找树中包含某个节点 **/ int contains(Tree* rt,const Tree* p){ if( rt==p ){ return 1; } if(rt==NULL){ return 0; } return contains(rt->left,p)||contains(rt->right,p); } /** *** 查找P1和P2的最近公共父节点 **/ Tree* get_same_parent(Tree* rt,const Tree* p1,const Tree* p2){ if(rt==NULL){ return NULL; } if(p1!=NULL&&p2!=NULL){ int left_contains_p1 = contains(rt->left,p1); int left_contains_p2 = contains(rt->left,p2); int right_contains_p1 = contains(rt->right,p1); int right_contains_p2 = contains(rt->right,p2); if( left_contains_p1 && left_contains_p2 ){ return get_same_parent(rt->left,p1,p2); } if( right_contains_p1 && right_contains_p2 ){ return get_same_parent(rt->right,p1,p2); } return rt; } }
扩展，如果树是搜索树时
1.p1,p2小于root，root=root->left
2.p1,p2大于root, root=root->right
3.p1,p2在root两边，root为p1,p2的最近公共父节点
STree* get_same_parent(STree* rt,STree* p1,STree* p2){ if(rt==NULL){ return NULL; } if( rt->value > p1->value && rt->value > p2->value ){ return get_same_parent(rt->left,p1,p2); } if( rt->value < p1->value && rt->value < p2->value ){ return get_same_parent(rt->right,p1,p2); } return rt; }
扩展，一般树
方法1.
用两个链表保存从根节点到p1,p2的路径。然后将问题转换为两个链表求交集问题。
方法2.
转自：http://www.cppblog.com/qingbizhu/archive/2012/04/05/170213.html
问题5.二叉查找树的删除
待删除节点是叶子节点，直接删除
待删除节点只有左子树或者只有右子树 ，将左（右）子树节点位置替换到待删除节点位置
待删除节点既有左子树又有右子树，遍历到待删除节点的最左下节点位置，也就是找到一个比待删除节点小，但是小得最少的，然后将这个节点替换到待删除节点位置
c语言写着还挺带感
#include<stdlib.h> #define null 0 struct tree{ struct tree* left; int value; struct tree* right; }; typedef struct tree Tree; Tree* root; Tree* insert_rcs(Tree* root, int value){ //只在叶节点位置插入 if(root == null){ root = malloc(sizeof(Tree)); root->value = value; root->left = null; root->right = null; //返回新增的叶节点 return root; } if(root->value > value){ root->left = insert_rcs(root->left, value); }else{ root->right = insert_rcs(root->right, value); } return root; } Tree* insert_no_rcs(Tree* root, int value){ Tree* newnode = malloc(sizeof(Tree)); newnode->value = value; newnode->left = null; newnode->right = null; if(root == null){ root = newnode; return root; } //p为工作指针 Tree* p = root; //p节点是插入节点，pre节点时插入节点的父节点 Tree* pre; while(p){ pre = p; if(p->value > value){ p = p->left; }else{ p = p->right; } } if(pre->value > newnode->value){ pre->left = newnode; }else{ pre->right = newnode; } return root; } //前序遍历 void pre_print_rcs(Tree* root){ if(root != null){ printf("value: %d \t",root->value); pre_print_rcs(root->left); pre_print_rcs(root->right); } } Tree* Stack[20]; int top = -1; //前序遍历 非递归 void pre_print_no_rcs(Tree* root){ //top != -1 这个条件一定要加上，这是处理单枝情况 while(root != null || top != -1){ if(root != null){ printf("%d \t",root->value); if(top+1 != 20){ Stack[++top] = root; root = root->left; } }else{ root = Stack[top--]->right; } } } //中序遍历 void in_print_rcs(Tree* root){ if(root != null){ in_print_rcs(root->left); printf("value: %d \t",root->value); in_print_rcs(root->right); } } //中序遍历 非递归 void in_print_no_rcs(Tree* root){ //top != -1 这个条件一定要加上，这是处理单枝情况 while(root != null || top != -1){ if(root != null){ if(top+1 != 20){ Stack[++top] = root; root = root->left; } }else{ root = Stack[top--]; printf("%d \t",root->value); root = root->right; } } } //后序遍历 void post_print_rcs(Tree* root){ if(root != null){ post_print_rcs(root->left); post_print_rcs(root->right); printf("value: %d \t",root->value); } } Tree* Q[20]; int front; int rear; //层序遍历 //输出队头元素，并将左右子树如队列 void level_print(Tree* root){ front = rear = 0; if(root != null){ Q[++rear] = root; while(rear != front){ Tree* p = Q[++front]; printf("%d \t",p->value); if(p->left != null){ Q[++rear] = p->left; } if(p->right != null){ Q[++rear] = p->right; } } } } Tree* create_no_rcs(int* list, int n){ int i; for(i=0; i<n; i++){ root = insert_no_rcs(root, list[i]); } return root; } Tree* create_rcs(int* list, int n){ int i; for(i=0; i<n; i++){ root = insert_rcs(root, list[i]); } return root; } int main(){ int list[10] = { 6,9,7,4,5,2,1,8,12,0 }; //root = create_no_rcs(list, 10); root = create_rcs(list, 10); //pre_print_rcs(root); //pre_print_no_rcs(root); in_print_rcs(root); in_print_no_rcs(root); //post_print_rcs(root); //level_print(root); return 0; }
