数据结构 -- 二叉树

这篇文章介绍的是经典的数据结构--二叉树，在这篇文章里介绍了几乎二叉树的所有操作。

二叉树给我们最重要的印象莫过于递归，因为这棵树就是递归的，所以，我在解决各个问题时大部分都用到了递归，代码简单且易于理解，好吧，这篇文章的代码有点长，贴出来吧：

头文件：

/** dlut_bitree.h**  Created on: 2014年1月13日*      Author: DLUTBruceZhang*/#ifndef DLUT_BITREE_H_
#define DLUT_BITREE_H_#include <stdio.h>typedef       int         need;#define        EMPTY           1
#define     NOT_EMPTY       0typedef struct _bitree
{need data;struct _bitree *lchild;struct _bitree *rchild;
}bitree;void        dlut_bitree_init(bitree **t);
void        dlut_bitree_create(bitree **t);
int         dlut_bitree_empty(bitree *t);void       dlut_bitree_recursion_preorder_traverse(bitree *t);
void        dlut_bitree_recursion_inorder_traverse(bitree *t);
void        dlut_bitree_recursion_backorder_traverse(bitree *t);void        dlut_bitree_preorder_traverse(bitree *t);
void        dlut_bitree_inorder_traverse(bitree *t);
void        dlut_bitree_backorder_traverse(bitree *t);
void        dlut_bitree_backorder2_traverse(bitree *t);void         dlut_bitree_level_traverse(bitree *t);int           dlut_bitree_node_count(bitree *t);
int         dlut_bitree_leaf_node_count(bitree *t);int      dlut_bitree_depth(bitree *t);void       dlut_bitree_find_data(bitree *t, need, bitree **);
int         dlut_bitree_find_max(bitree *t);
int         dlut_bitree_find_min(bitree *t);
void        dlut_bitree_find_its_lchild(bitree *t, need);
void        dlut_bitree_find_its_rchild(bitree *t, need);
void        dlut_bitree_find_its_parent(bitree *t, need);
void        dlut_bitree_find_its_lbrother(bitree *t, need);
void        dlut_bitree_find_its_rbrother(bitree *t, need);bitree * dlut_bitree_copy_the_bitree(bitree *t);
void        dlut_bitree_exchange_l_r(bitree **t);
int         dlut_bitree_is_equal(bitree *t1, bitree *t2);void       dlut_bitree_destory_left(bitree **t);
void        dlut_bitree_destory_right(bitree **t);
void        dlut_bitree_destory(bitree **t);#endif /* DLUT_BITREE_H_ */

C文件：

/** dlut_bitree.c**  Created on: 2014年1月13日*      Author: DLUTBruceZhang*/#include "dlut_bitree.h"
#include "dlut_stack.h"
#include <stdlib.h>void dlut_bitree_init(bitree **t)
{*t = NULL;return;
}void dlut_bitree_create(bitree **t)
{need data;printf("please input the prev data : \n");scanf("%d", &data);if (data == -1)*t = NULL;else{*t = (bitree *)malloc(sizeof(bitree));if (!*t)return;(*t) -> data = data;dlut_bitree_create(&((*t) -> lchild));dlut_bitree_create(&((*t) -> rchild));}
}int dlut_bitree_empty(bitree *t)
{return t == NULL ? EMPTY : NOT_EMPTY;
}void dlut_bitree_recursion_preorder_traverse(bitree *t)
{if (t){printf("%d  ", t -> data);dlut_bitree_recursion_preorder_traverse(t -> lchild);dlut_bitree_recursion_preorder_traverse(t -> rchild);}return;
}void dlut_bitree_recursion_inorder_traverse(bitree *t)
{if (t){dlut_bitree_recursion_inorder_traverse(t -> lchild);printf("%d  ", t -> data);dlut_bitree_recursion_inorder_traverse(t -> rchild);}return;
}void dlut_bitree_recursion_backorder_traverse(bitree *t)
{if (t){dlut_bitree_recursion_backorder_traverse(t -> lchild);dlut_bitree_recursion_backorder_traverse(t -> rchild);printf("%d  ", t -> data);}return;
}void dlut_bitree_preorder_traverse(bitree *t)
{bitree *stack[20];int top = -1;bitree *_t = t;while (_t || top != -1){while (_t){printf("%d  ", _t -> data);stack[++top] = _t;_t = _t -> lchild;}if (top != -1){_t = stack[top--];_t = _t -> rchild;}}printf("\n");return;
}void dlut_bitree_inorder_traverse(bitree *t)
{bitree *stack[20];int top = -1;bitree *_t = t;while (_t || top != -1){while (_t){stack[++top] = _t;_t = _t -> lchild;}if (top != -1){_t = stack[top--];printf("%d  ", _t -> data);_t = _t -> rchild;}}printf("\n");return;
}void dlut_bitree_backorder_traverse(bitree *t)
{bitree *_t = t;bitree *have_visited = NULL;bitree *stack[20];int top = -1;while (_t || top != -1){while (_t){stack[++top] = _t;_t = _t -> lchild;}_t = stack[top];if (_t -> rchild == NULL || _t -> rchild == have_visited){printf("%d  ", _t -> data);have_visited = _t;top--;_t = NULL;}else{_t = _t -> rchild;}}printf("\n");return;
}void dlut_bitree_backorder2_traverse(bitree *t)
{bitree *_t = t;bitree *stack1[20], *stack2[20];int top1 = -1, top2 = -1;stack1[++top1] = _t;while (top1 != -1){_t = stack1[top1--];stack2[++top2] = _t;if (_t -> lchild){stack1[++top1] = _t -> lchild;}if (_t -> rchild){stack1[++top1] = _t -> rchild;}}while (top2 != -1){printf("%d  ", stack2[top2--] -> data);}printf("\n");return;
}void dlut_bitree_level_traverse(bitree *t)
{bitree *_t = t;bitree *queue[20];int count = -1;int cur_pos = -1;if (_t){printf("%d  ", _t -> data);queue[++count] = _t;}while (count != cur_pos){_t = queue[++cur_pos];if (_t -> lchild){printf("%d  ", _t -> lchild -> data);queue[++count] = _t -> lchild;}if (_t -> rchild){printf("%d  ", _t -> rchild -> data);queue[++count] = _t -> rchild;}}printf("\n");return;
}int dlut_bitree_node_count(bitree *t)
{static int count = 0;if (t){count++;dlut_bitree_node_count(t -> lchild);dlut_bitree_node_count(t -> rchild);}return count;
}int dlut_bitree_leaf_node_count(bitree *t)
{static int count = 0;if (t){if (!t -> lchild && !t -> rchild)count++;dlut_bitree_leaf_node_count(t -> lchild);dlut_bitree_leaf_node_count(t -> rchild);}return count;
}int dlut_bitree_depth(bitree *t)
{int d1 = 0, d2 = 0;if (!t)return 0;d1 = dlut_bitree_depth(t -> lchild);d2 = dlut_bitree_depth(t -> rchild);return d1 > d2 ? d1 + 1 : d2 + 1;
}void dlut_bitree_find_data(bitree *t, need data, bitree **td)
{if (!t)return ;else{if (t -> data == data){*td = t;}dlut_bitree_find_data(t -> lchild, data, td);dlut_bitree_find_data(t -> rchild, data, td);}
}int dlut_bitree_find_max(bitree *t)
{static int max;static int flag = 0;if (!t)return -1;if (!flag  || t){if (!flag){max = t -> data;flag++;}if (t -> data > max){max = t -> data;}dlut_bitree_find_max(t -> lchild);dlut_bitree_find_max(t -> rchild);}return max;
}int dlut_bitree_find_min(bitree *t)
{static int min;static int flag;if (!flag || t){if (!flag){min = t -> data;flag++;}if (t -> data < min){min = t -> data;}dlut_bitree_find_min(t -> lchild);dlut_bitree_find_min(t -> rchild);}return min;
}void dlut_bitree_find_its_lchild(bitree *t, need data)
{if (!t){return ;}if (t -> data == data){if (t -> lchild){printf("%d 's lchild is %d\n", data, t -> lchild -> data);}else{printf("%d don't have lchild\n", data);}}dlut_bitree_find_its_lchild(t -> lchild, data);dlut_bitree_find_its_lchild(t -> rchild, data);return;
}void dlut_bitree_find_its_rchild(bitree *t, need data)
{if (!t){return ;}if (t -> data == data){if (t -> rchild){printf("%d 's rchild is %d\n", data, t -> rchild -> data);}else{printf("%d don't have rchild\n", data);}}dlut_bitree_find_its_rchild(t -> lchild, data);dlut_bitree_find_its_rchild(t -> rchild, data);return;
}void dlut_bitree_find_its_parent(bitree *t, need data)
{if (!t){return;}if (t -> lchild || t -> rchild){if (t -> lchild && t -> lchild -> data == data){printf("%d 's parent is %d\n", data, t -> data);}if (t -> rchild && t -> rchild -> data == data){printf("%d 's parent is %d\n", data, t -> data);}}dlut_bitree_find_its_parent(t -> lchild, data);dlut_bitree_find_its_parent(t -> rchild, data);
}void dlut_bitree_find_its_lbrother(bitree *t, need data)
{if (!t){return;}if (t -> rchild && t -> rchild -> data == data){if (t -> lchild){printf("%d 's lbrother is %d\n", data, t -> lchild -> data);}else{printf("%d don't have lbrother\n", data);}}dlut_bitree_find_its_lbrother(t -> lchild, data);dlut_bitree_find_its_lbrother(t -> rchild, data);
}void dlut_bitree_find_its_rbrother(bitree *t, need data)
{if (!t){return;}if (t -> lchild && t -> lchild -> data == data){if (t -> rchild){printf("%d 's rbrother is %d\n", data, t -> rchild -> data);}else{printf("%d don't have rbrother\n", data);}}dlut_bitree_find_its_rbrother(t -> lchild, data);dlut_bitree_find_its_rbrother(t -> rchild, data);
}bitree *dlut_bitree_copy_the_bitree(bitree *t)
{bitree *_t, *lchild, *rchild;if (!t)return NULL;lchild = dlut_bitree_copy_the_bitree(t -> lchild);rchild = dlut_bitree_copy_the_bitree(t -> rchild);_t = (bitree *)malloc(sizeof(bitree));_t -> data = t -> data;_t -> lchild = lchild;_t -> rchild = rchild;return _t;
}void dlut_bitree_exchange_l_r(bitree **t)
{bitree *tmp;if (t){dlut_bitree_exchange_l_r(&(*t) -> lchild);dlut_bitree_exchange_l_r(&(*t) -> rchild);tmp = (*t) -> lchild;(*t) -> lchild = (*t) -> rchild;(*t) -> rchild = tmp;}return;
}int dlut_bitree_is_equal(bitree *t1, bitree *t2)
{int _t1, _t2;if (t1 == NULL && t2 == NULL){return 1;}else if (t1 == NULL || t2 == NULL){return 0;}else{_t1 = dlut_bitree_is_equal(t1 -> lchild, t2 -> lchild);_t2 = dlut_bitree_is_equal(t1 -> rchild, t2 -> rchild);return _t1 && _t2;}
}void dlut_bitree_destory_left(bitree **t)
{if (!t){return;}dlut_bitree_destory_left(&((*t) -> lchild));free(*t);(*t) -> lchild = NULL;return;
}void dlut_bitree_destory_right(bitree **t)
{if (!t){return;}dlut_bitree_destory_right(&((*t) -> lchild));free(*t);(*t) -> rchild = NULL;return;
}void dlut_bitree_destory(bitree **t)
{if (*t){dlut_bitree_destory(&((*t) -> lchild));dlut_bitree_destory(&((*t) -> rchild));free(*t);*t = NULL;}return;
}

数据结构 -- 二叉树相关推荐

数据结构 - 二叉树 - 面试中常见的二叉树算法题
数据结构 - 二叉树 - 面试中常见的二叉树算法题数据结构是面试中必定考查的知识点,面试者需要掌握几种经典的数据结构:线性表(数组.链表).栈与队列.树(二叉树.二叉查找树.平衡二叉树.红黑树).图 ...
数据结构——二叉树的递归算法
二叉树的结构定义: typedef struct BiNode {TElemType data;struct BiNode *lchild;struct BiNode *rchild; }BiNode ...
数据结构——二叉树的层次遍历进阶
之前的一个博客数据结构--二叉树的层次遍历看完这个,可以简单实现下面的问题问题: 1.计算二叉树的最大宽度(二叉树的最大宽度是指二叉树所有层中结点个数的最大值. 2.用按层次顺序遍历二叉树的方法, ...
数据结构----二叉树叶子结点到根节点的高度计算
数据结构----二叉树叶子结点到根节点的高度计算代码: #include<stdio.h> #include<stdlib.h> typedef struct bstTree ...
数据结构二叉树的存储结构_线程二叉树| 数据结构
数据结构二叉树的存储结构线程二叉树 (Threaded Binary Tree ) A binary tree can be represented by using array represen ...
二叉树----数据结构:二叉树的三种遍历及习题
二叉树----数据结构:二叉树的三种遍历,利用递归算法. 关于二叉树的遍历,应用非常广泛,不单单是访问打印结点,还可以进行一系列的操作,如赋值.删除.查找.求二叉树的深度等等. 有递归和非递归两种算法 ...
数据结构-二叉树入门Go语言实现
数据结构-二叉树入门Go语言实现之前我们一直在谈的是一对一的线性结构,可现实中,还有很多一对多的情况需要处理,所以我们需要研究这种一对多的数据结构--"树",考虑它的各种特性,来 ...
数据结构——二叉树——特点及性质
数据结构--二叉树--特点及性质二叉树(Binary Tree)是n(n=0)个结点的有限集合,该集合或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交的.分别称为根结点的左子树和右子树的二 ...
数据结构——二叉树总结
数据结构-二叉树总结写在前面二叉树遍历递归实现先.中.后序遍历非递归遍历先序非递归中序非递归后序非递归层次遍历二叉树还原先序中序建树后序中序建树层次中序建树二叉树应用二叉查 ...

数据结构 -- 二叉树

数据结构 -- 二叉树相关推荐

最新文章

热门文章