【code】java树的实现

树的父节点存储实现

 

Java代码  收藏代码
  1. import java.util.*;  
  2. public class TreeParent<E>  
  3. {  
  4.     public static class Node<T>  
  5.     {  
  6.         T data;  
  7.         //记录其父节点的位置  
  8.         int parent;  
  9.         public Node()  
  10.         {  
  11.         }  
  12.         public Node(T data)  
  13.         {  
  14.             this.data = data;  
  15.         }  
  16.         public Node(T data , int parent)  
  17.         {  
  18.             this.data = data;  
  19.             this.parent = parent;  
  20.         }  
  21.         public String toString()  
  22.         {  
  23.             return "TreeParent$Node[data=" + data + ", parent="  
  24.                 + parent + "]";  
  25.         }  
  26.     }  
  27.     private final int DEFAULT_TREE_SIZE = 100;  
  28.     private int treeSize = 0;  
  29.     //使用一个Node[]数组来记录该树里的所有节点  
  30.     private Node<E>[] nodes;  
  31.     //记录节点数  
  32.     private int nodeNums;  
  33.     //以指定根节点创建树  
  34.     public TreeParent(E data)  
  35.     {  
  36.         treeSize = DEFAULT_TREE_SIZE;  
  37.         nodes = new Node[treeSize];  
  38.         nodes[0] = new Node<E>(data , -1);  
  39.         nodeNums++;  
  40.     }  
  41.     //以指定根节点、指定treeSize创建树  
  42.     public TreeParent(E data ,int treeSize)  
  43.     {  
  44.         this.treeSize = treeSize;  
  45.         nodes = new Node[treeSize];  
  46.         nodes[0] = new Node<E>(data , -1);  
  47.         nodeNums++;  
  48.     }  
  49.     //为指定节点添加子节点  
  50.     public void addNode(E data , Node parent)  
  51.     {  
  52.         for (int i = 0 ; i < treeSize ; i++)  
  53.         {  
  54.             //找到数组中第一个为null的元素，该元素保存新节点  
  55.             if (nodes[i] == null)  
  56.             {  
  57.                 //创建新节点，并用指定的数组元素保存它  
  58.                 nodes[i] = new Node(data , pos(parent));;  
  59.                 nodeNums++;  
  60.                 return;  
  61.             }  
  62.         }  
  63.         throw new RuntimeException("该树已满，无法添加新节点");  
  64.     }  
  65.     //判断树是否为空。  
  66.     public boolean empty()  
  67.     {  
  68.         //根节点是否为null  
  69.         return nodes[0] == null;  
  70.     }  
  71.     //返回根节点  
  72.     public Node<E> root()  
  73.     {  
  74.         //返回根节点  
  75.         return nodes[0];  
  76.     }  
  77.     //返回指定节点（非根节点）的父节点。  
  78.     public Node<E> parent(Node node)  
  79.     {  
  80.         //每个节点的parent记录了其父节点的位置  
  81.         return nodes[node.parent];  
  82.     }  
  83.     //返回指定节点（非叶子节点）的所有子节点。  
  84.     public List<Node<E>> children(Node parent)  
  85.     {  
  86.         List<Node<E>> list = new ArrayList<Node<E>>();  
  87.         for (int i = 0 ; i < treeSize  ; i++)  
  88.         {  
  89.             //如果当前节点的父节点的位置等于parent节点的位置  
  90.             if (nodes[i] != null &&  
  91.                 nodes[i].parent == pos(parent))  
  92.             {  
  93.                 list.add(nodes[i]);  
  94.             }  
  95.         }  
  96.         return list;  
  97.     }  
  98.     //返回该树的深度。  
  99.     public int deep()  
  100.     {  
  101.         //用于记录节点的最大深度  
  102.         int max = 0;  
  103.         for(int i = 0 ; i < treeSize && nodes[i] != null  
  104.             ; i++)  
  105.         {  
  106.             //初始化本节点的深度  
  107.             int def = 1;  
  108.             //m记录当前节点的父节点的位置  
  109.             int m = nodes[i].parent;  
  110.             //如果其父节点存在  
  111.             while(m != -1 && nodes[m] != null)  
  112.             {  
  113.                 //向上继续搜索父节点  
  114.                 m = nodes[m].parent;  
  115.                 def++;  
  116.             }  
  117.             if(max < def)  
  118.             {  
  119.                 max = def;  
  120.             }  
  121.         }  
  122.         //返回最大深度  
  123.         return max;   
  124.     }  
  125.     //返回包含指定值的节点。  
  126.     public int pos(Node node)  
  127.     {  
  128.         for (int i = 0 ; i < treeSize ; i++)  
  129.         {  
  130.             //找到指定节点  
  131.             if (nodes[i] == node)  
  132.             {  
  133.                 return i;  
  134.             }  
  135.         }  
  136.         return -1;  
  137.     }  
  138.       
  139.     public static void main(String[] args)   
  140.     {  
  141.         TreeParent<String> tp = new TreeParent<String>("root");  
  142.         TreeParent.Node root = tp.root();  
  143.         System.out.println(root);  
  144.         tp.addNode("节点1" , root);  
  145.         System.out.println("此树的深度:" + tp.deep());  
  146.         tp.addNode("节点2" , root);  
  147.         //获取根节点的所有子节点  
  148.         List<TreeParent.Node<String>> nodes = tp.children(root);  
  149.         System.out.println("根节点的第一个子节点：" + nodes.get(0));  
  150.         //为根节点的第一个子节点新增一个子节点  
  151.         tp.addNode("节点3" , nodes.get(0));  
  152.         System.out.println("此树的深度:" + tp.deep());  
  153.     }  
  154. }  

 

树的子节点链表实现

 

Java代码  收藏代码
  1. import java.util.*;  
  2. public class TreeChild<E>  
  3. {  
  4.     private static class SonNode  
  5.     {  
  6.         //记录当前节点的位置  
  7.         private int pos;  
  8.         private SonNode next;  
  9.         public SonNode(int pos , SonNode next)  
  10.         {  
  11.             this.pos = pos;  
  12.             this.next = next;  
  13.         }  
  14.     }  
  15.     public static class Node<T>  
  16.     {  
  17.         T data;  
  18.         //记录第一个子节点  
  19.         SonNode first;  
  20.         public Node(T data)  
  21.         {  
  22.             this.data = data;  
  23.             this.first = null;  
  24.         }  
  25.         public String toString()  
  26.         {  
  27.             if (first != null)  
  28.             {  
  29.                 return "TreeChild$Node[data=" + data + ", first="  
  30.                     + first.pos + "]";  
  31.             }  
  32.             else  
  33.             {  
  34.                 return "TreeChild$Node[data=" + data + ", first=-1]";  
  35.             }  
  36.         }  
  37.     }  
  38.     private final int DEFAULT_TREE_SIZE = 100;  
  39.     private int treeSize = 0;  
  40.     //使用一个Node[]数组来记录该树里的所有节点  
  41.     private Node<E>[] nodes;  
  42.     //记录节点数  
  43.     private int nodeNums;  
  44.     //以指定根节点创建树  
  45.     public TreeChild(E data)  
  46.     {  
  47.         treeSize = DEFAULT_TREE_SIZE;  
  48.         nodes = new Node[treeSize];  
  49.         nodes[0] = new Node<E>(data);  
  50.         nodeNums++;  
  51.     }  
  52.     //以指定根节点、指定treeSize创建树  
  53.     public TreeChild(E data ,int treeSize)  
  54.     {  
  55.         this.treeSize = treeSize;  
  56.         nodes = new Node[treeSize];  
  57.         nodes[0] = new Node<E>(data);  
  58.         nodeNums++;  
  59.     }  
  60.     //为指定节点添加子节点  
  61.     public void addNode(E data , Node parent)  
  62.     {  
  63.         for (int i = 0 ; i < treeSize ; i++)  
  64.         {  
  65.             //找到数组中第一个为null的元素，该元素保存新节点  
  66.             if (nodes[i] == null)  
  67.             {  
  68.                 //创建新节点，并用指定数组元素来保存它  
  69.                 nodes[i] = new Node(data);  
  70.                 if (parent.first == null)  
  71.                 {  
  72.                     parent.first = new SonNode(i , null);  
  73.                 }  
  74.                 else  
  75.                 {  
  76.                     SonNode next = parent.first;  
  77.                     while (next.next != null)  
  78.                     {  
  79.                         next = next.next;  
  80.                     }  
  81.                     next.next = new SonNode(i , null);  
  82.                 }  
  83.                 nodeNums++;  
  84.                 return;  
  85.             }  
  86.         }  
  87.         throw new RuntimeException("该树已满，无法添加新节点");  
  88.     }  
  89.     //判断树是否为空。  
  90.     public boolean empty()  
  91.     {  
  92.         //根节点是否为null  
  93.         return nodes[0] == null;  
  94.     }  
  95.     //返回根节点  
  96.     public Node<E> root()  
  97.     {  
  98.         //返回根节点  
  99.         return nodes[0];  
  100.     }  
  101.     //返回指定节点（非叶子节点）的所有子节点。  
  102.     public List<Node<E>> children(Node parent)  
  103.     {  
  104.         List<Node<E>> list = new ArrayList<Node<E>>();  
  105.         //获取parent节点的第一个子节点  
  106.         SonNode next = parent.first;  
  107.         //沿着孩子链不断搜索下一个孩子节点  
  108.         while (next != null)  
  109.         {  
  110.             //添加孩子链中的节点  
  111.             list.add(nodes[next.pos]);  
  112.             next = next.next;  
  113.         }  
  114.         return list;  
  115.     }  
  116.     //返回指定节点（非叶子节点）的第index个子节点。  
  117.     public Node<E> child(Node parent , int index)  
  118.     {  
  119.         //获取parent节点的第一个子节点  
  120.         SonNode next = parent.first;  
  121.         //沿着孩子链不断搜索下一个孩子节点  
  122.         for (int i = 0 ; next != null  ; i++)  
  123.         {  
  124.             if (index == i)  
  125.             {  
  126.                 return nodes[next.pos];  
  127.             }  
  128.             next = next.next;  
  129.         }  
  130.         return null;  
  131.     }  
  132.     //返回该树的深度。  
  133.     public int deep()  
  134.     {  
  135.         //获取该树的深度  
  136.         return deep(root());   
  137.     }  
  138.     //这是一个递归方法：每棵子树的深度为其所有子树的最大深度 + 1  
  139.     private int deep(Node node)  
  140.     {  
  141.         if (node.first == null)  
  142.         {  
  143.             return 1;  
  144.         }  
  145.         else  
  146.         {  
  147.             //记录其所有子树的最大深度  
  148.             int max = 0;  
  149.             SonNode next = node.first;  
  150.             //沿着孩子链不断搜索下一个孩子节点  
  151.             while (next != null)  
  152.             {  
  153.                 //获取以其子节点为根的子树的深度  
  154.                 int tmp = deep(nodes[next.pos]);  
  155.                 if (tmp > max)  
  156.                 {  
  157.                     max = tmp;  
  158.                 }  
  159.                 next = next.next;  
  160.             }  
  161.             //最后返回其所有子树的最大深度 + 1  
  162.             return max + 1;  
  163.         }  
  164.     }  
  165.     //返回包含指定值的节点。  
  166.     public int pos(Node node)  
  167.     {  
  168.         for (int i = 0 ; i < treeSize ; i++)  
  169.         {  
  170.             //找到指定节点  
  171.             if (nodes[i] == node)  
  172.             {  
  173.                 return i;  
  174.             }  
  175.         }  
  176.         return -1;  
  177.     }  
  178.       
  179.     public static void main(String[] args)   
  180.     {  
  181.         TreeChild<String> tp = new TreeChild<String>("root");  
  182.         TreeChild.Node root = tp.root();  
  183.         System.out.println("根节点：" + root);  
  184.         tp.addNode("节点1" , root);  
  185.         tp.addNode("节点2" , root);  
  186.         tp.addNode("节点3" , root);  
  187.         System.out.println("添加子节点后的根节点：" + root);  
  188.         System.out.println("此树的深度:" + tp.deep());  
  189.         //获取根节点的所有子节点  
  190.         List<TreeChild.Node<String>> nodes = tp.children(root);  
  191.         System.out.println("根节点的第一个子节点：" + nodes.get(0));  
  192.         //为根节点的第一个子节点新增一个子节点  
  193.         tp.addNode("节点4" , nodes.get(0));  
  194.         System.out.println("根节点的第一个子节点：" + nodes.get(0));  
  195.         System.out.println("此树的深度:" + tp.deep());  
  196.     }  
  197. }  
posted @ 2017-05-29 11:46  天涯海角路  阅读(274)  评论(0)    收藏  举报