算法与数据结构-二叉树 讲解与java代码实现

最新推荐文章于 2024-04-22 12:49:02 发布
最新推荐文章于 2024-04-22 12:49:02 发布
阅读量376 收藏 3
点赞数
分类专栏： 算法 文章标签： 牛客网 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bury_/article/details/78989963
版权

1. 三种遍历方式和宽度优先遍历

二叉树遍历方式

  • 递归实现先序，中序，后序遍历
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class TreeToSequence {
    public int[][] convert(TreeNode root) {
        // write code here

        ArrayList<Integer> temp1=new ArrayList<Integer>();
        ArrayList<Integer> temp2=new ArrayList<Integer>();
        ArrayList<Integer> temp3=new ArrayList<Integer>();

        pre(root,temp1);
        mid(root,temp2);
        post(root,temp3);
        int[][] result=new int[3][temp1.size()];
        for(int i=0;i<temp1.size();i++){
            result[0][i]=temp1.get(i);
            result[1][i]=temp2.get(i);
            result[2][i]=temp3.get(i);
        }

        return result;
    }

    public void pre(TreeNode root,ArrayList<Integer> result){
        if(root==null){
            return;
        }

        result.add(root.val);
        pre(root.left,result);
        pre(root.right,result);
    }

    public void mid(TreeNode root,ArrayList<Integer> result){
        if(root==null){
            return;
        }

        mid(root.left,result);
        result.add(root.val);
        mid(root.right,result);
    }

    public void post(TreeNode root,ArrayList<Integer> result){
     if(root==null){
         return;

     }   
        post(root.left,result);
        post(root.right,result);
        result.add(root.val);
    }
}
  • 非递归实现先序，中序，后序遍历
    非递归先序
    非递归中序
    非递归后序2个栈
    非递归后序1个栈
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class TreeToSequence {
    public int[][] convert(TreeNode root) {
        // write code here

        ArrayList<Integer> preRes=pre(root);
        ArrayList<Integer> midRes=mid(root);
        //ArrayList<Integer> postRes=post(root);
        ArrayList<Integer> postRes=post_oneStack(root);

        int[][] result=new int[3][preRes.size()];

        for(int i=0;i<preRes.size();i++){
            result[0][i]=preRes.get(i);
            result[1][i]=midRes.get(i);
            result[2][i]=postRes.get(i);
        }

        return result;
    }
    //非递归的先序遍历
    public ArrayList<Integer> pre(TreeNode root){
           Stack<TreeNode> stack=new Stack<TreeNode>();
        ArrayList<Integer> result=new ArrayList<Integer>();
        stack.push(root);
        TreeNode cur;
        while(!stack.isEmpty()){
            cur=stack.pop();
            result.add(cur.val);
            if (cur.right!=null){
               stack.push(cur.right);
            }
            if(cur.left!=null){
                stack.push(cur.left);
            }
        }
        return result;
    }

    public ArrayList<Integer> mid(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        ArrayList<Integer> result=new ArrayList<Integer>();
        TreeNode cur;
        cur=root;
        while(cur!=null||!stack.isEmpty()){
            //将左子树依次压入栈
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            //当左子树全部压入栈后，开始从栈顶取元素并指定cur等于右子树
            cur=stack.pop();
            result.add(cur.val);
            cur=cur.right;
        }
        return result;
    }

    public ArrayList<Integer> post(TreeNode root){
        Stack<TreeNode> stack1=new Stack<TreeNode>();
        Stack<TreeNode> stack2=new Stack<TreeNode>();
        ArrayList<Integer> result=new ArrayList<Integer>();
        TreeNode cur;
        stack1.push(root);
        while(!stack1.isEmpty()){
            cur=stack1.pop();
            stack2.push(cur);
            if(cur.left!=null){
                stack1.push(cur.left);
            }
            if(cur.right!=null){
                stack1.push(cur.right);
            }
        }

        while(!stack2.isEmpty()){
            cur=stack2.pop();
            result.add(cur.val);
        }

        return result;

    }

    public ArrayList<Integer> post_oneStack(TreeNode root){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        ArrayList<Integer> result=new ArrayList<Integer>();
        TreeNode lastNode=root,cur=null;//分别指向上次打印的节点以及当前节点

        while(!stack.isEmpty()){
            cur=stack.peek();
            if(cur.left!=null&&cur.left!=lastNode&&cur.right!=lastNode){
                stack.push(cur.left);
            }else if(cur.right!=null&&cur.right!=lastNode){
                stack.push(cur.right);
            }else{
                cur=stack.pop();
                result.add(cur.val);
                lastNode=cur;
            }
        }

              return result;


    }
}

宽度优先遍历（按层从左到右遍历）

宽度优先遍历

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class TreePrinter {
    public int[][] printTree(TreeNode root) {
        //保存每一行的值
        ArrayList<Integer> temp=new ArrayList<Integer>();
        //保存总的结果的list
        ArrayList<ArrayList<Integer>> resList=new ArrayList<ArrayList<Integer>>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();//队列，因为是按层从左到右遍历，先进先出
        queue.offer(root);
        TreeNode cur=root,last=root,nlast=null;//分别是当前节点，本层最后一个节点，下一层最后一个节点
        while(!queue.isEmpty()){
            cur=queue.poll();
            temp.add(cur.val);
            if(cur.left!=null){
                queue.offer(cur.left);
                nlast=cur.left;
            }
            if(cur.right!=null){
                queue.offer(cur.right);
                nlast=cur.right;
            }
            //如果当前节点为本层最后一个节点，则要把现在的节点加入结果，并令last等于nlast
            if(cur==last){
                resList.add(temp);
                temp=new ArrayList<Integer>();//不能使用Clear清空，否则存进入的就变成了空，因为保存的是引用
                last=nlast;
            }
        }
        int layers=resList.size();
        int[][] result=new int[layers][];
        for(int i=0;i<layers;i++){
            result[i]=new int[resList.get(i).size()];
            for(int j=0;j<result[i].length;j++){
                result[i][j]=resList.get(i).get(j);
            }
        }

        return result;


    }
}

二叉树的序列化打印：先序遍历

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class TreeToString {
    public String toString(TreeNode root) {
        // write code here
        Stack<TreeNode> stack=new Stack<TreeNode>();
        String result=new String();
        stack.push(root);
        TreeNode cur;
        while(!stack.isEmpty()){
            cur=stack.pop();
            if(cur==null){
                result+="#!";
            }else{
                result+=cur.val+"!";
                stack.push(cur.right);
                stack.push(cur.left);
            }
        }
        return result;
    }
}

纸张对折n次，求折痕方向：使用中序逆序遍历，此处的逆序可以省去，因为是题目规定哪个方向为正
这里写图片描述
折纸方向打印 实现

import java.util.*;
public class FoldPaper {
    public String[] foldPaper(int n) {
        // write code here
           ArrayList<String> temp=new ArrayList<String>();
        //dir false表示"down"，true表示"up"
        printDir(n,false,temp);
        int nodeSize=temp.size();
        String[] result=new String[nodeSize];
        for(int i=0;i<nodeSize;i++){
            result[i]=temp.get(i);
        }
        return result;
    }
    //中序逆序遍历递归打印
    public void printDir(int n,boolean dir,ArrayList<String> result){
        if(n<1){
            return;
        }
        printDir(n-1,false,result);
        result.add(dir?"up":"down");
        printDir(n-1,true,result);
    }
}

树上最远距离
这里写图片描述
这里写图片描述
这里写图片描述

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class LongestDistance {
    public int findLongest(TreeNode root) {

        int max=getDistance(root,0)[1];
        return max;
    }

    //节点只能经过一次，那么当前节点的左右两边最远距离是最可能为最大距离的，每次要计算这个值
    //同时需要返回距离头结点的单边最远距离为后续计算提供依据
    //第一个返回参数为当前头结点的单边最远距离，第二个返回的参数为当前已经求得的最远距离
    public int[] getDistance(TreeNode root,int max){
        int[] result=new int[2];
        result[1]=max;
        if(root==null){
            result[0]=0;
            return result;
        }
        int[] leftRes=getDistance(root.left,max);
        int[] rightRes=getDistance(root.right,max);
        int lDistToRoot=leftRes[0];
        int rDistToRoot=rightRes[0];
        int twoSideDist=lDistToRoot+rDistToRoot+1;
        max=Math.max(leftRes[1],rightRes[1]);
        if(twoSideDist>max){
            max=twoSideDist;
        }
        result[0]=Math.max(lDistToRoot,rDistToRoot)+1;
        result[1]=max;
        return result;

    }
}

2.三种树及其判定方法

  • 二叉树的子树定义
    子树定义
  • 平衡二叉树的定义
    平衡二叉树定义
    平衡二叉树的递归判定
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class CheckBalance {
    public boolean check(TreeNode root) {
        // write code here
        return getHeight(root)>=0;
    }
    //递归 求以root为头结点的树的最大高度
    public int getHeight(TreeNode root){
        //如果是空节点或者空树，则高度为0
        if(root==null){
            return 0;
        }
        int left=getHeight(root.left);
        int right=getHeight(root.right);
        //如果左子树或者右子树不平衡，则返回-1
        if(left<0||right<0){
            return -1;
        }
        //如果左子树或者右子树高度差大于1，则返回-1
        if(Math.abs(left-right)>1){
            return -1;
        }
        //返回左子树和右子树中最大的高度作为本棵树的高度
        return left>right?left+1:right+1;
    }
}
  • 搜索二叉树
    搜索二叉树的定义
    最大搜索子树
    最大搜索子树
    这里写图片描述
    这里写图片描述
    最大搜索二叉子树递归判定
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class MaxSubtree {
    public int nodeNum=0;//以当前节点为根节点的树的节点数
    public int MAX=Integer.MAX_VALUE;
    public int MIN=Integer.MIN_VALUE;
    public int max,min;//以当前节点为根节点的树的最大最小值

    public TreeNode getMax(TreeNode root) {
        return getInfo(root);
    }

    public TreeNode getInfo(TreeNode root){
        int lNodeNum=0,rNodeNum=0;//左子树，右子树的节点数
        int lMax,lMin;//左子树的最大节点值，最小节点值
        int rMax,rMin;
        TreeNode lSearchRoot,rSearchRoot;//左右子树如果是二叉搜索树，则保存他们的头结点引用，若为null，则不是二叉搜索树
        if(root==null){
            nodeNum=0;
            max=MIN;
            min=MAX;
            return null;
        }

        lSearchRoot=getInfo(root.left);
        lNodeNum=nodeNum;
        lMax=max;lMin=min;

        rSearchRoot=getInfo(root.right);
        rNodeNum=nodeNum;
        rMax=max;rMin=min;

        min=Math.min(root.val,lMin);
        max=Math.max(root.val,rMax);
        nodeNum=Math.max(lNodeNum,rNodeNum);
        //当前树为二叉搜索树，要求左子树和右子树均为二叉搜索树，且以当前节点为头结点的树为二叉搜索树
        //此处子树的二叉搜索树判定不能写成lSearchRoot！=null，因为要考虑到有叶节点的情况
        if(lSearchRoot==root.left&&rSearchRoot==root.right&&lMax<root.val&&root.val<rMin){
            nodeNum=lNodeNum+rNodeNum+1;
            return root;
        }
        if(lNodeNum==rNodeNum){
            return lSearchRoot.val>rSearchRoot.val?lSearchRoot:rSearchRoot;
        }
        return lNodeNum>rNodeNum?lSearchRoot:rSearchRoot;
    }
}

搜索二叉树寻找位置错误的两个节点
这里写图片描述

import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class FindErrorNode {
    public int[] findError(TreeNode root) {
        // write code here
           ArrayList<Integer> result=new ArrayList<Integer>();//保存数值的list
        int[] temp=new int[2];
        boolean descendTime=false;
        //是否曾经遇到降序：因为错位的只有2个节点，分为两种情况
        //如果此时为第一次，则降序的前面个数为错位大的数，后面的数暂时存为错位小的数
        //如果此时为第二次降序，则降序的后面的数为错位小的数
         mid(root,result);
        for(int i=1;i<result.size();i++){
           if(result.get(i)<result.get(i-1)){
               temp[0]=result.get(i);
               if(descendTime==false){
                    descendTime=true;
                       temp[1]=result.get(i-1);
               }
           }

        }
       return temp;
    }

    public void mid(TreeNode root,ArrayList<Integer> result){
        if(root==null){
            return;
        }

         mid(root.left,result);
        result.add(root.val);
        mid(root.right,result);
    }
}
  • 满二叉树
    这里写图片描述
    这里写图片描述
    这里写图片描述
    完全二叉树的判断
    这里写图片描述
    完全二叉树的判定：使用队列进行宽度优先遍历
import java.util.*;
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class CheckCompletion {
    public boolean chk(TreeNode root) {
        // write code here
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        TreeNode cur;
        boolean hasToBeLeaf=false;
        while(!queue.isEmpty()){
            cur=queue.poll();
            //如果当前节点的左孩子或者右孩子有一个为空
            if(cur.left==null||cur.right==null){
                //如果当前节点有右孩子却没有左孩子，则返回false，因为违背了缺少的节点全部集中在右边这一条
               if(cur.left==null&&cur.right!=null) return false;
                //因为缺少的节点需要全部集中在右边，若当前节点只有左孩子却没有右孩子，则后继节点必须为叶节点；
               if(hasToBeLeaf==false) hasToBeLeaf=true;
                //若此节点必须为叶节点却有左孩子，则返回false
               else if(cur.left!=null){
                   return false;
               }
            }else{
                queue.offer(cur.left);
                queue.offer(cur.right);
            }

        }
        return true;
    }
}

注释和引用：

java实现：

* Stack Queue

    * Stack<TreeNode> stack=new Stack<TreeNode>();//声明和定义
    * push() pop()//入栈和出栈
    * peek() //方法调用返回在这个堆栈的顶部的对象,但是不弹出
    * Queue<TreeNode> queue=new LinkedList<TreeNode>();//队列的声明和定义
    * offer() poll()//入队和出队
    * isEmpty() //判断栈和队列是否为空
    * http://www.runoob.com/java/data-queue.html 队列 菜鸟教程
    * 数组的大小用length属性，list的大小用size()函数


    * Arraylist<type(类名比如Integer或者String)>
    * List<String> temp=new ArrayList<String>();//初始化动态链表
    * size()//List或者ArrayList的元素个数
    * add()//添加元素
    * get(i)获取元素

牛客网算法课程视频链接

慕森
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法java篇--二叉树
小马哥的博客
12-24 738
数据结构有算法，java
数据结构与算法——二叉树详解java
qq_40688338的博客
12-23 940
我们有序数组查找快，可以通过二分查找快速的查找到数据，但是要在有序数组中插入一个数的话，就必须先找到插入数据项的位置，然后将所有插入位置后面的数据项后移以为，给新的数据腾出空间，同时删除数据也是一样的道理，可以知道这样的话是很浪费时间的， 同时另外的一种数据结构——链表，链表的插入和删除很快，我们只需要改变一些引用，但是查找数据就会很慢，因为我们无论查找到什么数据，都需要从链表的第一个数据开始，遍...
二叉树详解（Java）
weixin_45969711的博客
11-14 1394
也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。先访问左子节点，左子节点不为空就递归中序遍历，再访问根节点，然后再访问右子节点，右子节点不为空就递归中序遍历。先访问左子节点，左子节点不为空就递归后序遍历，再访问右子节点，右子节点不为空就递归后序遍历，然后再访问根节点。先访问根节点，再访问左节点，左节点不为空就递归前序遍历，再访问右节点，右节点不为空就递归前序遍历。若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1)
算法学习———二叉树（Java版）
Sencq的博客
10-23 963
本周leetcode刷题路线：二叉树算法题常用方法：递归算法 递归算法基本思路：只考虑部分，不考虑整体；101. 对称二叉树（简单）： 题目描述： 给你一个二叉树的根节点 ， 检查它是否轴对称。 示例： 输入：root = [1, 2, 2, 3, 4, 4, 3] 输出：true 解题思路： 检查该二叉树是否为对称二叉树，即检查该二叉树根节点的左子树翻转后是否与右子树相等（226.
二叉树的结构、构建及递归遍历算法 - 树结构 | 第1篇【java实现】
kndjg的博客
07-20 772
‘树’ 在整个数据结构体系中十分重要，它是某些算法乃至框架的架构基石。数据的逻辑结构大致可分为两类，一个是线性结构，另一个是非线性结构，前者有线性表、栈和队列等，后者主要是树和图结构。线性结构即一对一的，每一层都只有一个结点，可以理解为“单传”；至于非线性结构那就是一对多（树）和多对多（图），以树为例，可以想象成在一对一线性结构基础上将每层的元素个数横向拓展（根节点除外），即理解为“非单传”。......
Java【二叉树】详细图解 + 掌握重点基本操作
yzhcjl_的博客
02-22 1049
关于二叉树的相关知识和相关操作代码整理分享~
Java 数据结构与算法之二叉树
大魔王的博客
02-05 353
一、树的概念 1、树的概念：树，作为非线性数据结构的典型例子，不再是一对一，而是一对多的关系。示例图如下 根节点（root） ：最顶部节点，唯一的 父节点和子节点：parent，child是相对的 子节点：每个子节点只有一个父节点 叶子节点：没有子节点的节点称为叶子节点（leaf） 2、树的相关术语：示意图如下 节点的度：该节点的子节点个数，8的度为2 树的度：这棵树内子节点...
数据结构与排序算法------通过代码示例，讲解：数据结构和9种排序算法。.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
JAVA---算法与数据结构
04-08
在"JAVA---算法与数据结构"这个主题中，我们将深入探讨Java中常用的数据结构，如数组、链表、栈、队列、集合、映射、树（二叉树、红黑树）和图等。每种数据结构都有其独特的优势和适用场景，例如，数组适合随机访问...
尚硅谷老韩java版算法和数据结构讲解代码笔记整理.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构二叉树专题java代码实现
04-02
数据结构二叉树专题java代码实现
java版数据结构的 算术表达式与二叉树源码
06-08
Java作为一种流行的编程语言，被广泛用于实现各种数据结构，包括二叉树。本篇将详细讲解基于Java的算术表达式与二叉树相关的知识点。 一、算术表达式与二叉树 1. **中缀表达式**：我们日常接触的算术表达式通常是...
数据结构与算法Java语言描述
06-22
本系列文章将系统地讲解Java中的数据结构和算法，同时通过实例来深化理解。 数据结构是指计算机存储、组织数据的方式。在编程中，数据结构是计算机内部处理数据的方式，它们通过特定的关系来组织数据元素。选择合适...
【数据结构 Java 版】二叉树的实现（超多图、超详解）
热门推荐
吞吞吐吐大魔王的博客
11-01 1万+
文章目录1. 树型结构1.1 概念1.2 要掌握的知识点1.3 树的存储形式1.4 树的应用2. 二叉树2.1 概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.3.1 满二叉树2.3.2 完全二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1 二叉树的前、中、后序遍历（递归实现）2.6.2 二叉树的层序遍历2.6.2 二叉树的实现2.7 前中后序的非递归实现3. 二叉树练习题3.1 二叉树基础练习题3.1.1 二叉树的前序遍历3.1.2 二叉树的中序遍历3.1.3 二叉
Java数据结构之二叉树—理论图文篇
最新发布
2301_78838401的博客
04-22 924
一对一的线性结构，如顺序表和链表，但还有很多一对多的情况，所以引入“树”，一对多的结构。概念：一棵二叉树是结点的一个有限集合，该集合：1. 或者为空2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。从上图可以看出：1. 二叉树不存在度大于2的结点2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树注意：对于任意的二叉树都是由以下几种情况复合而成的：1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有2^i - 1(i>0)个结点2. 若。
[JAVA数据结构] 二叉树 - 详解
weixin_55250388的博客
02-01 1247
对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。二叉树的顺序存储，通过学习你会发现，其实二叉树并不适合用数组存储，因为并不是每个二叉树都是完全二叉树，普通二叉树使用顺序表存储或多或少会存在空间浪费的现象。1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ B）结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推,, 上图为4层。Node right;
java二叉树的基本算法_java 数据结构与算法---二叉树
weixin_42519253的博客
02-27 273
原理来自百度百科 推荐数据演示网址 ：https://www.cs.usfca.edu/~galles/visualization/BST.html一、什么是二叉树二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的(i-1)次方个结点；深度为k的二叉树至多有2的k次方然后减1个结点(次方不会敲所以用文字描述)；对任何一棵二叉树T...
java二叉树详解_二叉树详解
weixin_28730131的博客
02-25 828
树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点(或左孩子和右孩子)，并且二叉树的子树有左右之分，其次序不能任意颠倒。本篇博客将详细为大家解析二叉树。首先介绍两个概念：满二叉树：在一棵二叉树中，如果所有分支结点都有左孩子和右孩子结点，并且叶子结点都集中在二叉树的最下层，这样的树叫做满二叉树如：完全二叉树：若二叉树中最多只...
字符串匹配-KMP算法 讲解与java代码实现
bury_的博客
01-29 3966
如何高效地查找字符串a是否包含字符串s？ 可以使用KMP算法，首先计算字符串s的模式偏移数组next，然后在遍历a查找s的时候可以利用next偏移数组对s进行偏移，以求更快地进行匹配检测。 假设要计算字符串a=”bcbcbacbcbcbc”是否包含字符串s=”bcbcbc”。 1.算法思想 第一步：计算字符串”bcbcbc”的next偏移数组： next[0]=-1,next[1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值