数据结构总结篇-2

3.树和二叉树

目录

3.树和二叉树

3.1 树的递归方法

3.2 树的非递归方法

3.3 哈夫曼树

---

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

树：n个结点的集合。

二叉树：每个结点最多有两个子树。二叉树的性质：叶子数=度为2的结点数+1；

完全二叉树：深度为k，有n个结点的二叉树，当且仅当每个结点都与深度为k的满二叉树中编号从1-n的结点一一对应。特点：叶子结点只可能在层次最大的两层出现。

3.1 树的递归方法

二叉树的三种递归遍历方法：

//二叉树的前序遍历（递归）->根左右
public void preorder(TreeNode root, List<Integer> res) {
       if (root == null) {
            return;
       }
       res.add(root.val);
       preorder(root.left, res);
       preorder(root.right, res);
}
//二叉树的中序遍历（递归）->左根右
public void middleOrder(TreeNode root, List<Integer> res) {
       if (root == null) {
            return;
       }
       preorder(root.left, res);
       res.add(root.val);
       preorder(root.right, res);
}
//二叉树的后序遍历（递归）->左右根
public void postscript(TreeNode root, List<Integer> res) {
       if (root == null) {
            return;
       }
       preorder(root.left, res);
       preorder(root.right, res);
       res.add(root.val);
}

3.2 树的非递归方法

三种非递归算法：

//先序的非递归方法，采用stack
//思路：先序是根左右，node不为空的时候我们使用while不停的往左子树那边一直输出，
public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }//while结束说明到达最左子树，开始出栈，令node.right=node
            node = stack.pop();
            node = node.right;
        }
        return res;
}
//中序的非递归方法
public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root != null || !stk.isEmpty()) {
            while (root != null) {
                stk.push(root);
                root = root.left;//先一直while到最左子树
            }
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
}
//后序的非递归算法
public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
}

还有一种morris方法：

有一种巧妙的方法可以在线性时间内，只占用常数空间来实现后序遍历。这种方法由 J. H. Morris 在 1979 年的论文「Traversing Binary Trees Simply and Cheaply」中首次提出，因此被称为 Morris 遍历。

Morris 遍历的核心思想是利用树的大量空闲指针，实现空间开销的极限缩减。其后序遍历规则总结如下：

1.     新建临时节点，令该节点为 root；
2.     如果当前节点的左子节点为空，则遍历当前节点的右子节点；
3.     如果当前节点的左子节点不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点；

        如果前驱节点的右子节点为空，将前驱节点的右子节点设置为当前节点，当前节点更新为当前节点的左子节点。

        如果前驱节点的右子节点为当前节点，将它的右子节点重新设为空。倒序输出从当前节点的左子节点到该前驱节点这条路径上的所有节点。当前节点更新为当前节点的右子节点。

重复步骤 2 和步骤 3，直到遍历结束。

3.3 哈夫曼树

哈夫曼树：最优树，一类带权路径最短的树

构造方法：条件：给定n个权值，构造一个n颗只有根结点的二叉树。

1. 选取两个权值最小的树，作为左右子树构造一棵新的二叉树，两者权值之和作为新树的权值
2. 森林中删除这两棵树，加入新树

重复1、2操作直到只有一棵树为止

具体实现代码：

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        TreeNode[] nums=new TreeNode[8];
        List<TreeNode> list=new ArrayList<>();
        for (int i = 0; i <8; i++) {
            nums[i]=new TreeNode();
            nums[i].val=scanner.nextInt();
            list.add(nums[i]);
        }
        TreeNode root=gouzhao(list);
        int sum=daiquan(root);
        System.out.println("daiquan:   "+sum);
}
    //TODO 哈夫曼树：带权最短路径二叉树
    //TODO 树的带权路径长度为所有结点值相加-根节点的值
    /*
    思路：构造一个list，每次选va的最小的两个构造成一个新树
    5 5 2 4 6 7 7
    5 5 6 7 7 6
    6 7 7 6 10
    7 7 10 12
    10 12 14
    14 22
    36
     */
public static TreeNode gouzhao(List<TreeNode> list){
        int n=list.size();
        if(n==1){
            return list.get(0);
        }
        TreeNode[] nums=new TreeNode[n];
        for (int i = 0; i <n; i++) {
            nums[i]=list.get(i);
        }
        Arrays.sort(nums);
        TreeNode t=new TreeNode(nums[0].val+nums[1].val);
        t.left=nums[0];t.right=nums[1];
        list.remove(nums[0]);
        list.remove(nums[1]);
        list.add(t);
        for (TreeNode tr:list){
            System.out.print(" "+tr.val);
        }
        return gouzhao(list);
}
public static int daiquan(TreeNode root){
        if(root==null){
            return 0;
        }
        return root.val+daiquan(root.left)+daiquan(root.right);
}