树以及常用的算法

树的概念

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

二叉树的概念

每个结点至多拥有两棵子树(即二叉树中不存在度大于2的结点),并且,二叉树的子树有左右之分,其次序不能任意颠倒。
二叉树的性质
1.若二叉树的层次从0开始,则在二叉树的第i层至多有2^i个结点(i>=0)
2.高度为k的二叉树最多有2^(k+1) - 1个结点(k>=-1)(空树的高度为-1)
3.对任何一棵二叉树,如果其叶子结点(度为0)数为m, 度为2的结点数为n, 则m = n + 1

二叉树的分类

二叉树又分为:完美二叉树,完全二叉树,完满二叉树
其中完满二叉树:除了叶子节点每个节点都有俩个孩子
完全二叉树:除了最后一层外,除了叶子节点每个节点都有俩个孩子
完美二叉树:除了叶子节点外,每一层每个节点都有俩个孩子

完美二叉树
完全二叉树
完满二叉树
完满二叉树

二叉树常见的搜索算法,借助leetcode展示

前序遍历

import java.util.ArrayList;
import java.util.List;
import java.util.Stack; /**
 * Given a binary tree, return the preorder traversal of its TreeNodes' values.
 */
public class Lc144 {     /*
     * 前序遍历 :根左右 思路;将当前节点压入栈中,一直遍历左子树知道当前节点为空,向上弹出遍历一下右子树。
     */
    public static List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();
        TreeNode curr = root;
        while (curr != null || !stack.isEmpty()) {
            while (curr != null) {
                list.add(curr.val);
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop();
            curr = curr.right;
        }
        return list;
    }     public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, 2, null};
        TreeNode root = CreateNode.createTree(arr).get(0);
        List<Integer> list = preorderTraversal(root);
        list.forEach(n -> System.out.println(n));
    } }

中顺遍历

import java.util.ArrayList;
import java.util.List;
import java.util.Stack; /**
 * Given a binary tree, return the inorder traversal of its nodes' values.
 */
public class Lc94 {     /*
     * 中序遍历:左根右
     */
    public static List<Integer> orderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> preorder = new ArrayList<Integer>();
        TreeNode curr = root;         while (!stack.isEmpty() || curr != null) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }
            curr = stack.pop();
            preorder.add(curr.val);
            curr = curr.right;
        }
        return preorder;
    }     public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, null, 2, null, null, 3 };
        TreeNode root = CreateNode.createTree(arr).get(0);
        List<Integer> list = orderTraversal(root);
        list.forEach(n -> System.out.println(n));
    } }

后序遍历

import java.util.ArrayList;
import java.util.List;
import java.util.Stack; public class Lc145 {     /*
     * 后续序遍历:左右根
     */
    public static List<Integer> postorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> list = new ArrayList<>();         if (root == null) {
            return list;
        }         TreeNode curr = root;
        stack.push(curr);
        while (!stack.isEmpty()) {
            curr = stack.pop();
            list.add(0, curr.val);
            if (curr.left != null) {
                stack.push(curr.left);
            }
            if (curr.right != null) {
                stack.push(curr.right);
            }
        }
        return list;
    }     public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, null, 2 };
        TreeNode root = CreateNode.createTree(arr).get(0);
        List<Integer> list = postorderTraversal(root);
        list.forEach(n -> System.out.println(n));
    } }

层序遍历

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue; public class Lc102 {     /**
     * 层序遍历
     * 
     * @param root
     * @return
     */
    public static List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<>();
        if (root == null) {
            return lists;
        }         TreeNode curr = root;
        queue.offer(curr);
        int size = queue.size();
        while (!queue.isEmpty()) {
            curr = queue.poll();
            list.add(curr.val);
            size--;
            if (curr.left != null) {
                queue.offer(curr.left);
            }
            if (curr.right != null) {
                queue.offer(curr.right);
            }
            if (size == 0) {
                lists.add(list);
                list = new ArrayList<>();
                size = queue.size();
            }         }
        return lists;
    }     public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, 2, 3, 4, 5, 6, 7 };
        TreeNode root = CreateNode.createTree(arr).get(0);
        List<List<Integer>> lists = levelOrder(root);
        lists.forEach(n -> {
            n.forEach(m -> {
                System.out.print(m + ",");
            });
            System.out.println();
        });     }
}

BFS

public class Lc100 {

    //bfs 递归
    public static boolean isSameTree(TreeNode p, TreeNode q) {         if (p == null || q == null) {
            return p == q ? true : false;
        } else {
            if (p.val != q.val) {
                return false;
            } else {
                return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
            }
        }     }     public static void main(String[] args) {
        Integer[] arr = new Integer[] { 1, 2, 2, 3, null, null, 3 };
        TreeNode root = CreateNode.createTree(arr).get(0);
        System.out.println(isSameTree(root.left, root.right));     }
}

介绍一个二叉树数组转换节点的工具类

使用方法,每一个main函数中都是
import java.util.ArrayList;
import java.util.List; public class CreateNode {     public static List<TreeNode> list = new ArrayList<TreeNode>(); // 用一个集合来存放每一个Node     public static List<TreeNode> createTree(Integer[] array) {
        list.clear();
        for (int i = 0; i < array.length; i++) {
            TreeNode TreeNode = new TreeNode(array[i], null, null); // 创建结点,每一个结点的左结点和右结点为null
            list.add(TreeNode); // list中存着每一个结点
        }
        // 构建二叉树
        if (list.size() > 0) {
            for (int i = 0; i < array.length / 2 - 1; i++) { // i表示的是根节点的索引,从0开始
                if (list.get(2 * i + 1) != null) {
                    // 左结点
                    list.get(i).left = list.get(2 * i + 1);
                }
                if (list.get(2 * i + 2) != null) {
                    // 右结点
                    list.get(i).right = list.get(2 * i + 2);
                }
            }
            // 判断最后一个根结点:因为最后一个根结点可能没有右结点,所以单独拿出来处理
            int lastIndex = array.length / 2 - 1;
            // 左结点
            list.get(lastIndex).left = list.get(lastIndex * 2 + 1);
            // 右结点,如果数组的长度为奇数才有右结点
            if (array.length % 2 == 1) {
                list.get(lastIndex).right = list.get(lastIndex * 2 + 2);
            }
        }
        return list;
    } // 遍历,先序遍历
    public static void print(TreeNode TreeNode) {
        if (TreeNode != null) {
            System.out.print(TreeNode.val + " ");
            print(TreeNode.left);
            print(TreeNode.right);
        }
    }     /**
     * @param args
     */
    public static void main(String[] args) {
        Integer[] array = { 1, 2, 2, null, 3, null, 3 };
        CreateNode.createTree(array);
        print(list.get(0));
    }
}
基础类-节点 public class TreeNode {     public Integer val; // 自己本身值
    public TreeNode left; // 左结点
    public TreeNode right; // 右结点     public TreeNode() {
    }     public TreeNode(Integer val, TreeNode left, TreeNode right) {
        super();
        this.val = val;
        this.left = left;
        this.right = right;
    }     public int getVal() {
        return val;
    }     public void setVal(Integer val) {
        this.val = val;
    }     public TreeNode getLeft() {
        return left;
    }     public void setLeft(TreeNode left) {
        this.left = left;
    }     public TreeNode getRight() {
        return right;
    }     public void setRight(TreeNode right) {
        this.right = right;
    } }

leetcode-二叉树的更多相关文章

  1. LeetCode二叉树实现

    LeetCode二叉树实现 # 定义二叉树 class TreeNode: def __init__(self, x): self.val = x self.left = None self.righ ...

  2. LeetCode 二叉树,两个子节点的最近的公共父节点

    LeetCode 二叉树,两个子节点的最近的公共父节点 二叉树 Lowest Common Ancestor of a Binary Tree 二叉树的最近公共父亲节点 https://leetcod ...

  3. leetcode二叉树题目总结

    leetcode二叉树题目总结 题目链接:https://leetcode-cn.com/leetbook/detail/data-structure-binary-tree/ 前序遍历(NLR) p ...

  4. [LeetCode] 二叉树相关题目(不完全)

    最近在做LeetCode上面有关二叉树的题目,这篇博客仅用来记录这些题目的代码. 二叉树的题目,一般都是利用递归来解决的,因此这一类题目对理解递归很有帮助. 1.Symmetric Tree(http ...

  5. LeetCode二叉树的前序、中序、后序遍历(递归实现)

    本文用递归算法实现二叉树的前序.中序和后序遍历,提供Java版的基本模板,在模板上稍作修改,即可解决LeetCode144. Binary Tree Preorder Traversal(二叉树前序遍 ...

  6. LeetCode 二叉树的层次遍历

    第102题 给定一个二叉树,返回其按层次遍历的节点值. (即逐层地,从左到右访问所有节点). 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 ...

  7. LeetCode 二叉树的锯齿形层次遍历

    第103题 给定一个二叉树,返回其节点值的锯齿形层次遍历.(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行). 例如: 给定二叉树 [3,9,20,null,null,15,7] ...

  8. Leetcode——二叉树常考算法整理

    二叉树常考算法整理 希望通过写下来自己学习历程的方式帮助自己加深对知识的理解,也帮助其他人更好地学习,少走弯路.也欢迎大家来给我的Github的Leetcode算法项目点star呀~~ 二叉树常考算法 ...

  9. LeetCode 二叉树的最小深度

    计算二叉树的最小深度.最小深度定义为从root到叶子节点的最小路径. public class Solution { public int run(TreeNode root) { if(root = ...

  10. LeetCode - 二叉树的最大深度

    自己解法,欢迎拍砖 给定一个二叉树,找出其最大深度. 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数. 说明: 叶子节点是指没有子节点的节点. 示例:给定二叉树 [3,9,20,null,nu ...

随机推荐

  1. Vue项目中实现用户登录及token验证

    学习博客:https://www.cnblogs.com/web-record/p/9876916.html

  2. skipping archived logs of thread 1 from sequence 29 to 46; already backed up

    问题描述:删除归档的备份,在进行归档的重新备份,提示:skipping archived logs of thread 1 from sequence 29 to 46; already backed ...

  3. Spring Cloud第九篇 | 分布式服务跟踪Sleuth

    ​ ​本文是Spring Cloud专栏的第九篇文章,了解前八篇文章内容有助于更好的理解本文: Spring Cloud第一篇 | Spring Cloud前言及其常用组件介绍概览 Spring Cl ...

  4. django----session相关配置

    1. 数据库Session SESSION_ENGINE = 'django.contrib.sessions.backends.db' # 引擎(默认) 2. 缓存Session SESSION_E ...

  5. webpack学习1.1 webpack背景介绍

    一.为什么要前端需要构建? 开发复杂化 框架去中心化(代码中需要的模块都可以通过npm安装佢解决一个问题,包越来越零散,根据需要来安装) 开发编译化 语言模块化 二.为什么要用webpack? 1.三 ...

  6. CSS | 圣杯布局、双飞翼布局 | 自适应三栏布局

    圣杯布局和双飞翼布局是前端工程师需要日常掌握的重要布局方式.两者的功能相同,都是为了实现一个两侧宽度固定,中间宽度自适应的三栏布局 虽然两者的实现方法略有差异,不过都遵循了以下要点: 1.两侧宽度固定 ...

  7. 《Java练习题》进阶练习题(三)

    编程合集: https://www.cnblogs.com/jssj/p/12002760.html 前言:不仅仅要实现,更要提升性能,精益求精,用尽量少的时间复杂度和空间复杂度解决问题. [程序68 ...

  8. 《CSAPP》实验一:位操作

    <CSAPP>号称程序员圣经,虽然中文译名为<深入理解计算机系统>,但其实没那么"深",只是覆盖面很广,一般用作计算机专业大一导论课的教科书.早就听闻书上配 ...

  9. SpringCloud-使用熔断器仪表盘监控熔断

    场景 SpringCloud-使用熔断器防止服务雪崩-Ribbon和Feign方式(附代码下载): https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/ ...

  10. 开源WAF工具ModSecurity

    0 前言 ModSecurity是一个开源的跨平台Web应用程序防火墙(WAF)引擎,用于Apache,IIS和Nginx,由Trustwave的SpiderLabs开发.作为WAF产品,ModSec ...