算法——樹

樹：

定義：

樹是n個節點的有限集。n=0時稱為空樹。在任意一顆非空樹中：（1）有且僅有一個特定的稱為根（Root）的結點，（2）當n>1時，其余結點可分為m(m>0)個互不相交的有限集T1、T2、T3、……Tm，其中每一個集合本身又是一顆樹，並稱為根的子樹，如下圖

 

 

 

概念：

• 樹的結點包含一個數據元素及若干指向其子樹的分支。結點擁有的子樹數稱為結點的度（Degree）。度為0的結點稱為葉結點（Leaf） 或終端結點；度不為0的結點稱為非終端結點或分支結點。除根結點之外，分支結點也稱為內部結點。樹的度是樹內各結點的度的最大值。因為這棵樹結點的度的最大值是結點D的度為3，所以樹的度也為3，如下圖：

 

 

•  結點的子樹的根稱為該結點的孩子，相應的，該結點稱為孩子的雙親。同一個雙親的孩子之間互稱兄弟，如下圖：

 

 

• 結點的層次從根開始，根為第一層，根的孩子為第二層。雙親在同一層的結點互為堂兄弟，樹中結點的最大層次稱為樹的深度或者高度，如下圖：

 

 

 

樹的父節點表示法：

import java.util.ArrayList;
import java.util.List;


/**
 *   樹的父節點表示法
 * @author wydream
 *
 */

public class TreeParent<E> {
    
    //定義一個樹類
    public static class Node<T>{
        T data;//保存數據
        int parent;//保存父節點的位置
        public Node(){
            
        }
        
        public Node(T data) {
            this.data=data;
        }
        
        //指定根節點
        public Node(T data,int parent) {
            this.data=data;
            this.parent=parent;
        }
        
        public String toString() {
            return "TreeParent$Node[data=" + data + ", parent=" + parent + "]";
        }
    }
    
    private final int DEFAULT_TREE_SIZE=100;//樹的默認大小
    private int treeSize=0;//樹的實際大小
    //使用一個node數組來記錄該樹里的所有節點
    private Node<E>[] nodes;
    //記錄樹的節點數
    private int nodeNums;
    
    //以指定節點創建樹
    public TreeParent(E data) {
        treeSize=DEFAULT_TREE_SIZE;
        nodes=new Node[treeSize];
        nodes[0]=new Node<E>(data,-1);
        nodeNums++;
    }
    
    //以指定根節點、指定treeSize創建樹
    public TreeParent(E data,int treeSize){
        this.treeSize=treeSize;
        nodes=new Node[treeSize];
        nodes[0]=new Node<E>(data,-1);
        nodeNums++;
    }
    
    //為指定節點添加子節點
    public void addNode(E data,Node<E> parent) {
        for(int i=0;i<treeSize;i++) {
            // 找到數組中第一個為null的元素，該元素保存新節點
            if(nodes[i]==null) {
                nodes[i]=new Node<E>(data,pos(parent));
                nodeNums++;
                return;
            }
            // 創建新節點，並用指定的數組元素保存它
        }
        throw new RuntimeException("該樹已滿");
    }
    
    // 判斷樹是否為空
    public boolean isEmpty() {
        return nodes[0]==null;
    }
    
    // 返回根節點
    public Node<E> root() {
        return nodes[0];
    }
    
    // 返回指定節點（非根結點）的父節點
    public Node<E> parent(Node<E> node) {
        return nodes[node.parent];
    }
    
    // 返回指定節點（非葉子節點）的所有子節點
    public List<Node<E>> children(Node<E> parent){
        List<Node<E>> list=new ArrayList<Node<E>>();
        for(int i=0;i<treeSize;i++) {
            // 如果當前節點的父節點的位置等於parent節點的位置
            if(nodes[i]!=null&&nodes[i].parent==pos(parent)) {
                list.add(nodes[i]);
            }
        }
        return list;
    }
    
    // 返回該樹的深度
    public int deep() {
        //用於記錄節點的最大深度
        int max=0;
        for(int i=0;i<treeSize&&nodes[i]!=null;i++) {
            //初始化本節點的深度
            int def=1;
            //m 記錄當前節點的父節點的位置
            int m=nodes[i].parent;
            //如果其父節點存在
            while(m!=-1&&nodes[m]!=null) {
                //向上繼續搜索父節點
                m=nodes[m].parent;
                def++;
            }
            if(max<def) {
                max=def;
            }
        }
        return max;
    }
    
    //返回包含指定值的節點
    public int pos(Node<E> node) {
        for(int i=0;i<treeSize;i++) {
            //找到指定節點
            if(nodes[i]==node) {
                return i;
            }
        }
        return -1;
    }
    
    
    //測試
    public static void main(String[] args) {
        TreeParent<String> tp=new TreeParent<String>("root");
        TreeParent.Node root=tp.root();
        System.out.println(root);
        tp.addNode("節點1", root);
        System.out.println("此樹的深度"+tp.deep());
        tp.addNode("節點2",root);
        //獲取根節點的所有子節點
        List<TreeParent.Node<String>> nodes=tp.children(root);
        System.out.println("根節點的第一個子節點為："+nodes.get(0));
        // 為根節點的第一個子節點新增一個子節點
        tp.addNode("節點3", nodes.get(0));
        System.out.println("此樹的深度：" + tp.deep());
        
    }
}

 

程序運行結果：

TreeParent$Node[data=root, parent=-1]
此樹的深度2
根節點的第一個子節點為：TreeParent$Node[data=節點1, parent=0]
此樹的深度：3

　　

樹的子節點表示法：

import java.util.ArrayList;
import java.util.List;

/**
 *   樹的子節點表示法
 * @author wydream
 *
 */


public class TreeChild<E> {

    private static class SonNode{
        //記錄當前節點的位置
        private int pos;
        private SonNode next;
        
        public SonNode(int pos,SonNode next) {
            this.pos=pos;
            this.next=next;
        }
        
    }
    
    public static class Node<T>{
        T data;
        SonNode first;//記錄第一個子節點
        
        public Node(T data) {
            this.data=data;
            this.first=null;
        }
        
        public String toString() {
            if (first != null) {
                return "TreeChild$Node[data=" + data + ", first=" + first.pos + "]";
            } else {
                return "TreeChild$Node[data=" + data + ", first=-1]";
            }
        }
    }
    
    private final int DEFAULT_TREE_SIZE = 100;
    private int treeSize=0;
    
    // 使用一個Node[]數組來記錄該樹里的所有節點
    private Node<E>[] nodes;
    
    //記錄節點數
    private int nodeNums;
    
    // 以指定根節點創建樹    
    public TreeChild(E data) {
        treeSize=DEFAULT_TREE_SIZE;
        nodes=new Node[treeSize];
        nodes[0]=new Node<E>(data);
        nodeNums++;
    }
    
    // 以指定根節點、指定treeSize創建樹
    public TreeChild(E data,int treeSize) {
        this.treeSize=treeSize;
        nodes=new Node[treeSize];
        nodes[0]=new Node<E>(data);
        nodeNums++;
    }
    
    // 為指定節點添加子節點    
    public void addNode(E data,Node parent) {
        for(int i=0;i<treeSize;i++) {
            // 找到數組中第一個為null的元素，該元素保存新節點
            if(nodes[i]==null) {
                // 創建新節點，並用指定數組元素保存它
                nodes[i]=new Node(data);
                if(parent.first==null) {
                    parent.first=new SonNode(i, null);
                }else {
                    SonNode next=parent.first;
                    while(next.next!=null) {
                        next=next.next;
                    }
                    next.next = new SonNode(i, null);
                }
                nodeNums++;
                return;
            }
        }
        throw new RuntimeException("該樹已滿，無法添加節點");
    }
    
    //判斷樹是否為空
    public boolean isEmpty() {
        return nodes[0]==null;
    }
    
    //返回根節點
    public Node<E> root(){
        return nodes[0];
    }
    
    //返回指定節點的所有子節點
    public List<Node<E>> children(Node<E> parent){
        List<Node<E>> list=new ArrayList<Node<E>>();
        // 獲取parent節點的第一個子節點
        SonNode next=parent.first;
        // 沿着孩子鏈不斷搜索下一個孩子節點
        while(next!=null) {
            list.add(nodes[next.pos]);
            next=next.next;
        }
        return list;
    }
    
    // 返回指定節點（非葉子節點）的第index個子節點
    public Node<E> child(Node parent,int index){
        // 獲取parent節點的第一個子節點
        SonNode next=parent.first;
        // 沿着孩子鏈不斷搜索下一個孩子節點
        for(int i=0;next!=null;i++) {
            if(index==i) {
                return nodes[next.pos];
            }
            next=next.next;
        }
        return null;
    }
    
    // 返回該樹的深度
    public int deep() {
        // 獲取該樹的深度
        return deep(root());
    }
    
    // 這是一個遞歸方法：每棵子樹的深度為其所有子樹的最大深度 + 1
    public int deep(Node node) {
        if(node.first==null) {
            return 1;
        }else {
            // 記錄其所有子樹的最大深度
            int max=0;
            SonNode next=node.first;
            // 沿着孩子鏈不斷搜索下一個孩子節點
            while(next!=null) {
                // 獲取以其子節點為根的子樹的深度
                int tmp=deep(nodes[next.pos]);
                if(tmp>max) {
                    max=tmp;
                }
                next=next.next;
            }
            // 最后，返回其所有子樹的最大深度 + 1
            return max + 1;
        }
    }
    
    
    // 返回包含指定值得節點
    public int pos(Node node) {
        for (int i = 0; i < treeSize; i++) {
            // 找到指定節點
            if (nodes[i] == node) {
                return i;
            }
        }
        return -1;
    }
    
    //測試
    public static void main(String[] args) {

        TreeChild<String> tp = new TreeChild<String>("root");
        TreeChild.Node root = tp.root();
        System.out.println(root);
        tp.addNode("節點1", root);
        tp.addNode("節點2", root);
        tp.addNode("節點3", root);
        System.out.println("添加子節點后的根結點：" + root);
        System.out.println("此樹的深度：" + tp.deep());
        // 獲取根節點的所有子節點
        List<TreeChild.Node<String>> nodes = tp.children(root);
        System.out.println("根節點的第一個子節點：" + nodes.get(0));
        // 為根節點的第一個子節點新增一個子節點
        tp.addNode("節點4", nodes.get(0));
        System.out.println("此樹第一個子節點：" + nodes.get(0));
        System.out.println("此樹的深度：" + tp.deep());

    }


    
    
}

 

程序運行結果：

TreeChild$Node[data=root, first=-1]
添加子節點后的根結點：TreeChild$Node[data=root, first=1]
此樹的深度：2
根節點的第一個子節點：TreeChild$Node[data=節點1, first=-1]
此樹第一個子節點：TreeChild$Node[data=節點1, first=4]
此樹的深度：3