数据结构与算法-树

树的双亲表示法

package tree;

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

/**
 * 树的双亲表示法.
 * @author mac
 * */
public class ParentTree {

    private static Integer DEFAULT_CAPACITY = 10;
    private Node[] items;
    private Integer capacity;
    private Integer size;

    private static class Node{
        Object data;
        Integer parentIndex;

        public Node(Object data, Integer parentIndex) {
            this.data = data;
            this.parentIndex = parentIndex;
        }

        @Override
        public String toString() {
            return "[data: " + data +", parent index: " + parentIndex + "]";
        }
    }

    /**
     * 初始化一颗空树
     * */
    public ParentTree(){
        this.capacity = DEFAULT_CAPACITY;
        this.size = 0;
        this.items = new Node[this.capacity];
    }

    public ParentTree(Integer capacity){
        this.capacity = capacity;
        this.size = 0;
        this.items = new Node[this.capacity];
    }

    /**
     * 清空树
     * */
    public void clear(){
        this.items = new Node[this.capacity];
        this.size = 0;
    }

    /**
     * 判断是否为空
     * */
    public boolean isEmpty(){
        return this.size == 0;
    }

    /**
     * 返回当前树的总节点数
     * */
    public Integer size(){
        return this.size;
    }

    /**
     * 求树的深度
     * */
    public Integer deep(){
        Integer deep = 0;
        for(int i = 0;i < items.length;i ++) {
            Integer currentDeep = 1;
            if(!Objects.isNull(items[i])){
               for(int j = 0;j < items.length;j ++) {
                   if(!Objects.isNull(items[j]) && items[j].parentIndex == i){
                      /* Node node = items[j];
                       Integer parentIndex = node.parentIndex;
                       if(parentIndex == i) {*/
                           currentDeep ++;
                       //}
                   }
               }
            }
            //deep = currentDeep;
            if(currentDeep > deep) {
                deep = currentDeep;
            }
        }
        return deep;
    }

    /**
     * 返回树的根节点
     * */
    public Node root(){
        for(int i = 0;i < items.length;i ++) {
            if(!Objects.isNull(items[i]) && items[i].parentIndex == -1) {
                return items[i];
            }
        }
        return null;
    }

    /**
     * 返回Node的数组index
     * */
    public Integer index(Node node) {
        for(int i = 0;i < items.length;i ++) {
            if(items[i] == node){
                return i;
            }
        }
        return -1;
    }

    public Integer index(Object value) {
        for(int i = 0;i < items.length;i ++) {
            if(items[i].data.equals(value)){
                return i;
            }
        }
        return -1;
    }


    /**
     * 添加数据
     * */
    public Integer add(Integer parent, Object data){
        if(size == items.length) {
            throw new RuntimeException("树已满");
        }
        Node newNode = new Node(data, parent);
        for(int i = 0;i < items.length;i ++) {
            if(items[i] == null) {
                items[i] = newNode;
                this.size ++;
                return i;
            }
        }
        return -1;
    }

    public Integer add(Object parentValue, Object data){
        Integer idx = index(parentValue);
        return add(idx, data);
    }


    public Integer addRoot(Object data) {
        for(int i = 0;i < items.length;i ++) {
            if(!Objects.isNull(items[i])) {
                if (items[i].parentIndex == -1) {
                    throw new RuntimeException("根节点已存在");
                }
            }
        }
        for(int i = 0;i < items.length;i ++)
        {
            if(Objects.isNull(items[i])){
                items[i] = new Node(data, -1);
                return i;
            }
        }
        return -1;
    }



    /**
     * 递归遍历
     * */
    public void print(Node root){
        List<Node> children = new ArrayList<Node>();
        Integer nodeIdx = index(root);
        for(int i  = 0;i < items.length;i ++) {
            if(!Objects.isNull(items[i]) && items[i].parentIndex == nodeIdx){
                children.add(items[i]);
            }
        }
        if(children.size() > 0){
            children.stream().forEach(child -> {
                print(child);
            });
        }
        System.out.println(root);
    }

    public static void main(String[] args) {
        ParentTree parentTree = new ParentTree();
        parentTree.addRoot("a");
        parentTree.add("a", "b");
        parentTree.add("a", "c");
        parentTree.add("b", "d");

        parentTree.print(parentTree.root());
        System.out.println(parentTree.deep());
    }

}

树的孩子表示法

package tree;

import java.util.Arrays;
import java.util.Objects;

/**
 * 树的孩子表示法.
 * @author mac
 * */
public class ChildrenTree {

    private static Integer DEFAULT_CAPACITY = 10;
    private Node[] items;
    private Integer capacity;
    private Integer size;


    public ChildrenTree(){
        this.capacity = DEFAULT_CAPACITY;
        items = new Node[capacity];
        size = 0;
    }

    public ChildrenTree(Integer capacity) {
        this.capacity = capacity;
        this.items = new Node[capacity];
        this.size = 0;
    }

    /**
     * 清空树
     * */
    public void clear(){
        this.items = new Node[capacity];
        this.size =  0;
    }

    /**
     * 判断是否为空
     * */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 返回当前节点的总树
     * */
    public Integer size(){
        return size;
    }

    /**
     * 返回树的深度
     * */
    public Integer deep(){
        Integer deep = 0;
        if(size > 0) {
            for(int i = 0;i < items.length;i ++)
            {
                if(!Objects.isNull(items[i])) {
                    Integer currentDeep = 1;
                    ChildrenNode childPointer = items[i].firstChild;
                    while(childPointer != null) {
                        childPointer = childPointer.nextChild;
                        currentDeep ++;
                    }
                    if(currentDeep > deep){
                        deep = currentDeep;
                    }
                }
            }
        }
        return deep;
    }

    /**
     * 根据节点获取索引下标
     * */
    public Integer index(Node node) {
        for(int i = 0;i < items.length;i ++)
        {
            if(!Objects.isNull(items[i]) && items[i] == node) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据节点值获取索引
     * */
    public Integer index(Object value) {
        for (int i = 0;i < items.length;i ++) {
            if(!Objects.isNull(items[i]) && items[i].data.equals(value)) {
                return i;
            }
        }
        return -1;
    }

    public void addRoot(Object data) {
        for (int i = 0; i < items.length; i++) {
            if(Objects.isNull(items[i])) {
                items[i] = new Node(data, -1);
                break;
            }
        }
    }

    public void add(Object parentValue , Object data) {
        Integer parentIndex = index(parentValue);
        if(parentIndex == -1) {
            throw new RuntimeException("父节点不存在");
        }
        Integer newNodeIndex = -1;
        for(int i = 0;i < items.length;i ++) {
            if(Objects.isNull(items[i])) {
                items[i] = new Node(data, parentIndex);
                newNodeIndex = i;
                break;
            }
        }
        if(newNodeIndex == -1) {
            throw new RuntimeException("添加节点失败");
        }
        Node parent = items[parentIndex];
        ChildrenNode childrenNode = new ChildrenNode();
        childrenNode.childIndex = newNodeIndex;
        ChildrenNode first = parent.firstChild;
        if(Objects.isNull(first)){
            parent.firstChild = childrenNode;
            this.size ++;
            return;
        }
        while(!Objects.isNull(first) && first.nextChild!= null) {
            first = first.nextChild;
        }

        first.nextChild = childrenNode;
        this.size ++;
    }

    public void print(){
        for(int i = 0;i < items.length &&
                !Objects.isNull(items[i]);i ++) {

            System.out.println(items[i]);
        }
    }



    private class Node{
        private Object data;
        private Integer parentIndex;   //父节点的索引
        private ChildrenNode firstChild;  //孩子链的头指针

        public Node(Object data, Integer parentIndex) {
            this.data =data;
            this.parentIndex = parentIndex;
        }

        @Override
        public String toString() {
            return "[data : " + data + ", parent index:" + parentIndex+"]";
        }
    }

    private class ChildrenNode{
        Integer childIndex;  //当前子节点的索引
        ChildrenNode nextChild; //下一个子节点的指针
    }


    public static void main(String[] args) {

        ChildrenTree tree = new ChildrenTree();
        tree.addRoot("a");
        tree.add("a", "b");
        tree.add("a", "c");
        tree.add("c", "d");
        tree.add("c", "e");
        tree.add("b", "f");

        tree.print();

        System.out.println(tree.deep());
    }
}