zoukankan      html  css  js  c++  java
  • 【数据算法】Java实现二叉树存储以及遍历

    二叉树在java中我们使用数组的形式保存原数据,这个数组作为二叉树的数据来源,后续对数组中的数据进行节点化操作。

    步骤就是原数据:数组

    节点化数据:定义 Node节点对象

    存储节点对象:通过LinkedList保存Node节点对象

    在操作过程中我们需要将当前结点和前一节点、后一节点进行关系绑定

        package tree;  
          
        import java.util.LinkedList;  
        import java.util.List;  
          
        /** 
         * 功能:把一个数组的值存入二叉树中,然后进行3种方式的遍历 
         *  
         * 参考资料0:数据结构(C语言版)严蔚敏 
         *  
         * 参考资料1:http://zhidao.baidu.com/question/81938912.html 
         *  
         * 参考资料2:http://cslibrary.stanford.edu/110/BinaryTrees.html#java 
         *  
         * @author ocaicai@yeah.net @date: 2011-5-17 
         *  
         */  
        public class BinTreeTraverse2 {  
          
            private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
            private static List<Node> nodeList = null;  
          
            /** 
             * 内部类:节点 
             *  
             * @author ocaicai@yeah.net @date: 2011-5-17 
             *  
             */  
            private static class Node {  
                Node leftChild;  
                Node rightChild;  
                int data;  
          
                Node(int newData) {  
                    leftChild = null;  
                    rightChild = null;  
                    data = newData;  
                }  
            }  
          
            public void createBinTree() {  
                nodeList = new LinkedList<Node>();  
                // 将一个数组的值依次转换为Node节点  
                for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {  
                    nodeList.add(new Node(array[nodeIndex]));  
                }  
                // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树  
                for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {  
                    // 左孩子  
                    nodeList.get(parentIndex).leftChild = nodeList  
                            .get(parentIndex * 2 + 1);  
                    // 右孩子  
                    nodeList.get(parentIndex).rightChild = nodeList  
                            .get(parentIndex * 2 + 2);  
                }  
                // 最后一个父节点:因为最后一个父节点可能没有右孩子,所以单独拿出来处理  
                int lastParentIndex = array.length / 2 - 1;  
                // 左孩子  
                nodeList.get(lastParentIndex).leftChild = nodeList  
                        .get(lastParentIndex * 2 + 1);  
                // 右孩子,如果数组的长度为奇数才建立右孩子  
                if (array.length % 2 == 1) {  
                    nodeList.get(lastParentIndex).rightChild = nodeList  
                            .get(lastParentIndex * 2 + 2);  
                }  
            }  
          
            /** 
             * 先序遍历 
             *  
             * 这三种不同的遍历结构都是一样的,只是先后顺序不一样而已 
             *  
             * @param node 
             *            遍历的节点 
             */  
            public static void preOrderTraverse(Node node) {  
                if (node == null)  
                    return;  
                System.out.print(node.data + " ");  
                preOrderTraverse(node.leftChild);  
                preOrderTraverse(node.rightChild);  
            }  
          
            /** 
             * 中序遍历 
             *  
             * 这三种不同的遍历结构都是一样的,只是先后顺序不一样而已 
             *  
             * @param node 
             *            遍历的节点 
             */  
            public static void inOrderTraverse(Node node) {  
                if (node == null)  
                    return;  
                inOrderTraverse(node.leftChild);  
                System.out.print(node.data + " ");  
                inOrderTraverse(node.rightChild);  
            }  
          
            /** 
             * 后序遍历 
             *  
             * 这三种不同的遍历结构都是一样的,只是先后顺序不一样而已 
             *  
             * @param node 
             *            遍历的节点 
             */  
            public static void postOrderTraverse(Node node) {  
                if (node == null)  
                    return;  
                postOrderTraverse(node.leftChild);  
                postOrderTraverse(node.rightChild);  
                System.out.print(node.data + " ");  
            }  
          
            public static void main(String[] args) {  
                BinTreeTraverse2 binTree = new BinTreeTraverse2();  
                binTree.createBinTree();  
                // nodeList中第0个索引处的值即为根节点  
                Node root = nodeList.get(0);  
          
                System.out.println("先序遍历:");  
                preOrderTraverse(root);  
                System.out.println();  
          
                System.out.println("中序遍历:");  
                inOrderTraverse(root);  
                System.out.println();  
          
                System.out.println("后序遍历:");  
                postOrderTraverse(root);  
            }  
          
        }  
    
  • 相关阅读:
    CSS3 target伪类简介
    不用position,让div垂直居中
    css3 在线编辑工具 连兼容都写好了
    a标签伪类的顺序
    oncopy和onpaste
    【leetcode】1523. Count Odd Numbers in an Interval Range
    【leetcode】1518. Water Bottles
    【leetcode】1514. Path with Maximum Probability
    【leetcode】1513. Number of Substrings With Only 1s
    【leetcode】1512. Number of Good Pairs
  • 原文地址:https://www.cnblogs.com/wentaos/p/7407006.html
Copyright © 2011-2022 走看看