【本文谢绝转载，原文来自http://990487026.blog.51cto.com】

树
数据结构与算法 3:二叉树,遍历,创建,释放,拷贝,求高度,面试,线索树二叉树的创建,关系建立二叉树的创建,关系建立2三叉链表法双亲链表:二叉树的遍历遍历的分析PPT计算二叉树中叶子节点的数目:使用全局变量计数器计算二叉树中叶子节点的数目:不使用全局变量计数器无论是先序遍历,中序遍历,后序遍历,求叶子的数字都不变;因为本质都是一样的,任何一个节点都会遍历3趟求二叉树的高度二叉树的拷贝:二叉树的遍历-中序遍历非递归算法`栈的非常经典案例二叉树的遍历-中序遍历非递归算法,STL代码实现利用C++ STL实现 顺序存储  泛型 API泛型编程的威力,指针搞起来二叉树的创建 #号方法面试题-画二叉树面试题-画二叉树2数据结构演示工具二叉树的非递归遍历,C语言基于栈API实现线索二叉树[很难]

二叉树的创建,关系建立

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//二叉链表#include <stdio.h>typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;//推导
//struct BiTNode
//{
//  int data;
//  struct BiTNode *lchild;
//  struct BiTNode *rchild;
//};
//typedef struct BiTNode  BiTNode;
//typedef struct BiTNode* BiTree;int main()
{//创建节点BiTNode t1;  t1.data = 1;BiTNode t2;    t1.data = 2;BiTNode t3;    t1.data = 3;BiTNode t4;    t1.data = 4;BiTNode t5;    t1.data = 5;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  && ./a.out
chunli@http://990487026.blog.51cto.com~/binary_tree$

2:二叉树的创建,关系建立

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//二叉链表
#include <stdio.h>
#include <stdlib.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;int main()
{BiTNode *p1;   p1 = (BiTNode*)malloc(sizeof(BiTNode));BiTNode *p2;    p2 = (BiTNode*)malloc(sizeof(BiTNode));BiTNode *p3;    p3 = (BiTNode*)malloc(sizeof(BiTNode));BiTNode *p4;    p4 = (BiTNode*)malloc(sizeof(BiTNode));BiTNode *p5;    p5 = (BiTNode*)malloc(sizeof(BiTNode));p1->data = 1;p2->data = 2;p3->data = 3;p4->data = 4;p5->data = 5;//建立关系p1->lchild = p2;p1->rchild = p3;p2->lchild = p4;p3->rchild = p5;return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  && ./a.out
chunli@http://990487026.blog.51cto.com~/binary_tree$

三叉链表法

//三叉链表
typedef struct TriTNode
{int data;//左右孩子指针struct TriTNode *lchild, *rchild;struct TriTNode *parent;
}TriTNode, *TriTree;

双亲链表:

//双亲链表
#define MAX_TREE_SIZE 100
typedef struct BPTNode
{int data;int parentPosition; //指向双亲的指针 //数组下标char LRTag; //左右孩子标志域
}BPTNode;typedef struct BPTree
{BPTNode nodes[100]; //因为节点之间是分散的，需要把节点存储到数组中int num_node;  //节点数目int root; //根结点的位置 //注意此域存储的是父亲节点在数组的下标
}BPTree;//用这个数据结构能表达出一颗树。。。能，怎么表达？不能why

程序:

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//二叉链表
#include <stdio.h>
#include <stdlib.h>
typedef struct BPNode
{int data;int parentPosition;char LRTag;
}BPTNode;typedef struct BPtree
{BPTNode nodes[100];int num_node;int root;
}BPTree;int main()
{BPTree tree;//节点属性数值//根节点tree.nodes[0].parentPosition = 10000;//定义10000为root节点,自己定//B节点tree.nodes[1].parentPosition = 0;//0号节点是老爹的tree.nodes[1].data = 'B';tree.nodes[1].LRTag  = 1;//C节点tree.nodes[2].parentPosition = 0;//0号节点是老爹的tree.nodes[3].data = 'C';tree.nodes[4].LRTag  = 2;return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  -Wall && ./a.out
main.c: In function ‘main’:
main.c:21:9: warning: variable ‘tree’ set but not used [-Wunused-but-set-variable]BPTree tree;^
chunli@http://990487026.blog.51cto.com~/binary_tree$

二叉树的遍历

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void pre_Order(BiTNode * root) //先序遍历
{if(root == NULL){return ;}printf("%d ",root->data);pre_Order(root->lchild);//遍历左子树pre_Order(root->rchild);//遍历右子树
}void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}void post_Order(BiTNode * root)    //后序遍历
{if(root == NULL){return ;}post_Order(root->lchild);//遍历左子树post_Order(root->rchild);//遍历右子树printf("%d ",root->data);
}
int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;//树的遍历pre_Order(&t1);        printf("    先序遍历\n");in_Order(&t1);       printf("    中序遍历\n");post_Order(&t1); printf("    后序遍历\n");return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c   && ./a.out
1 2 4 3 5     先序遍历
4 2 1 5 3     中序遍历
4 2 5 3 1     后序遍历
chunli@http://990487026.blog.51cto.com~/binary_tree$

计算二叉树中叶子节点的数目:使用全局变量计数器

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void pre_Order(BiTNode * root) //先序遍历
{if(root == NULL){return ;}printf("%d ",root->data);pre_Order(root->lchild);//遍历左子树pre_Order(root->rchild);//遍历右子树
}void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}void post_Order(BiTNode * root)    //后序遍历
{if(root == NULL){return ;}post_Order(root->lchild);//遍历左子树post_Order(root->rchild);//遍历右子树printf("%d ",root->data);
}int  count_leaf(BiTNode * root)    //中序遍历
{static num = 0;if(root){if(!root->rchild && !root->rchild)//当左右孩子都为空,就是叶子节点{num++;}if(root->rchild){count_leaf(root->lchild);//遍历左子树}if(root->rchild){count_leaf(root->rchild);//遍历右子树}}return num;
}
int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;//树的遍历pre_Order(&t1);        printf("    先序遍历\n");in_Order(&t1);       printf("    中序遍历\n");post_Order(&t1); printf("    后序遍历\n");int num = count_leaf(&t1);printf("叶子节点的个数 %d\n",num);return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c   && ./a.out
1 2 4 3 5     先序遍历
4 2 1 5 3     中序遍历
4 2 5 3 1     后序遍历
叶子节点的个数 2
chunli@http://990487026.blog.51cto.com~/binary_tree$

计算二叉树中叶子节点的数目:不使用全局变量计数器

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void pre_Order(BiTNode * root) //先序遍历
{if(root == NULL){return ;}printf("%d ",root->data);pre_Order(root->lchild);//遍历左子树pre_Order(root->rchild);//遍历右子树
}void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}void post_Order(BiTNode * root)    //后序遍历
{if(root == NULL){return ;}post_Order(root->lchild);//遍历左子树post_Order(root->rchild);//遍历右子树printf("%d ",root->data);
}void count_leaf(BiTNode * root,int * num)
{if(!root){return ;}if(!root->rchild && !root->rchild)//当左右孩子都为空{(*num)++;}if(root->lchild){count_leaf(root->lchild,num);//遍历左子树}if(root->rchild){count_leaf(root->rchild,num);//遍历右子树}return ;
}
int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;//树的遍历pre_Order(&t1);        printf("    先序遍历\n");in_Order(&t1);       printf("    中序遍历\n");post_Order(&t1); printf("    后序遍历\n");int num = 0;count_leaf(&t1,&num);   //解决多线程,资源竞争问题printf("叶子节点的个数 %d\n",num);return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  -Wall && ./a.out
1 2 4 3 5     先序遍历
4 2 1 5 3     中序遍历
4 2 5 3 1     后序遍历
叶子节点的个数 2
chunli@http://990487026.blog.51cto.com~/binary_tree$

无论是先序遍历,中序遍历,后序遍历,求叶子的数字都不变;因为本质都是一样的,任何一个节点都会遍历3趟

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void count_leaf(BiTNode * root,int * num)  //求叶子的个数
{if(!root){return ;}if(root->lchild){count_leaf(root->lchild,num);//遍历左子树}if(!root->rchild && !root->rchild)//当左右孩子都为空{(*num)++;}if(root->rchild){count_leaf(root->rchild,num);//遍历右子树}return ;
}
int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;int num = 0;count_leaf(&t1,&num);   //解决多线程,资源竞争问题printf("叶子节点的个数 %d\n",num);return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  -Wall && ./a.out
叶子节点的个数 2
chunli@http://990487026.blog.51cto.com~/binary_tree$

求二叉树的高度:

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;int tree_dept(BiTNode * root)
{int depth_left = 0;int depth_right = 0;if(!root){return 0;}depth_left = tree_dept(root->lchild);depth_right = tree_dept(root->rchild);return  1+(depth_left>depth_right ? depth_left:depth_right);
}
int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;BiTNode t6;    memset(&t6,0,sizeof(BiTNode));  t6.data = 6;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;t2.rchild = &t6;int depth = 0;depth = tree_dept(&t1); //解决多线程,资源竞争问题printf("树的高度 %d\n",depth);return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  -Wall &&  ./a.out
树的高度 3
chunli@http://990487026.blog.51cto.com~/binary_tree$

二叉树的拷贝:

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.c
//树的遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;int tree_dept(BiTNode * root)
{int depth_left = 0;int depth_right = 0;if(!root){return 0;}depth_left = tree_dept(root->lchild);depth_right = tree_dept(root->rchild);return  1+(depth_left>depth_right ? depth_left:depth_right);
}BiTNode* CopyTree(BiTNode *T)
{BiTNode *newNode = NULL;BiTNode *newLp = NULL;BiTNode *newRp = NULL;if(!T){return NULL;}if(T->lchild)    //拷贝左子树{newLp = CopyTree(T->lchild);}else   //如果左子树为NULL{newLp = NULL;}if(T->rchild)//拷贝右子树{newRp = CopyTree(T->rchild);}else{newRp = NULL;}//拷贝根节点newNode = (BiTNode *)malloc(sizeof(BiTNode));memset(newNode,0,sizeof(BiTNode));if(!newNode){return NULL;}newNode->lchild = newLp;newNode->rchild = newRp;newNode->data = T->data;   return newNode;
}void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;BiTNode t6;    memset(&t6,0,sizeof(BiTNode));  t6.data = 6;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;t2.rchild = &t6;int depth = 0;depth = tree_dept(&t1); //解决多线程,资源竞争问题printf("树的高度 %d\n",depth);printf("中序遍历t1\n");in_Order(&t1);printf("\n");printf("中序遍历拷贝树\n");BiTNode *root = CopyTree(&t1);in_Order(root);printf("\n");return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ gcc main.c  -Wall  && ./a.out
树的高度 3
中序遍历t1
4 2 6 1 5 3
中序遍历拷贝树
4 2 6 1 5 3
chunli@http://990487026.blog.51cto.com~/binary_tree$

二叉树的遍历-中序遍历非递归算法`栈的非常经典案例

中序 遍历的几种情况

分析1：什么时候访问根、什么时候访问左子树、什么访问右子树

       当左子树为空或者左子树已经访问完毕以后，再访问根

       访问完毕根以后，再访问右子树。

分析2：为什么是栈，而不是其他队列。

        先走到的后访问、后走到的先访问，显然是栈结构

分析3：结点所有路径情况

步骤1：

如果结点有左子树，该结点入栈；

如果结点没有左子树，访问该结点；

步骤2：

如果结点有右子树，重复步骤1；

如果结点没有右子树（结点访问完毕），回退，让栈顶元素出栈，访问栈顶元素，并访问右子树，重复步骤1

如果栈为空，表示遍历结束。

注意：入栈的结点表示，本身没有被访问过，同时右子树也没有被访问过。

分析4：有一个一直往左走入栈的操作

二叉树的遍历-中序遍历非递归算法,STL代码实现

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.cpp
//树的非递归遍历(中序遍历)
//  g++ main.cpp  -Wall  && ./a.out
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
using namespace std;typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}BiTNode* go_left(BiTNode *T,stack<BiTNode *> *s)//一直往左走,直到找到中序遍历的起点,注意C++的引用*s->&s
{if(!T){return NULL;}while(T->lchild)//如果T有左孩子,就入栈{//s.push(T);  如果上面参数带有引用(*s).push(T);T = T->lchild;}return T;//如果T没有左孩子,就返回
}void in_Order2(BiTNode * T)
{stack<BiTNode *> s;//使用C++ STL库,当然也可以使用自己的栈API//BiTNode* t = go_left(T,s);//如果go_left函数参数是引用可以直接这么写BiTNode* t = go_left(T,&s);while(t)//回到了起点{printf("%d ",t->data);//打印 if(t->rchild)//如果有右子树{//t = go_left(t->rchild,s);//回到右子树中序遍历的起点,如果go_left函数参数是引用可以直接这么写 t = go_left(t->rchild,&s);//回到右子树中序遍历的起点    }else if (!s.empty())//如果t没有右子树,根据栈指示,回退{t = s.top();s.pop();}else//如果t没有右子树,且栈为空{t = NULL;}}
}int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;BiTNode t6;    memset(&t6,0,sizeof(BiTNode));  t6.data = 6;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;t2.rchild = &t6;printf("递归中序遍历t1\n");in_Order(&t1);printf("\n");printf("非递归中序遍历t1\n");in_Order2(&t1);printf("\n");return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$ g++ main.cpp  -Wall  && ./a.out
递归中序遍历t1
4 2 6 1 5 3
非递归中序遍历t1
4 2 6 1 5 3
chunli@http://990487026.blog.51cto.com~/binary_tree$

利用C++ STL实现 顺序存储  泛型 API

项目文件

chunli@http://990487026.blog.51cto.com~/binary_tree$ tree
.
├── main.cpp
├── SeqList.cpp
└── SeqList.h0 directories, 3 files

main.c

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.cpp
//g++ main.cpp  -Wall  && ./a.out
//利用C++ STL实现 顺序存储  泛型 API#include <iostream>
#include <stdio.h>
#include <string.h>
#include "SeqList.cpp"
using namespace std;struct Teacher
{char name[64];int age;
};void fun()
{int i = 0;struct Teacher  tmp;struct Teacher  t1; t1.age = 31;struct Teacher  t2;    t2.age = 32;struct Teacher  t3;    t3.age = 33;SeqList<Teacher> list(10);//创建顺序表list.insert(t1,0);//头插法list.insert(t2,0);//头插法list.insert(t3,0);//头插法//遍历链表for(i=0;i<list.getLen();i++){list.get(i,tmp);cout <<tmp.age <<"  get\n";}//循环删除while(list.getLen() > 0){list.del(0,tmp);头删除cout <<tmp.age <<" del\n";}
}int main()
{fun();return 0;
}
chunli@http://990487026.blog.51cto.com~/binary_tree$

SeqList.cpp 

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat SeqList.cpp
#include <stdio.h>
#include "SeqList.h"
template <typename T>
SeqList<T>::SeqList(int Capacity)
{this->pArray = new T[Capacity];this->capacity = Capacity;this->len = 0;
}template <typename T>
SeqList<T>::~SeqList(void)
{delete [] this->pArray;this->pArray = NULL;this->capacity = 0;this->len = 0;}template <typename T>
int SeqList<T>::getLen()
{return this->len;
}template <typename T>
int SeqList<T>::getCapacity()
{return this->capacity;
}template <typename T>
int SeqList<T>::insert(T &t,int pos)
{int i = 0;if(pos <0){return -1;}for(i=this->len;i>pos;i--){pArray[i] = pArray[i-1];}pArray[i] = t;//STL元素保存时,通过复制机制实现的,你的类要可以复制才行this->len++;return 0;
}template <typename T>
int SeqList<T>::get(int pos,T &t)
{if(pos <0){return -1;}t = pArray[pos];return 0;
}template <typename T>
int SeqList<T>::del(int pos,T &t)
{int i = 0;t = pArray[pos];for(i=pos+1;i<this->len;i++){pArray[i-1] = pArray[i];}this->len--;return 0;
}chunli@http://990487026.blog.51cto.com~/binary_tree$

SeqList.h

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat SeqList.h
#pragma once
template <typename T>
class SeqList
{
public:SeqList(int Capacity);~SeqList(void);int getLen();int getCapacity();int insert(T &t,int pos);int get(int pos,T &t);int del(int pos,T &t);
private:int len;int capacity;T *pArray; };
chunli@http://990487026.blog.51cto.com~/binary_tree$

编译运行

chunli@http://990487026.blog.51cto.com~/binary_tree$ g++ main.cpp SeqList.cpp -Wall  && ./a.out
33  get
32  get
31  get
33 del
32 del
31 del
chunli@http://990487026.blog.51cto.com~/binary_tree$

泛型编程的威力,指针搞起来

主程序稍作修改,其他都不变:

chunli@http://990487026.blog.51cto.com~/binary_tree$ cat main.cpp
//g++ main.cpp  -Wall  && ./a.out
//利用C++ STL实现 顺序存储  泛型 API#include <iostream>
#include <stdio.h>
#include <string.h>
#include "SeqList.cpp"
using namespace std;struct Teacher
{char name[64];int age;
};void fun()
{int i = 0;struct Teacher  *tmp;struct Teacher  t1;    t1.age = 31;struct Teacher  t2;    t2.age = 32;struct Teacher  t3;    t3.age = 33;struct Teacher  *p1 = &t1;    struct Teacher  *p2 = &t2; struct Teacher  *p3 = &t3; SeqList<Teacher *> list(10);//创建顺序表list.insert(p1,0);//头插法list.insert(p2,0);//头插法list.insert(p3,0);//头插法//遍历链表for(i=0;i<list.getLen();i++){list.get(i,tmp);cout <<tmp->age <<"  get\n";}//循环删除while(list.getLen() > 0){list.del(0,tmp);头删除cout <<tmp->age <<" del\n";}
}int main()
{fun();return 0;
}编译运行:
chunli@http://990487026.blog.51cto.com~/binary_tree$ g++ main.cpp SeqList.cpp -Wall  && ./a.out
33  get
32  get
31  get
33 del
32 del
31 del
chunli@http://990487026.blog.51cto.com~/binary_tree$

二叉树的创建 #号方法

chunli@http://990487026.blog.51cto.com~/tree_up$ cat main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;void in_Order(BiTNode * root)  //先序遍历
{if(root == NULL){return ;}printf("%c",root->data);in_Order(root->lchild);//遍历左子树in_Order(root->rchild);//遍历右子树
}BiTNode* create_tree()//先序创建
{BiTNode *node = NULL;BiTNode *pleft  = NULL;BiTNode *pright = NULL;char c = getchar(); if(c == '#'){return NULL;}else{node = (BiTNode*)malloc(sizeof(BiTNode));memset(node,0,sizeof(BiTNode));node->data = c;pleft = create_tree();if(pleft != NULL){node->lchild = pleft;}else{node->lchild = NULL;}pright = create_tree();if(pleft != NULL){node->rchild = pright;}else{node->rchild = NULL;}}return node;
}void free_tree(BiTNode* T)
{if(!T){return ;}if(T->lchild){free_tree(T->lchild);T->lchild = NULL;}if(T->rchild){free_tree(T->rchild);T->rchild = NULL;}if(T){free(T);T = NULL;}
}int  main()
{BiTNode *p = create_tree();   in_Order(p);            printf("\n");free_tree(p);return 0;
}
chunli@http://990487026.blog.51cto.com~/tree_up$
chunli@http://990487026.blog.51cto.com~/tree_up$ gcc main.c  -Wall  -g && ./a.out
1234##45678########
123445678
chunli@http://990487026.blog.51cto.com~/tree_up$

面试题-画二叉树

面试题-画二叉树2

数据结构演示工具

二叉树的非递归遍历,C语言基于栈API实现

项目文件:

chunli@http://990487026.blog.51cto.com~/tree_2$ tree
.
├── linklist.c
├── linklist.h
├── linkstack.c
├── linkstack.h
└── main.c
0 directories, 5 files

源代码:

linklist.c 

chunli@http://990487026.blog.51cto.com~/tree_2$ cat linklist.c #include <stdio.h>
#include <stdlib.h>
#include <string.h>#include "linklist.h"typedef struct _tag_LinkList
{//这个句柄里面，需要保存所有节点信息。需要有一个起始点//就是带头节点的链表。。。LinkListNode header;int length;
}TLinkList;LinkList* LinkList_Create()
{TLinkList *ret = (TLinkList *)malloc(sizeof(TLinkList));if (ret == NULL){return NULL;}//memset(ret, 0, sizeof(TLinkList));ret->header.next = NULL;ret->length = 0;return ret;
}void LinkList_Destroy(LinkList* list)
{if (list == NULL){return ;}free(list);return ;
}void LinkList_Clear(LinkList* list)
{TLinkList *tList =NULL;if (list == NULL){return ;}tList = (TLinkList *)list;tList->length = 0;tList->header.next = NULL;return ;
}int LinkList_Length(LinkList* list)
{TLinkList *tList = (TLinkList *)list;if (tList == NULL){return -1;}return tList->length;
}int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{int i = 0;TLinkList *tList  = NULL;LinkListNode *current = NULL;tList = (TLinkList *)list;if (list==NULL || node==NULL) //modify by bombing 2014.06.26{return -1;}//准备环境让辅助指针变量 指向链表头节点current = &tList->header;for (i=0; i<pos &&(current->next!=NULL); i++){current = current->next;}//让node节点链接后续链表node->next = current->next ;//让前边的链表。链接nodecurrent->next = node;tList->length ++;  return 0;
}LinkListNode* LinkList_Get(LinkList* list, int pos)
{int i = 0;TLinkList *tList  = NULL;LinkListNode *current = NULL;LinkListNode *ret = NULL;tList = (TLinkList *)list;if (list == NULL || pos <0 ||pos>=tList->length){return NULL;}//准备环境让辅助指针变量 指向链表头节点current = &tList->header;for (i=0; i<pos &&(current->next!=NULL); i++){current = current->next;}ret = current->next;return ret;
}LinkListNode* LinkList_Delete(LinkList* list, int pos)
{int i = 0;TLinkList *tList  = NULL;LinkListNode *current = NULL;LinkListNode *ret = NULL;tList = (TLinkList *)list;if (list == NULL || pos <0 ||pos>=tList->length){return NULL;}//准备环境让辅助指针变量 指向链表头节点current = &tList->header;for (i=0; i<pos &&(current->next!=NULL); i++){current = current->next;}ret = current->next;//删除算法current->next =ret->next;tList->length--;return ret;
}
chunli@http://990487026.blog.51cto.com~/tree_2$

linklist.h

chunli@http://990487026.blog.51cto.com~/tree_2$ cat linklist.h
#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_typedef void LinkList;
/*
typedef struct _tag_LinkListNode LinkListNode;
struct _tag_LinkListNode
{LinkListNode* next;
};
*/
typedef struct _tag_LinkListNode
{struct _tag_LinkListNode* next;
}LinkListNode;LinkList* LinkList_Create();void LinkList_Destroy(LinkList* list);void LinkList_Clear(LinkList* list);int LinkList_Length(LinkList* list);int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);LinkListNode* LinkList_Get(LinkList* list, int pos);LinkListNode* LinkList_Delete(LinkList* list, int pos);#endifchunli@http://990487026.blog.51cto.com~/tree_2$

linkstack.c

chunli@http://990487026.blog.51cto.com~/tree_2$ cat linkstack.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linkstack.h"
#include "linklist.h"
typedef struct linkstack_node
{LinkListNode node;//让万象包含链表void *item; //栈的业务节点
}linkstack_node;LinkStack* LinkStack_Create()//创建一个栈,相当于创建一个线性表
{return LinkList_Create();
}void LinkStack_Destroy(LinkStack* stack)//销毁一个栈,相当于销毁一个线性表
{LinkStack_Clear(stack);LinkList_Destroy(stack);return ;
}void LinkStack_Clear(LinkStack* stack)//清空一个栈,相当于清空一个线性表
{//清空栈的时候,涉及到元素生命周期管理if(stack == NULL){return;}while(LinkStack_Size(stack) > 0){LinkStack_Pop(stack);//释放链表节点}return ;
}int LinkStack_Push(LinkStack* stack, void* item)//向线性表的头部插入元素
{linkstack_node *tmp = (linkstack_node*)malloc(sizeof(linkstack_node));if(tmp == NULL){return -1;}memset(tmp,0,sizeof(linkstack_node));tmp->item = item;int ret = LinkList_Insert(stack,(LinkListNode*)tmp,0);//把数据转换成链表的业务节点if(ret != 0){printf("数据插入失败!\n");if(tmp != NULL)//业务失败时,及时释放内存{free(tmp);}return -2;}return 0;
}void* LinkStack_Pop(LinkStack* stack)//相当于从线性表的头部弹出元素
{linkstack_node *tmp = NULL;//返回一个linkstack_nodetmp = (linkstack_node *)LinkList_Delete(stack,0);//把链表节点转成业务节点if(tmp == NULL){return NULL;}void *item = tmp->item;//还原业务节点free(tmp);        //干掉链表节点return item;
}void* LinkStack_Top(LinkStack* stack)//获取栈顶元素
{linkstack_node *tmp = (linkstack_node *)LinkList_Get(stack,0);if(tmp == NULL){return NULL;}return tmp->item;
}int LinkStack_Size(LinkStack* stack)//求栈的大小,相当于求线性表的额length
{return LinkList_Length(stack);
}chunli@http://990487026.blog.51cto.com~/tree_2$

linkstack.h

chunli@http://990487026.blog.51cto.com~/tree_2$ cat linkstack.h
#ifndef _MY_LINKSTACK_H_
#define _MY_LINKSTACK_H_typedef void LinkStack;LinkStack* LinkStack_Create();void LinkStack_Destroy(LinkStack* stack);void LinkStack_Clear(LinkStack* stack);int LinkStack_Push(LinkStack* stack, void* item);void* LinkStack_Pop(LinkStack* stack);void* LinkStack_Top(LinkStack* stack);int LinkStack_Size(LinkStack* stack);#endif //_MY_LINKSTACK_H_chunli@http://990487026.blog.51cto.com~/tree_2$ chunli@http://990487026.blog.51cto.com~/tree_2$ cat main.c
//非递归遍历二叉树,栈模式API实现#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"
#include "linklist.h"
#include "linkstack.h"typedef struct BiTNode
{int data;struct BiTNode *lchild;struct BiTNode *rchild;
}BiTNode,*BiTree;BiTNode * goleft(BiTNode *T,LinkStack *s)
{int ret = 0;if(T == NULL){return NULL;}while(T->lchild != NULL){ret = LinkStack_Push(s,(void*)T);//压栈if(ret != 0){printf("error in LinkStack_Push \n");}T = T->lchild;}return T;
}void tree_print(BiTNode *root)
{if(!root){return ;}LinkStack *stack = LinkStack_Create();//创建栈if(stack == NULL){printf("error in LinkStack_Create\n");}BiTNode *tmp_node = goleft(root,stack);while(tmp_node){printf("%d ",tmp_node->data);if(tmp_node->rchild != NULL){tmp_node = goleft(tmp_node->rchild,stack);}else if(LinkStack_Size(stack)>0){tmp_node = (BiTNode *)LinkStack_Top(stack);LinkStack_Pop(stack);}else{tmp_node = NULL;}}printf("\n");
}void in_Order(BiTNode * root)  //中序遍历
{if(root == NULL){return ;}in_Order(root->lchild);//遍历左子树printf("%d ",root->data);in_Order(root->rchild);//遍历右子树
}int main()
{//创建节点BiTNode t1;  memset(&t1,0,sizeof(BiTNode));  t1.data = 1;BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;BiTNode t6;    memset(&t6,0,sizeof(BiTNode));  t6.data = 6;//建立关系t1.lchild = &t2;t1.rchild = &t3;t2.lchild = &t4;t3.lchild = &t5;t2.rchild = &t6;printf("  递归遍历"); in_Order(&t1);  printf("\n");printf("非递归遍历");   tree_print(&t1);return 0;
}
chunli@http://990487026.blog.51cto.com~/tree_2$

编译运行:

chunli@http://990487026.blog.51cto.com~/tree_2$ gcc main.c linkstack.c linklist.c  -Wall -g && ./a.out 递归遍历4 2 6 1 5 3
非递归遍历4 2 6 1 5 3
chunli@http://990487026.blog.51cto.com~/tree_2$

线索二叉树[很难]

chunli@http://990487026.blog.51cto.com~/tree_3$ cat main.c
#include "string.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"  #define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0#define MAXSIZE 100 /* 存储空间初始分配量 */typedef int Status;   /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef char TElemType;
typedef enum {Link,Thread} PointerTag;  /* Link==0表示指向左右孩子指针, *//* Thread==1表示指向前驱或后继的线索 */
typedef  struct BiThrNode   /* 二叉线索存储结点结构 */
{TElemType data;    /* 结点数据 */struct BiThrNode *lchild, *rchild;    /* 左右孩子指针 */PointerTag LTag;PointerTag RTag;        /* 左右标志 */
} BiThrNode, *BiThrTree;TElemType Nil='#'; /* 字符型以空格符为空 */Status visit(TElemType e)
{printf("%c ",e);return OK;
}/* 按前序输入二叉线索树中结点的值,构造二叉线索树T */
/* 0(整型)/空格(字符型)表示空结点 */
Status CreateBiThrTree(BiThrTree *T)
{ TElemType h;scanf("%c",&h);if(h==Nil)*T=NULL;else{*T=(BiThrTree)malloc(sizeof(BiThrNode));if(!*T)exit(OVERFLOW);(*T)->data=h; /* 生成根结点(前序) */CreateBiThrTree(&(*T)->lchild); /* 递归构造左子树 */if((*T)->lchild) /* 有左孩子 */(*T)->LTag=Link;CreateBiThrTree(&(*T)->rchild); /* 递归构造右子树 */if((*T)->rchild) /* 有右孩子 */(*T)->RTag=Link;}return OK;
}BiThrTree pre; /* 全局变量,始终指向刚刚访问过的结点 */
/* 中序遍历进行中序线索化 */
void InThreading(BiThrTree p)
{ if(p){InThreading(p->lchild); /* 递归左子树线索化 */if(!p->lchild) /* 没有左孩子 */{p->LTag=Thread; /* 前驱线索 */           p->lchild=pre; /* 左孩子指针指向前驱 */}if(!pre->rchild) /* 前驱没有右孩子 */{pre->RTag=Thread; /* 后继线索 */pre->rchild=p; /* 前驱右孩子指针指向后继(当前结点p) */}pre=p; /* 保持pre指向p的前驱 */InThreading(p->rchild); /* 递归右子树线索化 */}
}/* 中序遍历二叉树T,并将其中序线索化,Thrt指向头结点 */
Status InOrderThreading(BiThrTree *Thrt,BiThrTree T)
{ *Thrt=(BiThrTree)malloc(sizeof(BiThrNode));if(!*Thrt)exit(OVERFLOW);(*Thrt)->LTag=Link; /* 建头结点 */(*Thrt)->RTag=Thread;(*Thrt)->rchild=(*Thrt); /* 右指针回指 */if(!T) /* 若二叉树空,则左指针回指 */(*Thrt)->lchild=*Thrt;else{(*Thrt)->lchild=T;pre=(*Thrt);InThreading(T); /* 中序遍历进行中序线索化 */pre->rchild=*Thrt;pre->RTag=Thread; /* 最后一个结点线索化 */(*Thrt)->rchild=pre;}return OK;
}/* 中序遍历二叉线索树T(头结点)的非递归算法 */
Status InOrderTraverse_Thr(BiThrTree T)
{ BiThrTree p;p=T->lchild; /* p指向根结点 */while(p!=T){ /* 空树或遍历结束时,p==T */while(p->LTag==Link)p=p->lchild;if(!visit(p->data)) /* 访问其左子树为空的结点 */return ERROR;while(p->RTag==Thread&&p->rchild!=T){p=p->rchild;visit(p->data); /* 访问后继结点 */}p=p->rchild;}return OK;
}int main()
{BiThrTree H,T;printf("请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')\n");CreateBiThrTree(&T); /* 按前序产生二叉树 */InOrderThreading(&H,T); /* 中序遍历,并中序线索化二叉树 */printf("中序遍历(输出)二叉线索树:\n");InOrderTraverse_Thr(H); /* 中序遍历(输出)二叉线索树 */printf("\n");return 0;
}chunli@http://990487026.blog.51cto.com~/tree_3$ gcc main.c -Wall && ./a.out
请按前序输入二叉树(如:'ABDH##I##EJ###CF##G##')
ABDH##I##EJ###CF##G##
中序遍历(输出)二叉线索树:
H D I B J E A F C G
chunli@http://990487026.blog.51cto.com~/tree_3$

霍夫曼树(最优二叉树)

【本文谢绝转载，原文来自http://990487026.blog.51cto.com】