数据结构和算法5-非线性-树

最新推荐文章于 2022-08-20 19:46:11 发布
最新推荐文章于 2022-08-20 19:46:11 发布
阅读量435 收藏 2
点赞数 1
分类专栏： 数据结构和算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011622109/article/details/107350557
版权

数据结构和算法系列共八篇

先介绍个工具

1.概念

1-1.什么是树

树是由结点或顶点和边组成的(可能是非线性的)且不存在着任何环的一种数据结构。
没有结点的树称为空(null或empty)树。一棵非空的树包括一个根结点，还(很可能)有多个附加结点，所有结点构成一个多级分层结构。

img

1-2.度

度(degree)分为

  • 节点的度, 含有几个子节点(儿子)
  • degree为0的节点，称为叶子节点leaf
  • 最上层的曾为根节点root
  • degree不为0的节点，除根以外称为内部节点
  • 树的度，各节点的最大degree称为树的degree (m叉树)

img

1-3.深度

深度(depth)又叫层次(level),root为第一层，其子节点为第二层，子的子为第三层…以此类推

img

1-4.树的分类

顺序分

如果树的节点是有顺序的，那就是有序树，没有顺序的则是无序的

节点分

按树所有node里，某node的子node最多树为m，那就是m叉树 (以最多的为基准，即树的degree)

树的个数分

多棵树组成一个森林，一个树只是特殊的森林。

1-5.节点间关系

直接关系

  • 父节点：一个节点直接前节点
  • 子节点：一个节点直接后节点
  • 兄弟节点：同一父节点的，其他节点

间接关系

  • 祖先：从根到该节点所经分支上的所有节点；
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟

img

2.二叉树

二叉树，是m叉树为2的特殊树(即:树的degree小于等于2)。

2-1.二叉树特性

img

有兴趣的可以看下其证明

2-2.二叉树分类

2-2-1.满二叉树

高度为k并且有 2 k + 1 − 1 2^{k+1}-1 2k+1−1个结点的二叉树。

img

2-2-2.完全二叉树

基于满二叉树，在最下层从最右侧起去掉相邻的若干叶子结点，得到的二叉树称为完全二叉树。

img

2-3.二叉树的存储结构

  • 顺序数组存储
  • 链结构存储
2-3-1.顺序数组存储

如果是完全二叉树，用顺序存储很好。但是不是完全二叉树的话，中间会有空留，占用空间。

img

img

2-3-2.链结构存储

链表结构比较适合二叉树存储。node节点结构：左子节点、数据、右子节点。

这样的数据结构，只能保证父找到子，不能保证子找父的。(如需子找到父，那还得需要多加个父节点存储)

img

3.遍历

二叉树遍历根据root的位置分三种

  • 前序遍历：根-左-右 DLR
  • 中序遍历：左-根-右 LDR
  • 后序遍历：左-右-根 LRD

img

3-1.前序遍历

心法口诀：首先访问根，再先序遍历左子树，最后先序遍历右子树

img

传统分析

1.找到root-1，然后左边子node-4，右边子node-1。得到1 4_ 2_
2.再分析左边的node-4，node-4的左子node没有，右子node为node-5。得到1 4 5 2_
3.左边没有，在分析右边node-2，node-2的左子node-3，右子node-6。得到1 4 5 2 3 6 _
4.再分析node-3的，左右子node都没有，是leaf
5.再分析node-6，左子node没有，右子node-7。得到1 4 5 2 3 6 7

个人技巧

img

注意上面箭头方向。从最左上，每次一层，所得的结果就是前序结果。

用咱的小技巧去试试前面的二叉树吧，看是不是得到一样的结果。

3-2.中序遍历

心法口诀：首先中序遍历左子树，再访问根，最后中序遍历右子树

img

传统分析

1.找到root-1放中间，然后左边子node-4放左侧，右边子node-1放右侧。得到_4_ 1 2_(此时下划线是4和2的)
2.再分析左边的node-4，node-4的左子node没有，右子node为node-5。得到4 5 1 _2_(此时下划线是2的)
3.左边没有，在分析右边node-2，node-2的左子node-3放左侧，右子node-6放右测。得到4 5 1 _3_2_6_(此时下划线是3和6的)
4.再分析node-3的，左右子node都没有，是leaf。4 5 1 3 2_6_(3没有左右，那么就将3的左右下划线删去)
5.再分析node-6，左子node没有，右子node-7放右测。得到4 5 1 3 2 6 7

个人技巧

img

因为根在中间，那不就是跟我们二叉树一样吗!!!(左根右，LDR)，所以直接把二叉树压平到一条线，不就是需要的顺序吗? 是不是so easy😀!
我相信你看到这，肯定想将文章拉到最后，要给我一个大大的赞👍或者来段评论啥的(去吧，不拦你😄，记得回来找我，接着往下看)。

用咱的小技巧去试试前面的二叉树吧，看是不是得到一样的结果。

3-3.后序遍历

心法口诀：首先中序遍历左子树，再中序遍历右子树，最后访问根

img

传统分析

1.找到root-1放最后，然后左边子node-4放左1侧，右边子node-1放左2侧。得到_4 _2 1(此时下划线是4和2的)
2.再分析左边的node-4，node-4的左子node没有，右子node为node-5放左2侧。得到5 4 _2 1(此时下划线是2的)
3.左边没有，在分析右边node-2，node-2的左子node-3放左1侧，右子node-6放左2测。得到5 4 _3 _6 2 1(此时下划线是3和6的)
4.再分析node-3的，左右子node都没有，是leaf。5 4 3 _6 2 1(3没有左右，那么就将3的左右下划线删去)
5.再分析node-6，左子node没有，右子node-7放左2侧。得到5 4 3 7 6 2 1

个人技巧

img

这个小技巧没上面个两种直观。但也能出来，比较啰嗦。说下，能理解的就用，不理解的话，还是使用传统方式

口诀：由左到右,由下往上的顺序(左的优先级比下高)。先左看再右看最后向前看齐(跟中国式过马路似的，先左再右看，最后前看。下面右解释)，每遇到root有分叉，将root放局部最后位置。(因为是后序遍历，所以遇到是root的，直接放到局部域最后位置)

  1. 6虽比9层次低，但是6比9靠左，左的优先级比下高。6开始，往上找祖先，直到遇到4分叉了。先左看再右看，最后向前看。将2放局部最后。结果为：7 6 4 _ 2 (此时下划线是2的)
  2. 继续找左分支上，最左且最下层没有处理过的node为9。往上走找祖先，直到2没遇到分叉。结果为：7 6 4 9 8 5 2
  3. 2继续找祖先,遇到了1分支。将1放局部最后。结果为：7 6 4 9 8 5 2 _ 1 (此时下划线是1的，代表1右节点遍历数据)
  4. 看右测的最左且最下层是10，往上找祖先，直到遇到1分叉。结果为：7 6 4 9 8 5 2 10 12 11 3 1

这有几点说明：

  • 左的优先级比下高：6虽比9层次低，但是6比9靠左，左的优先级比下高。（虽然9在第5层，6和4在第4和3层）。因为左比层次(下)优先级高。
  • 先左看再右看，最后向前看：意思6是4的左节点，7在4的右子节点上。那是先6再7最后4的顺序。

说下马路过程：(大家都知道中国交通规则是靠右行的)，直接上图吧

img

1.过马路，还没过一半前，先左边看，因为汽车是靠右行的，防止有车冲过来。
2.过完一半后，再左边看，防止另一半车再冲过来
3.过完马路了，左右都安全了，最后往前看走路

4.代码实战

4-1.接口

接口

public interface ITree {
    /**
     * 是否空树
     *
     * @return
     */
    public boolean isEmpty();

    /**
     * 树结点数量
     *
     * @return
     */
    public int size();

    /**
     * 获取二叉树的高度
     *
     * @return
     */
    public int getHeight();

    /**
     * 查询指定值的结点
     *
     * @param value
     * @return
     */
    public TreeNode findKey(int value); // 查找

    /**
     * 前序递归遍历
     */
    public void preOrderTraverse();

    /**
     * 中序遍历递归操作
     */
    public void inOrderTraverse();

    /**
     * 后序遍历递归操作
     */
    public void postOrderTraverse();

    /**
     * 中序遍历非递归操作
     * 1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。
     * 2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current
     * 3) 重复1、2步操作，直到current为空且栈内节点为空。
     */
    public void inOrderByStack();

    /**
     * 前序遍历非递归操作
     * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。
     * 2）若左子树为空，栈顶节点出栈，将该节点的右子树置为current
     * 3) 重复1、2步操作，直到current为空且栈内节点为空。
     */
    public void preOrderByStack();

    /**
     * 后序遍历非递归操作
     * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。
     * 2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点
     * 3) 重复1、2步操作，直到current为空且栈内节点为空。
     */
    public void postOrderByStack();

    /**
     * 按照层次遍历二叉树
     */
    public void levelOrderByQueue();

}

二叉node节点定义

public class TreeNode {

    private Object data;

    private TreeNode leftChild;

    private TreeNode rightChild;

    public TreeNode(Object data, TreeNode leftChild, TreeNode rightChild) {
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public TreeNode getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(TreeNode leftChild) {
        this.leftChild = leftChild;
    }

    public TreeNode getRightChild() {
        return rightChild;
    }

    public void setRightChild(TreeNode rightChild) {
        this.rightChild = rightChild;
    }

    @Override
    public String toString() {
        return "TreeNode{" + "data=" + data + ", leftChild=" + leftChild.getData() + ", rightChild=" + rightChild.getData() + '}';
    }
}

4-2.实现代码

整体实现代码最后整体给出，这先每个片段给出，并分析。

分析尽我最大解释，实在不懂，那就得靠自己悟了

4-2-1.空判断
public class MyListBinaryTree implements ITree {

    private TreeNode root;

    public MyListBinaryTree(TreeNode root) {
        this.root = root;
    }

    @Override
    public boolean isEmpty() {
        return root == null;
    }
}

只要判断root是否为空

4-2-2.大小
public int size() {
        return size(this.root);
    }

private int size(TreeNode node) {
    // 为null时返回0，不为null时加一
    if (node == null) {
        return 0;
    }
    int leftSize = size(node.getLeftChild());
    int rightSize = size(node.getRightChild());
    // 左右子节点都会掉一次，所以只要node为null的只要自己加一就行
    return leftSize + rightSize + 1;
}

使用递归方式，每次将left child和 right child传进去。空的时候，就返回0，否则加一

4-2-3.树深度
@Override
    public int getHeight() {
        // 求深度，即求从root出来的child node谁最长
        return getHeight(root);
    }

private int getHeight(TreeNode node) {
    if (node == null) {
        return 0;
    }
    // 左子节点
    int leftNum = getHeight(node.getLeftChild());

    // 右子节点
    int rightNum = getHeight(node.getLeftChild());

    // 返回大的+1
    return leftNum > rightNum ? leftNum + 1 : rightNum + 1;
}

使用递归方式，每次将left child和 right child传进去。空的时候，就返回0，否则将左右返回值中较大的加一

4-2-4.查找
@Override
    public TreeNode findKey(Object value) {
        return this.findKey(value, root);
    }

private TreeNode findKey(Object value, TreeNode node) {
    if (node == null) {
        return null;
    }

    if (node.getData().equals(value)) {
        return node;
    }

    TreeNode leftNode = findKey(value, node.getLeftChild());

    TreeNode rightNode = findKey(value, node.getRightChild());

    if (leftNode != null) {
        return leftNode;
    }

    if (rightNode != null) {
        return rightNode;
    }

    return null;
}

递归查找

4-2-5.前序遍历

递归方式实现

@Override
public void preOrderTraverse() {
    this.preOrderTraverse(root);
}

private void preOrderTraverse(TreeNode node) {
    if (node == null) {
        return;
    }
    // d输出
    System.out.print(node.getData() + " ");
    // l处理
    preOrderTraverse(node.getLeftChild());
    // r处理
    preOrderTraverse(node.getRightChild());
}

img

擦，不知从何讲起呀。(理解一眼就明白，不明白的，言语也解释不了😂)
递归：
1.给出终止条件，node为空结束
2.将根节点传给方法，因为前序遍历，所以要将d先输出
3.再将左子节点传给方法，作为根继续处理
4.将右子节点也传给递归方法，作为根继续处理

栈方式实现

@Override
public void preOrderByStack() {
    Deque<TreeNode> stack = new LinkedList<>();
    if (root == null) {
        return;
    }

    // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
    // 指向树的当前移动node点
    TreeNode current = root;
    List<Object> result = new ArrayList<>();
    while (current != null || !stack.isEmpty()) {
        // 将current node的所有左子节点全放到栈里，一致循环直到左子node为null
        while (current != null) {
            // 输出
            result.add(current.getData());
            stack.push(current);
            // 要移动current node的位置给current node (即left node)
            current = current.getLeftChild();
        }

        // 如果栈不为空，那就从栈中弹出栈顶元素
        // 将current node的right node给 current node，供下次循环找其所有的left node
        if (!stack.isEmpty()) {
            current = stack.pop();
            current = current.getRightChild();
        }
    }
    System.out.println(result);
}

img

上面代码有注释
大体思路:
从根起，将所有左节点全入栈中(从栈顶到栈尾为：6、4、2、1)，因为前序遍历，所以这时就要输出了，此时current为空跳出内部的while循环
到达if判断，从栈中弹出栈顶6，并赋值给current，并将6的右子节点7再赋给current（没有），此时4为栈顶。
循环一次while，将4弹出栈，将4右子节点给current，此时2成为栈顶了。
再做一次while循环，将7下面所有节点处理一边。发现没有，继续弹出2…(以此类推)

4-2-6.中序遍历

递归方式实现

@Override
public void inOrderTraverse() {
    this.inOrderTraverse(root);
}

private void inOrderTraverse(TreeNode node) {
    if (node == null) {
        return;
    }
    // l处理
    inOrderTraverse(node.getLeftChild());
    // d输出
    System.out.print(node.getData() + " ");
    // r处理
    inOrderTraverse(node.getRightChild());
}

img

递归：
1.给出终止条件，node为空结束
2.将根节点传给方法，因为中序遍历，所以要将d先放l和r中间

栈方式实现

@Override
public void inOrderByStack() {
    Deque<TreeNode> stack = new LinkedList<>();
    if (root == null) {
        return;
    }

    // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
    // 指向树的当前移动node点
    TreeNode current = root;
    List<Object> result = new ArrayList<>();
    while (current != null || !stack.isEmpty()) {
        // 将current node的所有左子节点全放到栈里，一致循环直到左子node为null
        while (current != null) {
            stack.push(current);
            // 要移动current node的位置给current node (即left node)
            current = current.getLeftChild();
        }

        // 如果栈不为空，那就从栈中弹出栈顶元素，输出
        // 将current node的right node给 current node，供下次循环找其所有的left node
        if (!stack.isEmpty()) {
            current = stack.pop();
            result.add(current.getData());
            current = current.getRightChild();
        }
    }
    System.out.println(result);
}

img

上面代码有注释
大体思路:
从根起，将所有左节点全入栈中(从栈顶到栈尾为：6、4、2、1)，此时current为空跳出内部的while循环
到达if判断，从栈中弹出栈顶6，并赋值给current，因为是中序遍历，所以弹栈时就要输出，再将6的右子节点给current（为null），此时4成为栈顶。
再做一次while循环,从栈中弹出栈顶4, 将4的右子节点7再赋给current, 此是2成为了栈顶
再做一次while循环，将7下面所有节点处理一边。发现没有，继续弹出2…(以此类推)

4-2-7.后序遍历

递归方式实现

@Override
public void postOrderTraverse() {
    this.postOrderTraverse(root);
}

private void postOrderTraverse(TreeNode node) {
    if (node == null) {
        return;
    }
    // l处理
    postOrderTraverse(node.getLeftChild());
    // r处理
    postOrderTraverse(node.getRightChild());
    // d输出
    System.out.print(node.getData() + " ");
}

img

递归：
1.给出终止条件，node为空结束
2.将根节点传给方法，因为中序遍历，所以要将d先放l和r后面

栈方式实现1

@Override
public void postOrderByStack() {

    // 方式一：
    Deque<TreeNode> stack = new LinkedList<>();
    if (root == null) {
        return;
    }
    List<Object> result = new ArrayList<>();
    // 指向树的当前移动node点
    TreeNode current = null;
    // 指向当前移动node的其中一个子节点(即，栈上的上一个栈顶)
    TreeNode tmpChildNode = null;

    stack.push(root);
    while (!stack.isEmpty()) {
        current = stack.peek();
        if ((current.getLeftChild() == null && current.getRightChild() == null) || current.getLeftChild() == tmpChildNode || current
                .getRightChild() == tmpChildNode) {
            result.add(current.getData());
            stack.pop();
            tmpChildNode = current;
        } else {
            // 先添加right child node ，因为栈是LIFO
            if (current.getRightChild() != null) {
                stack.push(current.getRightChild());
            }
            // 再添加left child node ，因为栈是LIFO
            if (current.getLeftChild() != null) {
                stack.push(current.getLeftChild());
            }
        }
    }
    System.out.println(result);
}

img

思想：
将节点压到栈中，然后通过栈顶元素去判断有没子节点，有则入栈，没有则出栈。
出栈时打印结果。注意打印的条件两个

  • 没有子节点，即leaf，需要打印
  • 出栈的节点的有子节点，但是前一次出栈的节点，也需要打印

栈方式实现2

 @Override
public void postOrderByStack() {
    // 方式二
    Deque<TreeNode> stack = new LinkedList<>();
    if (root == null) {
        return;
    }

    // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
    // 指向树的当前移动node点
    TreeNode current = root;
    List<Object> result = new ArrayList<>();
    while (current != null || !stack.isEmpty()) {
        // 将current node的所有右子节点全放到栈里，一致循环直到右子node为null
        while (current != null) {
            stack.push(current);
            // 要移动current node的位置给current node (即right node)
            result.add(current.getData());
            current = current.getRightChild();
        }

        // 如果栈不为空，那就从栈中弹出栈顶元素，输出
        // 将current node的left node给 current node，供下次循环找其所有的right node
        if (!stack.isEmpty()) {
            current = stack.pop();
            current = current.getLeftChild();
        }
    }
    // 反转下结果
    Collections.reverse(result);
    System.out.println(result);
}

img

思路：
此要放结合前序栈方式遍历来理解(前序栈方式，以左子节点为先，一直while循环压榨)，而这后序栈方式，以右为先进行压栈
不过最后结果饭的，需要反转一下

4-2-8.水平遍历
@Override
public void levelOrderByQueue() {
    Deque<TreeNode> queue = new LinkedList<>();
    if (root == null) {
        return;
    }
    List<Object> result = new ArrayList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int len = queue.size();
        // 遍历将stack里元素弹出
        for (int i = 0; i < len; i++) {
            TreeNode node = queue.poll();
            result.add(node.getData());
            TreeNode leftChild = node.getLeftChild();
            TreeNode rightChild = node.getRightChild();
            if (leftChild != null) {
                queue.offer(leftChild);
            }
            if (rightChild != null) {
                queue.offer(rightChild);
            }
        }
    }
    System.out.println(result);
}

img

水平遍历要借助队列的特性来处理，将每层的放进queue里队尾，从头取出(每次while加一层数据，需要取将queue里数据都取出)

4-3.整体代码

package com.iworkh.da.lesson03;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

/**
 * 自定义二叉树
 *
 * @author: iworkh-沐雨云楼
 * @date: 2020-07-02
 */
public class MyListBinaryTree implements ITree {

    private TreeNode root;

    public MyListBinaryTree(TreeNode root) {
        this.root = root;
    }

    @Override
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    public int size() {
        return size(this.root);
    }

    private int size(TreeNode node) {
        // 为null时返回0，不为null时加一
        if (node == null) {
            return 0;
        }
        int leftSize = size(node.getLeftChild());
        int rightSize = size(node.getRightChild());
        // 左右子节点都会掉一次，所以只要node为null的只要自己加一就行
        return leftSize + rightSize + 1;
    }

    @Override
    public int getHeight() {
        // 求深度，即求从root出来的child node谁最长
        return getHeight(root);
    }

    private int getHeight(TreeNode node) {
        if (node == null) {
            return 0;
        }
        // 左子节点
        int leftNum = getHeight(node.getLeftChild());

        // 右子节点
        int rightNum = getHeight(node.getLeftChild());

        // 返回大的+1
        return leftNum > rightNum ? leftNum + 1 : rightNum + 1;
    }

    @Override
    public TreeNode findKey(Object value) {
        return this.findKey(value, root);
    }

    private TreeNode findKey(Object value, TreeNode node) {
        if (node == null) {
            return null;
        }

        if (node.getData().equals(value)) {
            return node;
        }

        TreeNode leftNode = findKey(value, node.getLeftChild());

        TreeNode rightNode = findKey(value, node.getRightChild());

        if (leftNode != null) {
            return leftNode;
        }

        if (rightNode != null) {
            return rightNode;
        }

        return null;
    }

    @Override
    public void preOrderTraverse() {
        this.preOrderTraverse(root);
    }

    private void preOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        // d输出
        System.out.print(node.getData() + " ");
        // l处理
        preOrderTraverse(node.getLeftChild());
        // r处理
        preOrderTraverse(node.getRightChild());
    }

    @Override
    public void inOrderTraverse() {
        this.inOrderTraverse(root);
    }

    private void inOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        // l处理
        inOrderTraverse(node.getLeftChild());
        // d输出
        System.out.print(node.getData() + " ");
        // r处理
        inOrderTraverse(node.getRightChild());
    }

    @Override
    public void postOrderTraverse() {
        this.postOrderTraverse(root);
    }

    private void postOrderTraverse(TreeNode node) {
        if (node == null) {
            return;
        }
        // l处理
        postOrderTraverse(node.getLeftChild());
        // r处理
        postOrderTraverse(node.getRightChild());
        // d输出
        System.out.print(node.getData() + " ");
    }

    @Override
    public void preOrderByStack() {
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) {
            return;
        }

        // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
        // 指向树的当前移动node点
        TreeNode current = root;
        List<Object> result = new ArrayList<>();
        while (current != null || !stack.isEmpty()) {
            // 将current node的所有左子节点全放到栈里，一致循环直到左子node为null
            while (current != null) {
                // 输出
                result.add(current.getData());
                stack.push(current);
                // 要移动current node的位置给current node (即left node)
                current = current.getLeftChild();
            }

            // 如果栈不为空，那就从栈中弹出栈顶元素
            // 将current node的right node给 current node，供下次循环找其所有的left node
            if (!stack.isEmpty()) {
                current = stack.pop();
                current = current.getRightChild();
            }
        }
        System.out.println(result);
    }

    @Override
    public void inOrderByStack() {
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) {
            return;
        }

        // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
        // 指向树的当前移动node点
        TreeNode current = root;
        List<Object> result = new ArrayList<>();
        while (current != null || !stack.isEmpty()) {
            // 将current node的所有左子节点全放到栈里，一致循环直到左子node为null
            while (current != null) {
                stack.push(current);
                // 要移动current node的位置给current node (即left node)
                current = current.getLeftChild();
            }

            // 如果栈不为空，那就从栈中弹出栈顶元素，输出
            // 将current node的right node给 current node，供下次循环找其所有的left node
            if (!stack.isEmpty()) {
                current = stack.pop();
                result.add(current.getData());
                current = current.getRightChild();
            }
        }
        System.out.println(result);
    }

    @Override
    public void postOrderByStack() {

        // 方式一：
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) {
            return;
        }
        List<Object> result = new ArrayList<>();
        // 指向树的当前移动node点
        TreeNode current = null;
        // 指向当前移动node的其中一个子节点(即，栈上的上一个栈顶)
        TreeNode tmpChildNode = null;

        stack.push(root);
        while (!stack.isEmpty()) {
            current = stack.peek();
            if ((current.getLeftChild() == null && current.getRightChild() == null) || current.getLeftChild() == tmpChildNode || current
                    .getRightChild() == tmpChildNode) {
                result.add(current.getData());
                stack.pop();
                tmpChildNode = current;
            } else {
                // 先添加right child node ，因为栈是LIFO
                if (current.getRightChild() != null) {
                    stack.push(current.getRightChild());
                }
                // 再添加left child node ，因为栈是LIFO
                if (current.getLeftChild() != null) {
                    stack.push(current.getLeftChild());
                }
            }
        }
        System.out.println(result);


        // 方式二
        // Deque<TreeNode> stack = new LinkedList<>();
        // if (root == null) {
        //     return;
        // }
        //
        // // 心法：以当前node移动，根据DLR、LDR、LRD的顺序去如何存取到stack中去
        // // 指向树的当前移动node点
        // TreeNode current = root;
        // List<Object> result = new ArrayList<>();
        // while (current != null || !stack.isEmpty()) {
        //     // 将current node的所有右子节点全放到栈里，一致循环直到右子node为null
        //     while (current != null) {
        //         stack.push(current);
        //         // 要移动current node的位置给current node (即right node)
        //         result.add(current.getData());
        //         current = current.getRightChild();
        //     }
        //
        //     // 如果栈不为空，那就从栈中弹出栈顶元素，输出
        //     // 将current node的left node给 current node，供下次循环找其所有的right node
        //     if (!stack.isEmpty()) {
        //         current = stack.pop();
        //         current = current.getLeftChild();
        //     }
        // }
        // // 反转下结果
        // Collections.reverse(result);
        // System.out.println(result);
    }

    @Override
    public void levelOrderByQueue() {
        Deque<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return;
        }
        List<Object> result = new ArrayList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int len = queue.size();
            // 遍历将stack里元素弹出
            for (int i = 0; i < len; i++) {
                TreeNode node = queue.poll();
                result.add(node.getData());
                TreeNode leftChild = node.getLeftChild();
                TreeNode rightChild = node.getRightChild();
                if (leftChild != null) {
                    queue.offer(leftChild);
                }
                if (rightChild != null) {
                    queue.offer(rightChild);
                }
            }
        }
        System.out.println(result);
    }
}

4-4.测试代码

造的tree就是我们前面文章一直分析的树

img

public class MyListBinaryTreeTest {
    public static void main(String[] args) {
        TreeNode root = genBTree();

        MyListBinaryTree myListBinaryTree = new MyListBinaryTree(root);

        System.out.println("是否为空：" + myListBinaryTree.isEmpty());
        System.out.println("树的高度：" + myListBinaryTree.getHeight());
        System.out.println("树节点数：" + myListBinaryTree.size());

        System.out.println("查找3： " + myListBinaryTree.findKey(3));
        System.out.println("查找20：" + myListBinaryTree.findKey(20));

        System.out.println("前序递归遍历：");
        myListBinaryTree.preOrderTraverse();
        System.out.println("");
        System.out.println("中序递归遍历：");
        myListBinaryTree.inOrderTraverse();
        System.out.println("");
        System.out.println("后序递归遍历：");
        myListBinaryTree.postOrderTraverse();
        System.out.println("");

        System.out.println("前序栈遍历：");
        myListBinaryTree.preOrderByStack();
        System.out.println("");
        System.out.println("中序栈遍历：");
        myListBinaryTree.inOrderByStack();
        System.out.println("");
        System.out.println("后序栈遍历：");
        myListBinaryTree.postOrderByStack();
        System.out.println("");
        System.out.println("水平队列遍历：");
        myListBinaryTree.levelOrderByQueue();
    }

    private static TreeNode genBTree() {
        TreeNode treeNode6 = new TreeNode(6, null, null);
        TreeNode treeNode7 = new TreeNode(7, null, null);
        TreeNode treeNode4 = new TreeNode(4, treeNode6, treeNode7);

        TreeNode treeNode9 = new TreeNode(9, null, null);
        TreeNode treeNode8 = new TreeNode(8, null, treeNode9);
        TreeNode treeNode5 = new TreeNode(5, treeNode8, null);

        TreeNode treeNode2 = new TreeNode(2, treeNode4, treeNode5);

        TreeNode treeNode10 = new TreeNode(10, null, null);
        TreeNode treeNode12 = new TreeNode(12, null, null);
        TreeNode treeNode11 = new TreeNode(11, null, treeNode12);

        TreeNode treeNode3 = new TreeNode(3, treeNode10, treeNode11);

        return new TreeNode(1, treeNode2, treeNode3);
    }
}

结果

是否为空：false
树的高度：4
树节点数：12
查找3： TreeNode{data=3, leftChild=10, rightChild=11}
查找20：null
前序递归遍历：
1 2 4 6 7 5 8 9 3 10 11 12 
中序递归遍历：
6 4 7 2 8 9 5 1 10 3 11 12 
后序递归遍历：
6 7 4 9 8 5 2 10 12 11 3 1 
前序栈遍历：
[1, 2, 4, 6, 7, 5, 8, 9, 3, 10, 11, 12]

中序栈遍历：
[6, 4, 7, 2, 8, 9, 5, 1, 10, 3, 11, 12]

后序栈遍历：
[6, 7, 4, 9, 8, 5, 2, 10, 12, 11, 3, 1]

水平队列遍历：
[1, 2, 3, 4, 5, 10, 11, 6, 7, 8, 12, 9]

5.链接

6.推荐

能读到文章最后，首先得谢谢您对本文的肯定，你的肯定是对博主最大的鼓励。

你觉本文有帮助，那就点个👍
你有疑问，那就留下您的💬
怕把我弄丢了，那就把我⭐
电脑不方便看，那就把发到你📲

pgmanor
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树
dasd
03-07 250
树 对于大量的输入数据，链表的线性访问时间太慢，不宜使用。本章讨论一种简单的数据结构，其大部分操作的运行时间平均为O(log N)。我们要简述这种数据结构上在概念上的简单修改，它保证了在最坏清醒下上述的时间界。此外，还讨论了第二种修改，对于长的指令序列它基本上给出每种操作O(log N)运行时间。 这种数据结构叫做二叉查找树（binary search tree）。二叉查找树是两种库集合类Tree...
【数据结构】树（一）—— 树的基础知识（C语言版）
haoweixl的博客
05-09 1816
树的基础知识树的定义树的相关概念度(Degree)结点间的关系结点的 层次(Level)有序树与森林线性表和树的不同树的抽象数据类型树的存储结构双亲表示法双亲表示法的优化孩子表示法孩子兄弟表示法 树的定义 树(Tree)是 n(n≥0)个结点的有限集。 n=0 时称为空树。 在任意一颗非空树中： （1）有且仅有一个特定的称为根(Root)的结点 （2）当 n>1时，其余结点可分为 m(m>0)个互不相交的有限集 T1、T2、…、Tm， 其中每一个集合本身又是一棵树，并且称为根的子树(SubTre
【数据结构oj】树的度（树和二叉树的相互转化）
qq_25218219的博客
11-15 1351
输入：ABC##DE#F#G#### 输出：3   不难看出， 以二叉树方式存储的树，二叉树结点a的左孩子就是树结点a的左孩子，而二叉树a的右孩子是树节点的a的兄弟，既a父节点f_a的某个孩子（非长子） 那么，可以通过遍历树的每个结点，编写算法，计算出每个结点的度（既树的孩子数目），找出其中最大的度，作为该树的度输出。 第一版代码 #include <stdio.h> #include <stdlib.h> int Max_degree = 0; typedef st.
30 | 图的表示：如何存储微博、微信等社交网络中的好友关系？
liyf2的博客
10-26 862
微博、微信、LinkedIn 这些社交软件我想你肯定都玩过吧。在微博中，两个人可以互相关注；在微信中，两个人可以互加好友。那你知道，如何存储微博、微信等这些社交网络的好友关系吗？ 这就要用到我们今天要讲的这种数据结构：图。实际上，涉及图的算法有很多，也非常复杂，比如图的搜索、最短路径、最小生成树、二分图等等。我们今天聚焦在图存储这一方面，后面会分好几节来依次讲解图相关的算法。 如何理解“图”？ 我们前面讲过了树这种非线性表数据结构，今天我们要讲另一种非线性表数据结构，图（Graph）。和树比起来，这是一种更
数据结构——非线性结构（树与二叉树）
巧克力布丁的博客
08-20 2911
1）有且只有一个称为根的节点2）有若干个互不相交的子树，这些子树本身也是一棵树（递归定义）1）树是由节点和边组成2）每个节点只有一个父节点但可以有多个子节点3）但有一个节点除外，该节点没有父节点，此节点称为根节点（n个节点的树中有n-1条边）后序遍历左子树后序遍历右子树再访问根节点递归遍历左右子树顺序是固定的，只是访问根的顺序不同。时间复杂度O(n)：因为不管采用哪种遍历算法，每个节点都访问一次。
数据结构与算法设计-王晓东PPT
09-21
第5章介绍递归以及递归在数据结构和算法设计中的应用；第6章介绍实际应用中常用的排序与选择算法；第7～12章讨论反映层次关系的数据结构树、表示集合的抽象数据类型、符号表以及散列表等实践中常用实现符号表的方法...
武汉理工大学数据结构与算法实验——欢乐连连看（非线性结构）
06-22
注意：这是武汉理工大学数据结构与算法实验欢乐连连看的非线性结构!!!!!!注意这是非线性的，实验完成了除闯关模式和排行榜以外的所有功能，已经验收通过
大数据-算法-Hammerstein非线性系统辨识算法研究马亮.pdf
04-15
大数据-算法-Hammerstein非线性系统辨识算法研究马亮.pdf
大数据-算法-关于若干非线性问题算法.pdf
04-16
大数据-算法-关于若干非线性问题算法.pdf
大数据-算法-一些非线性发展方程组的辛和多辛算法.pdf
04-15
大数据-算法-一些非线性发展方程组的辛和多辛算法.pdf
数据结构
Xu_Haocan的博客
01-13 250
定义 n(n&amp;amp;amp;amp;gt;=0)个节点构成的有限集合（n=0则空树） 性质 1.子树是互不相交的 2.除了根节点之外，每个节点有且只有一个父节点（根节点没有父节点） 3.一棵树N个节点有N-1条边 基本术语 1.节点的度（degree）：节点的子树个数 2.树的度（degree）：树种所有节点中最大的度数（节点的度的最大值） 3.叶节点（leaf）：度为0的节点 4.父节点（parent） 5.子节点（...
大话数据结构 －－ 图
Maggie的博客
09-05 6682
图的各种定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 在图形结构中，结点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。 图与其他数据结构的不同之处见下表： 数据结构 结点之间关系 数据元素名称 数据元素可否没有 线性表 一对一 元素 可以（...
数据结构-树的基本概念
qq_46249770的博客
12-03 650
1.基本概念 度数（Degree）：每个节点所有子树的个数。 层数（Level）：树的层数。 高度（Height）：树的最大层数。 树叶或终端节点（Terminal Node）：度数为零的节点就是树叶。 2.树的存储 一般树结构在计算机内存中的存储方式是以链表为主。对于n叉树来说，因为每个节点的读书都不相同，所以我们必须为每个节点都预留存放n个链接字段的最大存储空间。 我们可以知道： n=2时，2叉树的链接浪费率约为1/2； n=3时，3叉树的链接浪费率约为2/3； n=4时，4叉树的链接浪费率约为3/4；
java tree degree_树-概念和分类 - 老弟，来啦？ - OSCHINA - 中文开源技术交流社区
weixin_39632471的博客
03-07 391
树的定义树是一种数据结构，它是由n(n>=1)个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个结点有零个或多个子结点；每一个子结点只有一个父结点；没有前驱的结点为根结点；除了根结点外，每个子结点可以分为m个不相交的子树；树的表示树形图集合包含关系文氏图法凹入表表示法广义表表示法(A(B(E，F(I，J))...
树(Tree)
Catherine的笔记
10-11 8477
树(Tree) 1. 树的概念 树形结构是以分支关系定义的层次结构，是一类重要的非线性数据结构。 树是包含n(n>0)个结点的有穷集，也就说树是由一个集合以及在该集合上定义的一种关系构成的。 树可分为无根树(自由树、无序树)和有根树(系统树、有序树)。 (1)无根树(unrooted tree)： 在离散数学中指无环连通无向图。 (2)有根树(rooted tree)：指具有方向的系统发生树(phylogen
树的一些基本术语
古道湫风的博客
12-13 835
1、结点的度(Degree)：结点的子树个数 2、树的度：树的所有结点中最大的度数 3、叶节点(Leaf)：度为0的结点 4、父节点(Parent)：有子树的结点，是其子树的根结点的父节点 5、子结点(Child)：若A结点是B结点的父结点，则B称为A的子结点；子结点也称为孩子节点 6、兄弟节点(Sibling)：具有同一父结点的各结点彼此是兄弟结点 7、路径和长度：从结点n1到nk的路径为一个结...
树（Tree）相关知识
UncleMing5371的博客
01-05 830
数据结构中最重要的一种结构——树（Tree）相关知识的介绍，本文包括对树的定义、节点、树的度、树的深度等相关内容的介绍，以及最重要的数的存储结构的形式。
从递归（代码）的角度理解二叉树的先序/中序/后序三种遍历顺序
热门推荐
zhang197093的博客
04-28 1万+
二叉树的遍历原理其实是很简单的，就是从二叉树的根节点开始，把它的左节点以及左节点下面的节点再当作一棵二叉树，和右节点以及右节点下面的节点也再当作一棵二叉树，依此类推，直到节点下面没有节点为止。二叉树的有三种遍历顺序：先序遍历、中序遍历、后序遍历，而这个顺序都是以根节点作为参照的，最先遍历根节点就是先序遍历，最后遍历根节点就是后序遍历，根节点放在左右节点之间的情况就是中序遍历。先看代码：#inclu...
数据结构：树
OR的博客
08-15 1388
一、数的定义现实生活中，有很多一对多的情况需要处理，所以我们需要研究这种一对多的数据结构——“树”，考虑到它的各种特性，来解决在编程中碰到的相关问题。树(Tree)是n（n≥0）个结点的有限集。n = 0时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n ≥ 1时，其余结点可分为m（m>0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本身又是一棵
线性数据结构和非线性
最新发布
08-21
数据构根据元素之间的关系可以分为线性数据结构和非线性数据结构。 线性数据结构是指数据元素之间存在一对一的关系，即每个元素只有一个直接前驱和一个直接后继。常见的线性数据结构有数组、链表、栈和队列等。其中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值