Java 数据结构_树

最新推荐文章于 2023-05-14 12:48:50 发布

LZ_Luzhuo

最新推荐文章于 2023-05-14 12:48:50 发布

阅读量432

点赞数

分类专栏： java 文章标签：数据结构树

本文链接：https://blog.csdn.net/Rozol/article/details/78469973

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

Java 数据结构_树

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/78469973

树

树的基本概念

树是结点的有限集合
双亲: 根结点A是BCD的双亲, 下面的BCD都是A的孩子
兄弟: 同一个双亲之间的结点, 互称为兄弟, BCD互为兄弟
堂兄弟: 双亲在同一层的结点, 互称为堂兄弟, EFGHIJKL互为堂兄弟
度: 连接他的结点数, A的度为3
根结点: 无双亲, 且唯一的结点
分支结点(非终端结点): 度不为0的结点, BCD都是分支结点, 也称中间结点(除A外)
叶结点(终端结点): 度为0的结点, EFGHIJKL都是叶结点.
祖先: 之前所有的结点都是祖先, G的祖先是BA
子孙: 之后所有的结点都是子孙, B的子孙是EFG
有序树(从左到右不能换顺序), 无序树(可换顺序)
深度: 树的最大深度, 这颗树的深度为3
森林: 多个独立的树(互不相交)放在一起就是森林
二叉树: 每个结点的度最多为2的树
树的遍历:
用途:压缩软件-赫夫曼树 / 搜索-人机对战

二叉树的实现方式

数组实现方式, 删除指定索引位置的结点时, 不会删除他的所有孩子
链式实现方式, 删除指定结点时, 会删除他的所有孩子

二叉树的数组实现方式

二叉树的数组实现代码

/**
 * 二叉树(数组的表示方式)
 * @author Luzhuo
 *         A(0)
 *    B(1)       C(2)
 *  D(3) E(4)  F(5) G(6)    
 * 
 * |A(0)| B(1)|C(2) | D(3)|E(4) | F(5)|G(6) | ...|... |
 */
public class ArrayTree {
    // 树的数组表示方式
    private Node[] nodes; // 树的指针
    private int size; // 数组的大小

    public ArrayTree(Node root){
        init(1024, root);
    }

    public ArrayTree(int size, Node root){
        init(size, root);
    }

    /**
     * 创建二叉树<br>
     * 创建存放结点的数组, 设置该数据结构的容量, 设置根结点
     * @param size
     * @param root
     */
    private void init(int size, Node root){
        this.nodes = new Node[size];
        this.size = size;
        // 根结点
        this.nodes[0] = root;
    }

    /**
     * 销毁二叉树<br>
     * 删除存放结点的数组
     */
    public void destory(){
        nodes = null;
    }

    /**
     * 根据索引搜索结点
     * @param nodeIndex 索引
     * @return 结点
     */
    public Node serchNode(int nodeIndex){
        if(nodeIndex < 0 || nodeIndex >= this.size){
            throw new ArrayIndexOutOfBoundsException("索引越界.");
        }

        return nodes[nodeIndex];
    }

    /**
     * 添加结点<br>
     * 添加在父结点的左边时, 添加到数组的奇数索引位置(1, 3, 5 ...), 添加在父结点的右边时, 添加到数组的偶数索引位置(2, 4, 6 ...)
     * @param nodeIndex 结点索引(从0开始)
     * @param direction 左边0还是右边1
     * @param node 结点
     * @return 是否添加成功
     */
    public boolean addNode(int nodeIndex, int direction, Node node){
        if(nodeIndex < 0 || nodeIndex >= this.size){
            throw new ArrayIndexOutOfBoundsException("索引越界.");
        }

        if(this.nodes[nodeIndex] == null){
            throw new NullPointerException("该结点为空");
        }

        // 若某结点再父节点下标 * 2 + 1 ,则表示该结点在左
        // 若某结点再父节点下标 * 2 + 2, 则表示该结点在右
        int leftIndex = nodeIndex * 2 + 1;
        int rightIndex = nodeIndex * 2 + 2;
        if(direction == 0){
            if(leftIndex >= this.size || this.nodes[leftIndex] != null) return false;
            this.nodes[leftIndex] = node;
        }else if(direction == 1){
            if(rightIndex >= this.size || this.nodes[rightIndex] != null) return false;
            this.nodes[rightIndex] = node;
        }
        return true;
    }

    /**
     * 删除索引<br>
     * @param nodeIndex
     * @return 被删除的结点
     */
    public Node deleteNode(int nodeIndex){
        if(nodeIndex < 0 || nodeIndex >= this.size){
            throw new ArrayIndexOutOfBoundsException("索引越界.");
        }

        if(this.nodes[nodeIndex] == null){
            throw new NullPointerException("该结点为空");
        }

        Node tempN = this.nodes[nodeIndex];
        this.nodes[nodeIndex] = null;
        return tempN;
    }

    /**
     * 遍历<br>
     * 之间从左向右遍历数组.
     */
    public void traverse(){
        for(int i = 0; i < this.size; i++){
            Node data = this.nodes[i];
            if(data != null) System.out.print(data + " ");
        }
    }

}

class Node{
    public char data;

    public Node(char data){
        this.data = data;
    }

    @Override
    public String toString() {
        return String.valueOf(data);
    }
}

数组方式测试代码

public class ArrayTreeTest {

    public static void main(String[] args) {
        // 测试
        ArrayTree tree = new ArrayTree(new Node('A'));

//      tree.addNode(0, 0, new Node('B'));
//      tree.addNode(0, 1, new Node('C'));
//      tree.addNode(1, 0, new Node('D'));
//      tree.addNode(1, 1, new Node('E'));
//      tree.addNode(2, 0, new Node('F'));
//      tree.addNode(2, 1, new Node('G'));
        // ↓ 简化

        int nodeIndex = -1;
        for(int i = 0; i < 10; i++){
            int direction;
            if(i%2 == 0){
                direction = 0;
                nodeIndex++;
            }else{
                direction = 1;
            }
            tree.addNode(nodeIndex, direction, new Node((char)(66+i)));
        }

        tree.traverse();

        System.out.println();

        System.out.println(tree.serchNode(3));
        System.out.println(tree.deleteNode(3));

        tree.traverse();

        tree.destory();
    }
}

二叉树的链式实现方式

二叉树的链式实现代码

/**
 * 二叉树(链式实现方式)
 * @author Luzhuo
 *         (0)
 *    A(1)       B(2)
 *  C(3) D(4)  E(5) F(6)  
 * 前序遍历(根左右): 0 1 3 4 2 5 6 
 * 中序遍历(左根右): 3 1 4 0 5 2 6
 * 后序遍历(左右根): 3 4 1 5 6 2 0 
 */
public class LinkedTree {
    Node_ root; // 根结点

    public LinkedTree(){
        init();
    }

    /**
     * 创建链式二叉树<br>
     * 初始化根结点的数据0, 索引0, 左孩子指针null, 右孩子指针null, 父节点指针null
     */
    private void init(){
        root = new Node_();
        root.data = 0;
        root.index = 0;
        root.lChildNode = null;
        root.rChildNode = null;
        root.parentNode = null;
    }

    /**
     * 销毁链式二叉树<br>
     * 递归删除所有孩子, 并指针重置为null
     */
    public void destory(){
        this.root.deleteNode();
        this.root = null;
    }

    /**
     * 根据索引寻找结点<br>
     * 递归查找指定索引位置的结点
     * @param nodeindex 索引
     * @return 结点
     */
    public Node_ searchNode(int nodeindex){
        return this.root.searchNode(nodeindex);
    }

    /**
     * 添加结点<br>
     * 找到指定位置的结点, 将新结点添加到该结点的左边 / 右边, 并将该结点的指针交给新结点
     * @param nodeindex 索引
     * @param direction 左边0或右边1
     * @param node 被挂在的结点
     * @return 添加成功返回true,否则返回false;
     */
    public boolean addNode(int nodeindex, int direction, Node_ node){
        Node_ curN = searchNode(nodeindex);
        if(curN == null) return false;

        // 加入到该结点的左边or右边
        if(direction == 0){
            curN.lChildNode = node;
        }else if(direction == 1){
            curN.rChildNode = node;
        }
        // 并该结点的指针交给插入的结点
        node.parentNode = curN;
        return true;
    }

    /**
     * 删除指定索引的结点, 注意删除结点,会将挂在在该结点的所有结点同时删除<br>
     * 找到指定的结点, 递归删除自己所有的孩子
     * @param nodeindex 索引
     * @return 被删除的结点, 该结点为空返回null
     */
    public Node_ deleteNode(int nodeindex){
        Node_ curN = searchNode(nodeindex);
        if(curN == null) return null;

        Node_ tempN = curN;
        curN.deleteNode();
        curN = null;
        return tempN;
    }

    /**
     * 前序遍历(根左右, 根前)
     */
    public void preorderTraversal(){
        this.root.preorderTraversal();
    }

    /**
     * 中序遍历(左根右, 根中)
     */
    public void inorderTraversal(){
        this.root.inorderTraversal();
    }

    /**
     * 后序遍历(左右根, 根后)
     */
    public void postorderTraversal(){
        this.root.postorderTraversal();
    }

}

/**
 * 结点, 创建必须给index和data赋值
 * @author Luzhuo
 *
 */
class Node_{
    public int index; // 索引
    public char data; // 数据
    public Node_ lChildNode; // 左结点指针
    public Node_ rChildNode; // 右结点指针
    public Node_ parentNode; // 父结点指针

    public Node_(){ }

    public Node_(int index, char data){
        this.index = index;
        this.data = data;
    }

    /**
     * 根据索引寻找结点
     * @param nodeindex 索引
     * @return 找到结点返回结点, 否则返回null
     */
    public Node_ searchNode(int nodeindex){
        // 是否是自身
        if(this.index == nodeindex) return this;

        Node_ tempN;
        // 是否是左边的孩子,及其子结点
        if(this.lChildNode != null){
            if(this.lChildNode.index == nodeindex){
                return this.lChildNode;
            }else{
                tempN = this.lChildNode.searchNode(nodeindex);
                if(tempN != null) return tempN;
            }
        }

        // 是否是右边的孩子,及其子结点
        if(this.rChildNode != null){
            if(this.rChildNode.index == nodeindex){
                return this.rChildNode;
            }else{
                tempN = this.rChildNode.searchNode(nodeindex);
                if(tempN != null) return tempN;
            }
        }
        return null;
    }

    public void deleteNode(){
        // 删除自己左右边的所有子结点
        if(this.lChildNode != null){
            this.lChildNode.deleteNode();
        }
        if(this.rChildNode != null){
            this.rChildNode.deleteNode();
        }
        // 删除自己在父结点上的指针
        if(this.parentNode != null){
            if(this.parentNode.lChildNode == this){
                this.parentNode.lChildNode = null;
            }
            if(this.parentNode.rChildNode == this){
                this.parentNode.rChildNode = null;
            }
        }       
    }

    /**
     * 前序遍历(根左右)<br>
     * 每个结点先输出自身(根), 然后递归左结点, 在递归右结点
     */
    public void preorderTraversal(){
        // 根
        System.out.println("index: " + this.index + " data: " + data + " === ");
        // 左
        if(this.lChildNode != null) this.lChildNode.preorderTraversal();
        // 右
        if(this.rChildNode != null) this.rChildNode.preorderTraversal();
    }

    /**
     * 中序遍历(左根右)
     */
    public void inorderTraversal(){
        // 左
        if(this.lChildNode != null) this.lChildNode.inorderTraversal();
        // 根
        System.out.println("index: " + this.index + " data: " + data + " === ");
        // 右
        if(this.rChildNode != null) this.rChildNode.inorderTraversal();
    }

    /**
     * 后序遍历(左右根)
     */
    public void postorderTraversal(){
        // 左
        if(this.lChildNode != null) this.lChildNode.postorderTraversal();
        // 右
        if(this.rChildNode != null) this.rChildNode.postorderTraversal();
        // 根
        System.out.println("index: " + this.index + " data: " + data + " === ");

    }
}

数组方式测试代码

public class LinkedTreeTest {
    public static void main(String[] args) {
        // 测试
        /*
         *         (0)
         *    A(1)       B(2)
         *  C(3) D(4)  E(5) F(6)  
         * 前序遍历(根左右): 0 1 3 4 2 5 6 
         * 中序遍历(左根右): 3 1 4 0 5 2 6
         * 后序遍历(左右根): 3 4 1 5 6 2 0 
         */

        LinkedTree tree = new LinkedTree();

//      tree.addNode(0, 0, new Node_(1, 'A'));
//      tree.addNode(0, 1, new Node_(2, 'B'));
//      tree.addNode(1, 0, new Node_(3, 'C'));
//      tree.addNode(1, 1, new Node_(4, 'D'));
//      tree.addNode(2, 0, new Node_(5, 'E'));
//      tree.addNode(2, 1, new Node_(6, 'F'));
        // ↓ 简化

        int nodeIndex = -1;
        for(int i = 0; i < 10; i++){
            int direction;
            if(i%2 == 0){
                direction = 0;
                nodeIndex++;
            }else{
                direction = 1;
            }
            tree.addNode(nodeIndex, direction, new Node_(i + 1, (char)(65+i)));
        }

        tree.preorderTraversal();
        System.out.println();
        tree.inorderTraversal();
        System.out.println();
        tree.postorderTraversal();

        System.out.println();
        System.out.println(tree.deleteNode(3).data);
        System.out.println(tree.deleteNode(2).data);
        tree.preorderTraversal();


        tree.destory();
    }
}