1 #一个节点的数据类型，包含左子孩子节点指针 右孩子节点指针 和值
  2 class Node(object):
  3     def __init__(self , item):
  4         self.left = None    #指向左子节点
  5         self.right = None   #指向右子节点
  6         self.item = item    #保存值
  7
  8 #树的类
  9 class Tree(object):
 10     def __init__(self):
 11         self.root = None #保存树根所在位置
 12     #添加节点方法，按照层次由低到高，优先靠左的思想添加
 13     def add(self , item ):
 14         node = Node(item) #首先创建一个节点
 15         #如果树还没有树根
 16         if self.root is None:
 17             self.root = node
 18         else :
 19             # 这里需要用到广度优先遍历的思想来找第一个可以添加节点的位置
 20             # 开一个队列用于广度优先搜索 先把树根放进去
 21             queue = [ self.root ]
 22             #循环操作：
 23             # 出队一个节点，如果它没有左海子，为它添加左孩子 退出  否则 左孩子入队列
 24             #            如果他没有右孩子，为它添加右孩子 退出  否则 右孩子如队列
 25             #如果队列里面有元素我们就一直操作。队列空了就退出来（这个只是保险条件，一般队列还没空就找到空位创建节点然后退出了）
 26             while queue :
 27                 #取出队节点
 28                 temp = queue.pop(0)
 29                 #如果没有左孩子 我们 添加左孩子后退出
 30                 if temp.left is None:
 31                     temp.left = node
 32                     return
 33                 #如果有左孩子 我们把左孩子入队列
 34                 else:
 35                     queue.append(temp.left)
 36
 37                 #如果没有右孩子 我们添加右孩子 然后退出
 38                 if temp.right is None:
 39                     temp.right = node
 40                     return
 41                 # 如果有右孩子 我们把右孩子入队列
 42                 else :
 43                     queue.append( temp.right )
 44     # 广度优先遍历
 45     def breadth_travel(self):
 46         #开启一个队列 把树根放进去
 47         queue=[ self.root ]
 48         #循环操作：从对头取出节点，把值输出后 把他们的左孩子右孩子添加到队列里，一直到队列空了，说明遍历结束
 49         # 只要队列不是空的 我们就一直遍历
 50         while queue :
 51             #从队列头取出一个元素
 52             temp = queue.pop(0)
 53             #输出节点的值
 54             print( temp.item,end=" " )
 55             #如果节点有左孩子 就把左孩子追加到队列
 56             if temp.left is not None:
 57                 queue.append( temp.left )
 58             #如果节点有右孩子 就把右孩子追加到队列
 59             if temp.right is not None:
 60                 queue.append(temp.right)
 61         #最后来一个换行
 62         print()
 63     #先序遍历  按照 根 左 右 进行遍历
 64     # 把当前子树的树根传进去做参数
 65     def preOder(self , node):
 66         #如果传进来的十个None，说明上一个节点 没有左孩子或者右孩子 传进来一个None 那就不遍历这个节点
 67         if not node:
 68             return
 69         #先把根的值输出来
 70         print(node.item,end=" ")
 71         #然后对左孩子进行遍历
 72         self.preOder( node.left )
 73         #然后对右孩子遍历
 74         self.preOder( node.right )
 75     #中序遍历 按照 左 根 右 的顺序进行遍历
 76     # 传入当前要遍历的子树的根
 77     def inOrder(self, node):
 78         #当传入的子树是None 说明上一个节点没有这个子树 传进来了None 此时不用遍历它了
 79         if not node:
 80             return None
 81         #先对左子树进行遍历
 82         self.inOrder( node.left )
 83         #再输出自己的数值
 84         print( node.item,end=" " )
 85         #最后对右子树进行遍历
 86         self.inOrder(node.right)
 87     #后序遍历 按照 左 右 根 的顺序进行遍历
 88     # 把当前子树的树根传进去做参数
 89     def postOrder(self,node):
 90         #如果传进来一个None 说明上一个节点没有这可子树，这时候不用遍历
 91         if not node :
 92             return
 93         #先对左子树进行遍历
 94         self.postOrder(node.left)
 95         #再对右子树进行遍历
 96         self.postOrder(node.right)
 97         #最后输出自己的值
 98         print( node.item,end=" " )
 99
100     #我们再封装一下，在外部调用自己的三个深度优先遍历可以不传入自己的根
101     def preOrder_travel(self):
102         self.preOder(self.root)
103     def inOrder_travel(self):
104         self.inOrder( self.root )
105     def postOrder_travel(self):
106         self.postOrder(self.root)
107
108
109
110 if __name__ == '__main__':
111     tree = Tree()
112     tree.add(1)
113     tree.add(2)
114     tree.add(3)
115     tree.add(4)
116     tree.add(5)
117     tree.add(6)
118     tree.add(7)
119     tree.breadth_travel() # 1 2 3 4 5 6 7
120     tree.preOrder_travel() #1 2 4 5 3 6 7
121     print()# 回车换行
122     tree.inOrder_travel() #4 2 5 1 6 3 7
123     print()# 回车换行
124     tree.postOrder_travel() #4 5 2 6 7 3 1

  1 import java.util.LinkedList;
  2 import java.util.Queue;
  3 //二叉树的实现
  4 class Main {
  5     public static void main(String[] args) {
  6         Tree tree = new Tree();
  7         tree.append(1);
  8         tree.append(2);
  9         tree.append(3);
 10         tree.append(4);
 11         tree.append(5);
 12         tree.append(6);
 13         tree.append(7);
 14         tree.breadth();
 15         tree.preOrder_travel();
 16         tree.inOrder_travel();
 17         tree.postOrder_travel();
 18     }
 19
 20 }
 21 //一棵树的叶子节点
 22 class Node{
 23     int value;
 24     Node left = null;
 25     Node right = null;
 26     public Node(int value){
 27         this.value = value;
 28     }
 29 }
 30
 31 public class Tree{
 32     private Node root = null;
 33     public Node getRoot(){
 34         return this.root;
 35     }
 36     //添加叶子节点方法
 37     public void append( int value ){
 38         Node node = new Node(value);
 39         //如果根节点是空的，就添加根节点
 40         if( this.root == null ){
 41             this.root = node;
 42         //根节点不是空的 按层次遍历 找到最浅层次最靠左的位置把节点放进去
 43         }else{
 44             Queue<Node> queue = new LinkedList<Node>();
 45             queue.offer(this.root);
 46             while( ! queue.isEmpty() ){
 47                 Node cur = queue.poll();
 48                 if( cur.left == null ){
 49                     cur.left = node;
 50                     break;
 51                 }else{
 52                     queue.add(cur.left);
 53                 }
 54                 if( cur.right == null ){
 55                     cur.right = node;
 56                     break;
 57                 }else{
 58                     queue.add(cur.right);
 59                 }
 60             }
 61         }
 62     }
 63     //广度优先遍历
 64     public void breadth( ){
 65         Queue<Node> queue = new LinkedList<Node>();
 66         queue.add(this.root);
 67         while( !queue.isEmpty() ){
 68             Node cur = queue.poll();
 69             System.out.print(cur.value+" ");
 70             if(cur.left!=null){
 71                 queue.add(cur.left);
 72             }
 73             if(cur.right!= null){
 74                 queue.add(cur.right);
 75             }
 76         }
 77         System.out.println();
 78     }
 79     //深度优先遍历
 80     //先序遍历
 81     public void preOrder_travel(){
 82         preOrder(this.root);
 83         System.out.println();
 84     }
 85     private void preOrder(Node root){
 86         if(root == null){
 87             return;
 88         }
 89         System.out.print( root.value + " " );
 90         preOrder(root.left);
 91         preOrder(root.right);
 92     }
 93     //中序遍历
 94     public void inOrder_travel(){
 95         inOrder(this.root);
 96         System.out.println();
 97     }
 98     private void inOrder(Node root){
 99         if(root == null){
100             return;
101         }
102         inOrder(root.left);
103         System.out.print( root.value + " " );
104         inOrder(root.right);
105     }
106     //后序遍历
107     public void postOrder_travel(){
108         postOrder(this.root);
109         System.out.println();
110     }
111     private void postOrder(Node root){
112         if(root == null){
113             return;
114         }
115         postOrder(root.left);
116         postOrder(root.right);
117         System.out.print( root.value + " " );
118     }
119 }