数据结构与算法学习十六:树的知识、二叉树、二叉树的遍历(前序、中序、后序、层次)、二叉树的查找(前序、中序、后序、层次)、二叉树的删除

简介: 这篇文章主要介绍了树和二叉树的基础知识,包括树的存储方式、二叉树的定义、遍历方法(前序、中序、后序、层次遍历),以及二叉树的查找和删除操作。

一、树的介绍

1.1 为什么需要树这种数据结构

1.1.1 数组存储方式的分析

优点:通过下标方式访问元素,速度快。对于有序数组,还可使用二分查找提高检索速度。检索、修改速度快。
缺点:如果要检索具体某个值,或者插入值(按一定顺序)会整体移动,效率较低 [示意图]
画出操作示意图
在这里插入图片描述

1.1.2 链式存储方式的分析

优点:在一定程度上对数组存储方式有优化(比如:插入一个数值节点,只需要将插入节点,链接到链表中即可, 删除效率也很好)。删除、添加快。

缺点:在进行检索时,效率仍然较低,比如(检索某个值,需要从头节点开始遍历)
画出操作示意图
在这里插入图片描述

1.1.3 树存储方式的分析

能提高数据存储,读取的效率, 比如利用 二叉排序树(Binary Sort Tree),既可以保证数据的检索速度,同时也可以保证数据的插入,删除,修改的速度。【示意图,后面详细讲】
案例:[7, 3, 10, 1, 5, 9, 12]
在这里插入图片描述

1.2 基本介绍

这个的介绍是从百度上拿来的,定义比较简单。

树状图是一种数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。

特点
每个结点有零个或多个子结点;没有父结点的结点称为根结点;每一个非根结点有且只有一个父结点;除了根结点外,每个子结点可以分为多个不相交的子树

1.3 树的常用语

  1. 树示意图
    在这里插入图片描述

  2. 树的常用术语(结合示意图理解):
    1、节点
    2、根节点
    3、父节点
    4、子节点
    5、叶子节点 (没有子节点的节点)
    6、节点的权(节点值)
    7、路径(从root节点找到该节点的路线)
    8、层
    9、子树
    10、树的高度(最大层数)
    11、森林 :多颗子树构成森林

二、二叉树定义

  1. 树有很多种,每个节点最多只能有两个子节点的一种形式称为 二叉树

  2. 二叉树的子节点分为 左节点和右节点

  3. 示意图
    在这里插入图片描述

  4. 如果该二叉树的所有叶子节点都在最后一层,并且结点总数= 2^n -1 , n 为层数,则我们称为 满二叉树
    在这里插入图片描述

  5. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层,而且最后一层的叶子节点在左边连续,倒数第二层的叶子节点在右边连续,我们称为 完全二叉树
    在这里插入图片描述

三、二叉树的操作

3.1 二叉树遍历说明

二叉树的遍历,分为 前序遍历、中序遍历、层次遍历。

  1. 前序遍历: 先输出父节点,再遍历左子树和右子树
  2. 中序遍历: 先遍历左子树,再输出父节点,再遍历右子树
  3. 后序遍历: 先遍历左子树,再遍历右子树,最后输出父节点
  4. 层次遍历:先输出根结点,然后分层次的进行遍历。
    小结: 看输出父节点的顺序,就确定是前序,中序还是后序

3.2 实例

和以往一样,对水浒传英雄进行构建二叉树。

创建8个节点,分别为1 2 3 4 5 6 7 8 。

开始是7个节点,然后后来测试添加,便在6节点左子树挂载 8 结点。
我绘制一下8个节点的二叉树
在这里插入图片描述
我们手动遍历一把,然后在与下面代码的输出进行对比。
前序遍历:1 2 4 5 3 6 8 7
中序遍历:4 2 5 1 8 6 3 7
后序遍历:4 5 2 8 6 7 3 1
层次遍历:1 2 3 4 5 6 7 8

事实证明,与下面代码输出一致。

3.3 二叉树遍历

思路分析:
在这里插入图片描述
图中文字:
分析二叉树的前序、中序、后序的遍历步骤

  1. 创建一颗二叉树

  2. 前序遍历
    2.1先输出当前节点(初始的时候是root节点)
    2.2 如果左子节点不为空,则递归继续前序遍历
    2.3 如果右子节点不为空,则递归继续前序遍历

  3. 中序遍历
    3.1 如果当前节点的右子节点不为空,则递归中序遍历,
    3.2 输出当前节点
    3.3 如果当前节点的右子节点不为空,则递归中序遍历

  4. 后序遍历
    4.1 如果当前节点的左子节点不为空,则递归后序遍历,
    4.2 如果当前节点的右子节点不为空,则递归后序遍历
    4.3 输出当前节点

3.3.1 HeroNode.java 结点

这个类为 节点类。对英雄构建成结点实体类。

在这里面编写 前序、中序、后序遍历的底层方法。注释比较清晰。

package com.feng.ch12_tree.t1_binarytree;

/*
 * 创建 HeroNode 结点
 *
 * 1、数据域 包含 编号 和 姓名
 * 2、指针域包括 左子结点 和 右子结点
 * */
public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    // 编写前序遍历的方法
    public void preOrder() {
        System.out.println(this);// 先输出父结点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 中序遍历
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出父结点
        System.out.println(this);
        // 递归向右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    // 后序遍历
    public void postOrder() {
        // 递归向遍历
        if (this.left != null) {
            this.left.postOrder();
        }
        // 递归向右子树中序遍历
        if (this.right != null) {
            this.right.postOrder();
        }
        // 输出父结点
        System.out.println(this);
    }
}

3.3.2 BinaryTree.java 二叉树

创建的二叉树,在这里 调用 HeroNode 结点类的 方法,实现二叉树的各种操作,前序、中序、后序的操作。

package com.feng.ch12_tree.t1_binarytree;

import java.util.LinkedList;

/*
 * 定义BinaryTree 二叉树
 * */
class BinaryTree {
    private HeroNode root;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    // 前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空,无法遍历");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空,无法遍历");
        }
    }

    // 后序遍历
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空,无法遍历");
        }
    }

    /*
     * 层次遍历
     * */
    public void middleOrder() {
        if (this.root != null) {
            LinkedList<HeroNode> queue = new LinkedList();
            queue.add(root);
            HeroNode current = null;

            while (!queue.isEmpty()) {
                current = queue.poll();//出队队头元素并访问
                System.out.println(current);
                if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
                    queue.offer(current.getLeft());
                }
                if (current.getRight() != null) {//如果当前节点的右节点不为空,把右节点入队
                    queue.offer(current.getRight());
                }
            }
        } else {
            System.out.println("二叉树为空,无法遍历");
        }
    }
}

3.3.3 T1_BinaryTreeMain.java 测试类

测试类,对前序中序后序,进行测试。打印输出,
构建二叉树时,是手动添加。这里主要测试二叉树的前序、中序、后序的遍历

public class T1_BinaryTreeMain {

    public static void main(String[] args) {
        // 先需要创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点

        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "武松");
        HeroNode node6 = new HeroNode(6, "武大郎");
        HeroNode node7 = new HeroNode(7, "李逵");

        /*
         * 说明,我们先手动创建该二叉树,后面我们学习递归的方式创建二叉树
         * */
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        node3.setRight(node7);

        /*
         * 测试 二叉树 的遍历
         * */
        System.out.println("前序遍历:"); // 输出 1 2 4 5 3 6 7
        binaryTree.preOrder();
        System.out.println();

        System.out.println("中序遍历:"); // 输出 4 2 5 1 6 3 7
        binaryTree.infixOrder();
        System.out.println();

        System.out.println("后序遍历:"); // 输出 4 5 2 6 7 3 1
        binaryTree.postOrder();
        System.out.println();

        System.out.println("层次遍历:"); // 输出 1 2 3 4 5 6 7
        binaryTree.middleOrder();
        System.out.println();

        /*
         * 新添加一个节点
         * */
        HeroNode node8 = new HeroNode(8, "关胜");
        node6.setLeft(node8);

        /*
         * 测试 新增加结点 后的遍历
         * */
        System.out.println("添加新节点后的 前序遍历:"); // 输出  1 2 3 5 4
        binaryTree.preOrder();
        System.out.println();

        System.out.println("添加新节点后的 中序遍历:"); // 输出 2 1 5 3 4
        binaryTree.infixOrder();
        System.out.println();

        System.out.println("添加新节点后的 后序遍历:"); // 输出 2 5 4 3 1
        binaryTree.postOrder();
        System.out.println();

        System.out.println("添加新节点后的 层次遍历:"); // 输出 2 5 4 3 1
        binaryTree.middleOrder();
        System.out.println();

     }
}

3.3.4 测试结果

这里截图的为测试中添加节点后的遍历:
在这里插入图片描述
在这里插入图片描述

3.4 二叉树的查找

  • 要求
  1. 请编写前序查找,中序查找和后序查找的方法。
  2. 并分别使用 三种查找方式 ,查找 heroNO = 5 的节点
  3. 并分析各种查找方式,分别比较了多少次
  • 二叉树的查找也分为前序查找、中序查找、后序查找。
    层次查找直接在二叉树类 BinaryTree.java 中编写。

  • 思路分析图解
    在这里插入图片描述
    图中文字如下:
    使用前序,中序,后序的方式来查询指定的结点

前序查找思路

  1. 先判断当前节点的 no 是否等于要查找的no
  2. 如果是相等,则返回当前结点
  3. 如果不等,则判断当前结点的左子节点是否为空,如果不为空,则递归前序查找
  4. 如果左递归前序查找,找到节点,则返回,否则继续判断 当前节点的右子节点是否为空,如果不为空,则继续向右递归前序查找。

中序查找思路

  1. 判断当前节点的左子结点是否为空,如果不为空,则递归中序查找
  2. 如果找到,则返回,如果没有找到,就和当前结点比较,如果是则返回当前结点,否则继续进行右递归中序查找
  3. 如果右递归中序查找,找到就返回,否则返回null

后序查找思路

  1. 判断当前节点的左子结点是否为空,如果不为空,则递归后序查找
  2. 如果找到,则返回,如果没有找到,就判断当前节点的右子节点是否为空,如果不为空,则有递归进行后续查找,如果找到,就返回
  3. 如果左右节点都没有找到,就和当前节点进行比较,如果是则返回,否则返回 null

3.4.1 HeroNode.java 节点类

在这里进行编写底层查找的方法。
包括前序查找、中序查找、后序查找

    /*
     *前序遍历查找
     * @param no 查找 no
     * @return 如果找到就返回该 Node,如果没有找到就返回 null
     * */
    public HeroNode preOrderSearch(int no) {
        System.out.println("进入前序遍历查找~~");
        // 比较当前节点是不是
        if (this.no == no) {
            return this;
        }
        /*
         * 1、则判断当前结点的左子节点是否为空,如果不为空,则递归前序查找
         * 2、如果左递归前序查找,找到节点,则返回
         * */
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        // 1、左递归前序查找,找到节点,则返回,否则继续判断
        // 2、当前节点的右子节点是否为空,如果不为空,则继续向右递归前序查找。
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    /*
     * 中序遍历查找
     * */
    public HeroNode infixOrderSearch(int no) {
        //1、判断当前节点的左子结点是否为空,如果不为空,则递归中序查找
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入中序遍历查找~~");
        // 2、如果找到,则返回,如果没有找到,就和当前结点比较,如果是则返回当前结点,
        if (this.no == no) {
            return this;
        }

        // 3、否则继续进行右递归中序查找
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /*
     * 后序遍历查找
     * */
    public HeroNode postOrderSearch(int no) {
        //1、判断当前节点的左子结点是否为空,如果不为空,则递归后序查找,如果找到,则返回,
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }

        // 2、如果没有找到,就判断当前节点的右子节点是否为空,如果不为空,则有递归进行后续查找,如果找到,就返回
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入后序遍历查找");
        // 3、如果左右节点都没有找到,就和当前节点进行比较,如果是则返回,否则返回 null
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

3.4.2 BinaryTree.java 二叉树

这里是二叉树类,对 结点类中进行包装。

    /*
     * 前序遍历查找
     * */
    public HeroNode preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 中序遍历查找
     * */
    public HeroNode infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 后序遍历查找
     * */
    public HeroNode postOrderSearch(int no) {
        if (root != null) {
            return root.postOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 层次遍历查找
     * */
    public HeroNode middleOrderSearch(int no) {
        if (root != null) {
            LinkedList<HeroNode> queue = new LinkedList();
            queue.add(root);
            HeroNode current = null;
            HeroNode result = null;

            while (!queue.isEmpty()) {
                current = queue.poll();//出队队头元素并访问
                if (no == current.getNo()){
                    result = current;
                    break;
                }
                if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
                    queue.offer(current.getLeft());
                }
                if (current.getRight() != null) {//如果当前节点的右节点不为空,把右节点入队
                    queue.offer(current.getRight());
                }
            }
            return result;
        } else {
            return null;
        }
    }

3.4.3 T1_BinaryTreeMain.java 测试类

在上面的测试类,后面写

/*
  * 测试二叉树的 查找
  * */
 //  递归4次
 System.out.println("二叉树的 前序遍历查找");
 HeroNode heroNode = binaryTree.preOrderSearch(5);
 if (null == heroNode) {
     System.out.printf("没有找到 no = %d 的英雄", 5);
 } else {
     System.out.printf("找到了, 信息为 no= %d name=%s \n", heroNode.getNo(), heroNode.getName());
 }
 System.out.println();

 // 递归 3次
 System.out.println("二叉树的 中序遍历查找");
 HeroNode heroNode1 = binaryTree.infixOrderSearch(5);
 if (null == heroNode1) {
     System.out.printf("没有找到 no = %d 的英雄", 5);
 } else {
     System.out.printf("找到了, 信息为 no= %d name=%s \n", heroNode1.getNo(), heroNode1.getName());
 }
 System.out.println();

 // 递归 2次
 System.out.println("二叉树的 后序遍历查找");
 HeroNode heroNode2 = binaryTree.postOrderSearch(5);
 if (null == heroNode2) {
     System.out.printf("没有找到 no = %d 的英雄\n", 5);
 } else {
     System.out.printf("找到了, 信息为 no= %d name=%s \n", heroNode2.getNo(), heroNode2.getName());
 }
 System.out.println();

 System.out.println("二叉树的 层次遍历查找");
 HeroNode heroNode3 = binaryTree.middleOrderSearch(4);
 if (null == heroNode3) {
     System.out.printf("没有找到 no = %d 的英雄\n", 5);
 } else {
     System.out.printf("找到了, 信息为 no= %d name=%s \n", heroNode3.getNo(), heroNode3.getName());
 }
 System.out.println();

3.4.4 测试结果

在这里插入图片描述

3.5 二叉树的删除

  • 要求
  1. 如果删除的节点是叶子节点,则删除该节点
  2. 如果删除的节点是非叶子节点,则删除该子树.
  3. 测试,删除掉 5号叶子节点 和 3号子树.
  • 完成删除思路分析:
    在这里插入图片描述
    图中文字:
    完成删除结点的操作
    规定:
    1、如果删除的结点是叶子节点,则删除该节点
    2、如果删除的结点是非叶子节点,则删除该子树
    思路:
    首先先处理:考虑如果树是空树root,如果只有一个root结点,则等价将二叉树置空。
    然后进行下面步骤
    1、因为我们的二叉树是单向的,所以 我们是判断当前节点的子节点是否需要删除节点,而不能取判断当前这个结点是不是需要删除结点。
    2、如果当前节点的左子结点不为空,并且左子结点 就是要删除结点,就将this.left = null即可;并且就返回(结束递归删除)
    3、如果当前结点的右子节点不为空,并且左子结点就是要删除结点,就将 this.right = null即可;并且就返回(结束递归删除)
    4、如果第2步和第3步没有删除结点,那么我们就需要向左子树进行递归删除
    5、如果第4步也没有删除结点,则应当向右子树进行递归删除。

3.4.1 HeroNode.java 节点类

删除结点时,需要考虑两种情况。
第一种:如果删除的结点是叶子节点,则删除该叶子节点
第二种:如果删除的结点是非叶子节点,则删除该子树

/*
 * 递归删除结点
 * 1、如果删除的结点是叶子节点,则删除该叶子节点
 * 2、如果删除的结点是非叶子节点,则删除该子树
 * 首先先处理:考虑如果树是空树root,如果只有一个root结点,则等价将二叉树置空。 这一部分放在上一层处理
 * */
public void deleteNode(int no) {
    // 第二第三步 为递归的 结束条件
    /*
     * 1、因为我们的二叉树是单向的,所以我们是判断当前节点的子节点是否需要删除节点,而不能取判断当前这个结点是不是需要删除结点。
     * 2、如果当前节点的左子结点不为空,并且左子结点 就是要删除结点,就将this.left = null 即可;并且就返回(结束递归删除)
     * 3、如果当前结点的右子节点不为空,并且左子结点就是要删除结点,就将 this.right = null 即可;并且就返回(结束递归删除)
     * 4、如果第2步和第3步没有删除结点,那么我们就需要向左子树进行递归删除
     * 5、如果第4步也没有删除结点,则应当向右子树进行递归删除。
     * */
    // 2、如果当前节点的左子结点不为空,并且左子结点 就是要删除结点,就将this.left = null 即可;并且就返回(结束递归删除)
    if (this.left != null && this.left.no == no) {
        this.left = null;
        return;
    }

    //3、如果当前结点的右子节点不为空,并且左子结点就是要删除结点,就将 this.right = null 即可;并且就返回(结束递归删除)
    if (this.right != null && this.right.no == no) {
        this.right = null;
        return;
    }
    // 4、如果第2步和第3步没有删除结点,那么我们就需要向左子树进行递归删除
    if (this.left != null) {
        this.left.deleteNode(no);
    }
    //5、如果第4步也没有删除结点,则应当向右子树进行递归删除。
    if (this.right != null) {
        this.right.deleteNode(no);
    }
}

3.5.2 BinaryTree.java 二叉树

/*
 * 递归删除结点
 * */
public void deleteNode(int no) {
    if (root != null) {
        //  如果只有一个节点,这里立即判断root 是不是就是要删除结点
        if (root.getNo() == no) {
            root = null;
        } else {
            root.deleteNode(no);
        }
    } else {
        System.out.println("空树,不能删除~~");
    }
}

3.5.3 T1_BinaryTreeMain.java 测试类

/*
 * 测试删除结点
 * */
System.out.println("删除前,前序遍历");
binaryTree.preOrder(); // 1 2 3 5 4

//binaryTree.deleteNode(5);
binaryTree.deleteNode(3);
System.out.println("删除后,前序遍历");
binaryTree.preOrder(); // 1 2 3 4 // 1 2

3.5.4 测试结果

在这里插入图片描述

相关文章
|
2月前
|
存储 算法
数据结构与算法学习二二:图的学习、图的概念、图的深度和广度优先遍历
这篇文章详细介绍了图的概念、表示方式以及深度优先遍历和广度优先遍历的算法实现。
60 1
数据结构与算法学习二二:图的学习、图的概念、图的深度和广度优先遍历
|
28天前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之串(12)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
数据结构与算法系列学习之串的定义和基本操作、串的储存结构、基本操作的实现、朴素模式匹配算法、KMP算法等代码举例及图解说明;【含常见的报错问题及其对应的解决方法】你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
2024重生之回溯数据结构与算法系列学习之串(12)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丟脸好嘛?】
|
17天前
|
算法
分享一些提高二叉树遍历算法效率的代码示例
这只是简单的示例代码,实际应用中可能还需要根据具体需求进行更多的优化和处理。你可以根据自己的需求对代码进行修改和扩展。
|
20天前
|
存储 缓存 算法
如何提高二叉树遍历算法的效率?
选择合适的遍历算法,如按层次遍历树时使用广度优先搜索(BFS),中序遍历二叉搜索树以获得有序序列。优化数据结构,如使用线索二叉树减少空指针判断,自定义节点类增加辅助信息。利用递归与非递归的特点,避免栈溢出问题。多线程并行遍历提高速度,注意线程安全。缓存中间结果,避免重复计算。预先计算并存储信息,提高遍历效率。综合运用这些方法,提高二叉树遍历算法的效率。
45 5
|
23天前
|
机器学习/深度学习 JSON 算法
二叉树遍历算法的应用场景有哪些?
【10月更文挑战第29天】二叉树遍历算法作为一种基础而重要的算法,在许多领域都有着不可或缺的应用,它为解决各种复杂的问题提供了有效的手段和思路。随着计算机科学的不断发展,二叉树遍历算法也在不断地被优化和扩展,以适应新的应用场景和需求。
26 0
|
28天前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习(8)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
28天前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之顺序表【无论是王道考研人还真爱粉都能包会的;不然别给我家鸽鸽丢脸好嘛?】
顺序表的定义和基本操作之插入;删除;按值查找;按位查找等具体详解步骤以及举例说明
|
28天前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之单双链表精题详解(9)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
28天前
|
存储 Web App开发 算法
2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构之单双链表按位、值查找;[前后]插入;删除指定节点;求表长、静态链表等代码及具体思路详解步骤;举例说明、注意点及常见报错问题所对应的解决方法
|
28天前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之栈和队列精题汇总(10)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第3章之IKUN和I原达人之数据结构与算法系列学习栈与队列精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!