AI 助理
备案控制台
开发者社区 人工智能 文章 正文

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

2024-10-16 31
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 这篇文章主要介绍了树和二叉树的基础知识，包括树的存储方式、二叉树的定义、遍历方法（前序、中序、后序、层次遍历），以及二叉树的查找和删除操作。

一、树的介绍

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 测试结果

在这里插入图片描述

文章标签：
存储
算法
关键词：
数据结构树
数据结构二叉树
算法学习
数据结构学习
数据结构与算法学习
java冯坚持
目录
相关文章
XIAZHI
|
1月前
|
算法
数据结构之博弈树搜索(深度优先搜索)
本文介绍了使用深度优先搜索（DFS）算法在二叉树中执行遍历及构建链表的过程。首先定义了二叉树节点`TreeNode`和链表节点`ListNode`的结构体。通过递归函数`dfs`实现了二叉树的深度优先遍历，按预序（根、左、右）输出节点值。接着，通过`buildLinkedList`函数根据DFS遍历的顺序构建了一个单链表，展示了如何将树结构转换为线性结构。最后，讨论了此算法的优点，如实现简单和内存效率高，同时也指出了潜在的内存管理问题，并分析了算法的时间复杂度。
XIAZHI
49 0
龙大吉
|
22天前
|
存储 缓存 算法
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式，强调了合理选择数据结构的重要性，并通过案例分析展示了其在实际项目中的应用，旨在帮助读者提升编程能力。
龙大吉
43 5
ephemerals__
|
1月前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现（c语言）（附源码）
本文介绍了树和二叉树的基本概念及结构，重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树，常用于实现优先队列和高效的排序算法（如堆排序）。文章详细描述了堆的性质、存储方式及其实现方法，包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容，读者可以全面了解堆的原理和应用。
ephemerals__
75 16
光明顶阳顶天
|
1月前
|
算法
分享一些提高二叉树遍历算法效率的代码示例
这只是简单的示例代码，实际应用中可能还需要根据具体需求进行更多的优化和处理。你可以根据自己的需求对代码进行修改和扩展。
光明顶阳顶天
46 8
dufadayang
|
1月前
|
存储 缓存 算法
如何提高二叉树遍历算法的效率？
选择合适的遍历算法，如按层次遍历树时使用广度优先搜索（BFS），中序遍历二叉搜索树以获得有序序列。优化数据结构，如使用线索二叉树减少空指针判断，自定义节点类增加辅助信息。利用递归与非递归的特点，避免栈溢出问题。多线程并行遍历提高速度，注意线程安全。缓存中间结果，避免重复计算。预先计算并存储信息，提高遍历效率。综合运用这些方法，提高二叉树遍历算法的效率。
dufadayang
58 5
dufadayang
|
1月前
|
算法
树的遍历算法有哪些？
不同的遍历算法适用于不同的应用场景。深度优先搜索常用于搜索、路径查找等问题；广度优先搜索则在图的最短路径、层次相关的问题中较为常用；而二叉搜索树的遍历在数据排序、查找等方面有重要应用。
dufadayang
37 2
mao29955
|
1月前
|
机器学习/深度学习 JSON 算法
二叉树遍历算法的应用场景有哪些？
【10月更文挑战第29天】二叉树遍历算法作为一种基础而重要的算法，在许多领域都有着不可或缺的应用，它为解决各种复杂的问题提供了有效的手段和思路。随着计算机科学的不断发展，二叉树遍历算法也在不断地被优化和扩展，以适应新的应用场景和需求。
mao29955
41 0
XIAZHI
|
1月前
|
算法
数据结构之文件系统模拟（树数据结构）
本文介绍了文件系统模拟及其核心概念，包括树状数据结构、节点结构、文件系统类和相关操作。通过构建虚拟环境，模拟文件的创建、删除、移动、搜索等操作，展示了文件系统的基本功能和性能。代码示例演示了这些操作的具体实现，包括文件和目录的创建、移动和删除。文章还讨论了该算法的优势和局限性，如灵活性高但节点移除效率低等问题。
XIAZHI
47 0
软件算法开发
|
16天前
|
算法
基于WOA算法的SVDD参数寻优matlab仿真
该程序利用鲸鱼优化算法(WOA)对支持向量数据描述(SVDD)模型的参数进行优化，以提高数据分类的准确性。通过MATLAB2022A实现，展示了不同信噪比(SNR)下模型的分类误差。WOA通过模拟鲸鱼捕食行为，动态调整SVDD参数，如惩罚因子C和核函数参数γ，以寻找最优参数组合，增强模型的鲁棒性和泛化能力。
软件算法开发
58 31
软件算法开发
|
2天前
|
供应链 算法 调度
排队算法的matlab仿真,带GUI界面
该程序使用MATLAB 2022A版本实现排队算法的仿真，并带有GUI界面。程序支持单队列单服务台、单队列多服务台和多队列多服务台三种排队方式。核心函数`func_mms2`通过模拟到达时间和服务时间，计算阻塞率和利用率。排队论研究系统中顾客和服务台的交互行为，广泛应用于通信网络、生产调度和服务行业等领域，旨在优化系统性能，减少等待时间，提高资源利用率。
软件算法开发
13 1

热门文章

最新文章

  • 1
    学数据结构，只需要基本的编程体验
  • 2
    数据结构学习笔记——链式存储结构实现栈（链栈）
  • 3
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 4
    R语言学习笔记（一）数据结构
  • 5
    基于OHCI的USB主机 —— UFI数据结构2
  • 6
    初学python数据结构-切片
  • 7
    数据结构示例——堆排序过程
  • 8
    [数据结构 -- C语言] 队列(Queue)
  • 9
    数据结构实验十二 哈夫曼树及编码
  • 10
    数据结构221-希尔排序的增量
  • 1
    数据结构与算法 动态规划(启发式搜索、遗传算法、强化学习待完善)
    108
  • 2
    数据结构与算法 回溯
    40
  • 3
    数据结构与算法 分治
    44
  • 4
    数据结构与算法 搜索（下）
    46
  • 5
    数据结构与算法 搜索（上）
    34
  • 6
    数据结构与算法 搜索
    52
  • 7
    数据结构与算法 排序（下）
    58
  • 8
    数据结构与算法 排序（上）
    60
  • 9
    数据结构与算法 图
    34
  • 10
    数据结构与算法 树（B树，B+树，红黑树待完善）
    64

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • “大数据+算法”助力B2B未来商业
  • 数据+算法定义新世界
  • Apache Flink 流式应用中状态的数据结构定义升级

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • RSA非对称加密算法
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    DataWorks