【数据结构】对比数组链表我发现二叉树的好

已于 2022-02-22 23:06:51 修改
阅读量963 收藏 9
点赞数 8
分类专栏： 数据结构 文章标签： 数据结构 链表 b树 二叉树 算法
于 2022-02-22 22:59:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doomwatcher/article/details/123079449
版权

前言

觉得文章有帮助的话，麻烦随手留下点赞收藏吧，关注小冷看更多干货学习文章

★ 这里是小冷的博客
✓ 优质技术好文见专栏
个人公众号，分享一些技术上的文章，以及遇到的坑
当前系列：数据结构系列
源代码 git 仓库
数据结构代码地址 代码Git 仓库地址

目录

二叉树简介

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

二叉树的概念

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

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

    image-20220217224612770

  3. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

    image-20220217224724938

  4. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数二

    层的叶子节点在右边连续，我们称为完全二叉树

    image-20220217224752362

数组

数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低

画出操作示意图：

image-20220217223223437

链表

链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，

删除效率也很好)。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

操作示意图：

image-20220217223347750

二叉树

树存储方式的分析

能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也

可以保证数据的插入，删除，修改的速度

案例: [7, 3, 10, 1, 5, 9, 12]

image-20220217223632040

认识树结构

树的常用术语(结合示意图理解:

1) 节点  

2) 根节点  

3) 父节点  

4) 子节点  

5) 叶子节点 (没有子节点的节点)  6) 节点的权(节点值)  7) 路径(从 root 节点找到该节点的路线)  8) 层  

6) 子树  

7) 树的高度(最大层数)
  1. 森林 :多颗子树构成森林

image-20220217223650665

二叉树遍历的说明

  1. 前序遍历: 先输出父节点，再遍历左子树和右子树
  2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
  3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
  4. 小结: 看输出父节点的顺序，就确定是前序，中序还是后序
二叉树遍历应用实例(前序,中序,后序)

image-20220218001503848

二叉树遍历代码实例
 public static void main(String[] args){
     //  测试，先创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();
        heroNode root = new heroNode(1, "宋江");
        heroNode node1 = new heroNode(2, "吴用");
        heroNode node2 = new heroNode(3, "卢俊义");
        heroNode node3 = new heroNode(4, "林冲");
        heroNode node4 = new heroNode(5, "关胜");
        //设置头节点
        binaryTree.setHead(root);
        // 此处我们手动的填补二叉树，之后还会有递归的方式填充二叉树
        root.setLeftNode(node1);
        root.setRightNode(node2);
        node2.setRightNode(node3);
        node2.setLeftNode(node4);
        //测试
            前序遍历
        //binaryTree.PreOrder();
        中序遍历
        //System.out.println();
        //binaryTree.InfixOrder();
        后序遍历
        //System.out.println();
        //binaryTree.PostOrder();
 }    

class BinaryTree {
    //确定根节点
    private heroNode head;

    public void setHead(heroNode head) {
        this.head = head;
    }

    //   前序遍历
    public void PreOrder() {
        if (this.head != null) {
            this.head.PreOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }

    //中序遍历
    public void InfixOrder() {
        if (this.head != null) {
            this.head.infixOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }

    //后续遍历
    public void PostOrder() {
        if (this.head != null) {
            this.head.postOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }
}

class heroNode {
    private int id;
    private String name;
    private heroNode leftNode;
    private heroNode rightNode;

    public heroNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(heroNode leftNode) {
        this.leftNode = leftNode;
    }

    public heroNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(heroNode rightNode) {
        this.rightNode = rightNode;
    }

    public heroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

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

    }

    //    前序遍历
    public void PreOrder() {
        System.out.println(this);
        if (this.getLeftNode() != null) {
            this.leftNode.PreOrder();
        }
        if (this.getRightNode() != null) {
            this.rightNode.PreOrder();
        }
    }

    //    中序遍历
    public void infixOrder() {
        if (this.leftNode != null) {
            this.leftNode.infixOrder();
        }
        System.out.println(this);
        if (this.rightNode != null) {
            this.rightNode.infixOrder();
        }
    }

    //   后序遍历
    public void postOrder() {
        if (this.leftNode != null) {
            this.leftNode.postOrder();
        }
        if (this.rightNode != null) {
            this.rightNode.postOrder();
        }
        System.out.println(this);
    }
}
二叉树查找思路
  1. 请编写前序查找，中序查找和后序查找的方法。
  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点
  3. 并分析各种查找方式，分别比较了多少次

思路图解

image-20220222224722855

二叉树查找代码示例

为了方便更好的阅读代码，就把节点和树类的查找代码专门的写出来，后面会有全代码的部分

class BinatyTree{
    
    //前序查找
    public heroNode preOrderSearch(int no) {
        if (this.head != null) {
            return this.head.PreOrderSearch(no);
        } else {
            return null;
        }
    }

    //中序查找
    public heroNode infixOrderSearch(int no) {
        if (this.head != null) {
            return this.head.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //后序查找
    public heroNode postOrderSearch(int no) {
        if (this.head != null) {
            return this.head.postOrderSearch(no);
        } else {
            return null;
        }
    }
}
class heroNode{
    
    //前序查找
    public heroNode preOrderSearch(int no) {
        if (this.head != null) {
            return this.head.PreOrderSearch(no);
        } else {
            return null;
        }
    }

    //中序查找
    public heroNode infixOrderSearch(int no) {
        if (this.head != null) {
            return this.head.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //后序查找
    public heroNode postOrderSearch(int no) {
        if (this.head != null) {
            return this.head.postOrderSearch(no);
        } else {
            return null;
        }
    }

}
二叉树-删除节点
  • 如果删除的节点是叶子节点，则删除该节点
  • 如果删除的节点是非叶子节点，则删除该子树.
  • 测试，删除掉 5 号叶子节点 和 3 号子树.

思路分析

image-20220222225120417

有关二叉树的，遍历，查找，删除的全代码
package com.hyc.DataStructure.tree;

/**
 * @projectName: DataStructure
 * @package: com.hyc.DataStructure.tree
 * @className: BinaryTreeDemo
 * @author: 冷环渊 doomwatcher
 * @description: TODO
 * @date: 2022/2/3 16:47
 * @version: 1.0
 */
public class BinaryTreeDemo {
    public static void main(String[] args) {
        //  测试，先创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();
        heroNode root = new heroNode(1, "宋江");
        heroNode node1 = new heroNode(2, "吴用");
        heroNode node2 = new heroNode(3, "卢俊义");
        heroNode node3 = new heroNode(4, "林冲");
        heroNode node4 = new heroNode(5, "关胜");
        //设置头节点
        binaryTree.setHead(root);
        // 此处我们手动的填补二叉树，之后还会有递归的方式填充二叉树
        root.setLeftNode(node1);
        root.setRightNode(node2);
        node2.setRightNode(node3);
        node2.setLeftNode(node4);
        //测试
            前序遍历
        //binaryTree.PreOrder();
        中序遍历
        //System.out.println();
        //binaryTree.InfixOrder();
        后序遍历
        //System.out.println();
        //binaryTree.PostOrder();


        //System.out.println("前中后查找");
        //System.out.println("开始前序查找");
        //heroNode resNode = binaryTree.preOrderSearch(5);
        //if (resNode != null) {
        //    System.out.printf("找到节点为 no =>%d,名字 name => %s ", resNode.getId(), resNode.getName());
        //} else {
        //    System.out.println("查找失败");
        //}
        //System.out.println("开始中序查找");
        //heroNode resNode = binaryTree.infixOrderSearch(5);
        //if (resNode != null) {
        //    System.out.printf("找到节点为 no =>%d,名字 name => %s ", resNode.getId(), resNode.getName());
        //} else {
        //    System.out.println("查找失败");
        //}
        //System.out.println("开始后序查找");
        //heroNode resNode = binaryTree.postOrderSearch(5);
        //if (resNode != null) {
        //    System.out.printf("找到节点为 no =>%d,名字 name => %s ", resNode.getId(), resNode.getName());
        //} else {
        //    System.out.println("查找失败");
        //}

        //    删除测试
        System.out.println("删除前");
        binaryTree.PreOrder();
        System.out.println("删除后");
        binaryTree.deleteNode(5);
        binaryTree.PreOrder();

    }
}


class BinaryTree {
    //确定根节点
    private heroNode head;

    public void setHead(heroNode head) {
        this.head = head;
    }

    //   前序遍历
    public void PreOrder() {
        if (this.head != null) {
            this.head.PreOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }

    //中序遍历
    public void InfixOrder() {
        if (this.head != null) {
            this.head.infixOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }

    //后续遍历
    public void PostOrder() {
        if (this.head != null) {
            this.head.postOrder();
        } else {
            System.out.println("二叉树没有根节点，无法遍历");
        }
    }

    //前序查找
    public heroNode preOrderSearch(int no) {
        if (this.head != null) {
            return this.head.PreOrderSearch(no);
        } else {
            return null;
        }
    }

    //中序查找
    public heroNode infixOrderSearch(int no) {
        if (this.head != null) {
            return this.head.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    //后序查找
    public heroNode postOrderSearch(int no) {
        if (this.head != null) {
            return this.head.postOrderSearch(no);
        } else {
            return null;
        }
    }


    //    删除节点
    public void deleteNode(int no) {
        if (head != null) {
            if (head.getId() == no) {
                head = null;
                return;
            } else {
                head.deleteNode(no);
            }
        } else {
            System.out.println("空树,无法删除");
        }
    }
}

class heroNode {
    private int id;
    private String name;
    private heroNode leftNode;
    private heroNode rightNode;

    public heroNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(heroNode leftNode) {
        this.leftNode = leftNode;
    }

    public heroNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(heroNode rightNode) {
        this.rightNode = rightNode;
    }

    public heroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

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

    }

    //    前序遍历
    public void PreOrder() {
        System.out.println(this);
        if (this.getLeftNode() != null) {
            this.leftNode.PreOrder();
        }
        if (this.getRightNode() != null) {
            this.rightNode.PreOrder();
        }
    }

    //    中序遍历
    public void infixOrder() {
        if (this.leftNode != null) {
            this.leftNode.infixOrder();
        }
        System.out.println(this);
        if (this.rightNode != null) {
            this.rightNode.infixOrder();
        }
    }

    //   后序遍历
    public void postOrder() {
        if (this.leftNode != null) {
            this.leftNode.postOrder();
        }
        if (this.rightNode != null) {
            this.rightNode.postOrder();
        }
        System.out.println(this);
    }

    //   前序查找
    public heroNode PreOrderSearch(int no) {
        System.out.println("前序查找");
        //比较当前节点的no 是不是我们要搜索的
        if (this.id == no) {
            return this;
        }
        //要返回的节点
        heroNode resNode = null;
        //  判断左边节点是不是空 如果不是空的话 那么就递归前序查找
        //    如果找到的话 就返回找到的节点
        if (this.leftNode != null) {
            resNode = this.leftNode.PreOrderSearch(no);
        }
        //如果不为null 那么代表左边找到了直接返回即可
        if (resNode != null) {
            return resNode;
        }
        //  判断右边节点是不是空 如果不是空的话 那么就递归前序查找
        //    如果找到的话 就返回找到的节点
        if (this.rightNode != null) {
            resNode = this.rightNode.PreOrderSearch(no);
        }
        return resNode;
    }

    //   中序查找
    public heroNode infixOrderSearch(int no) {

        //要返回的节点
        heroNode resNode = null;
        //  判断左边节点是不是空 如果不是空的话 那么就递归中序查找
        //    如果找到的话 就返回找到的节点
        if (this.leftNode != null) {
            resNode = this.leftNode.infixOrderSearch(no);
        }
        //如果不为null 那么代表左边找到了直接返回即可
        if (resNode != null) {
            return resNode;
        }
        //比较当前节点的no 是不是我们要搜索的
        System.out.println("中序查找");
        if (this.id == no) {
            return this;
        }
        //  判断右边节点是不是空 如果不是空的话 那么就递归中序查找
        //    如果找到的话 就返回找到的节点
        if (this.rightNode != null) {
            resNode = this.rightNode.infixOrderSearch(no);
        }
        return resNode;
    }

    //   后序查找
    public heroNode postOrderSearch(int no) {

        //要返回的节点
        heroNode resNode = null;
        //  判断左边节点是不是空 如果不是空的话 那么就递归后序查找
        //    如果找到的话 就返回找到的节点
        if (this.leftNode != null) {
            resNode = this.leftNode.postOrderSearch(no);
        }
        //如果不为null 那么代表左边找到了直接返回即可
        if (resNode != null) {
            return resNode;
        }
        //  判断右边节点是不是空 如果不是空的话 那么就递归后序查找
        //    如果找到的话 就返回找到的节点
        if (this.rightNode != null) {
            resNode = this.rightNode.postOrderSearch(no);
        }
        //如果不为null 那么代表右边找到了直接返回即可
        if (resNode != null) {
            return resNode;
        }
        System.out.println("后序查找");
        //左右子树，都没有找到，那么就比较当前节点的no 是不是我们要搜索的
        if (this.id == no) {
            return this;
        }
        return resNode;
    }


    //    删除 
    public void deleteNode(int no) {
        //    向左边遍历 如果左边子树有点话就将左边子树置空，如果不是就遍历右边
        if (this.leftNode != null && this.leftNode.id == no) {
            this.leftNode = null;
            return;
        }
        //    向右边遍历 如果右边子树有点话就将左边子树置空，如果左右都没有那么就绪要递归的删除
        if (this.rightNode != null && this.rightNode.id == no) {
            this.rightNode = null;
            return;
        }
        //    如果上面两步都不成功那么我们先向左边递归删除
        if (this.leftNode != null) {
            this.leftNode.deleteNode(no);
        }

        //    如果递归删除左子树也没有成功删除，那么就递归删除右边子树
        if (this.rightNode != null) {
            this.rightNode.deleteNode(no);
        }
    }

}
冷环渊
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
python 数据结构 算法 LeetCode 牛客 面试 编程之美 动态规划 字典树 快速排序 树 字符串 数组 链表 全排列
10-08
树 * 字典树 * 遍历-层次遍历 * 遍历-中序遍历-非递归 * 遍历-前序遍历-非递归 * 遍历-后序遍历-非递归 * 二叉查找树-两数之和 * 二叉查找树-中第K小的元素 * 二叉查找树-从有序数组中构造二叉查找树 * 二叉查找树-从有序链表构造平衡的二叉查找树 * 二叉树-的最大深度 数组&字符串 查找排序 排列组合 动态规划 树 链表 数学 位运算 编程之美
数据结构之二叉树链表.rar
12-11
基于vs环境下实现了数据结构之二叉树链表形式，将原有的利用数组存储二叉树进行了改进，能够利用指针进行修改。可以进行插入和删除节点操作，以及对二叉树进行前中后序遍历。
Java版数据结构代码，栈，动态数组，队列，链表，二叉树
07-28
在队列的代码中，引用了链表的代码
数据结构和算法实现，实现链表，数组，二叉树等
11-08
数据结构和算法实现
二叉树的优势
weixin_34082177的博客
04-24 2759
在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。   有序二叉树天然具有对数查找效率；二叉树天然具有链表特征。 与哈希表比较具有天然排...
链表和二叉树
lzy520o的博客
05-16 1308
链表 链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内 存结构（节点），按特定的顺序链接在一起的抽象数据类型。 链表是离散存储性结构 常用链表有3类：单链表、双向链表、循环链表 数组是一种连续存储线性结构，元素类型相同，大小相等。 链表和数组各自的优缺点： 链表 优点：空间没有限制 、插入删除元素很快 缺点：存取速度慢 数组 优点：存取速度快 缺点：必须事先知道数组的长度、插入删除元素很慢、空间有限制 单链表 由各个内存结构通过一个Next指针链接在一起组成，每一
二叉树学习笔记一 树、数组、链表比较
promiseful的博客
05-03 696
1） 数组存储方式的分析 优点：通过下标访问元素,速度快。对于有序数组,还可以使用二分查找提高检索速度。 缺点：如果要检索到具体某个值,或者插入值（按一定的顺序）会整体移动,效率低。 2）链式存储方式的分析 优点：在一定程度上对数组存储方式有优化（插入一个数值节点,只需将插入节点,连接到链表中即可,删除效率也可以）。 缺点：在进行检索的时候,效率比...
数据结构树
qq_25359343的博客
05-27 658
asdf
二叉树的理论基础
j13733143423的博客
06-23 118
深度优先遍历一般我们都是使用递归法来解决的，其实栈这种数据结构底层就是用递归来实现的（先进后出），所以说每次每一次出栈都要等到上面的元素都出去了当前元素才能出去，就像递归必须等到里面的函数执行完并且返回数值的时候，当前的函数才能继续往下执行。深度优先搜素一般是使用队列来实现的，利用队列先进先出的特性来实现一层一层的遍历。上面我们也说了二叉树主要有两种存储方式：链式存储和顺序存储。顺序存储就是⽤数组来存， 这个定义没啥可说的。下面我们就来看看链式存储的二叉树节点定义的方式：int val;
数据结构-----二叉树
qianggea11的博客
06-02 261
C++数据结构：二叉树 二叉树是一种重要的数据结构，与数组、向量、链表都是一种顺序容器，它们提供了按位置访问数据的手段。但是有一个缺点，它们都是按照位置来确定数据，想要通过值来获取数据，只能通过遍历的方式。而二叉树在很大程度上解决了这个缺点，二叉树是按值来保存元素，也按值来访问元素。二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树是递归定义的。二叉树底层数据结构最好采用链表描述...
数据结构-数组、链表、栈、队列、树、图研究如何组织和存储数据
最新发布
06-18
常见的数据结构包括数组、链表、栈、队列、树、图等。每种数据结构都有其特定的应用场景和优劣势，选择合适的数据结构可以显著提高算法的效率和性能。 1. **数组（Array）**：连续的内存空间组成的数据结构，支持...
算法之有序链表和平衡二叉树有序数组与平衡二叉树 数组和链表.pdf
04-18
有序链表是一种特殊的数据结构，其中元素按照升序排列。在计算机科学中，平衡二叉查找树（Balanced Binary Search Tree，简称BBST）是一种特殊的二叉树，它满足以下性质： 1. 每个节点的左子树只包含比其小的元素。...
【数据结构与算法 13】二叉树
学Java，找哪吒
05-28 4392
一、前言 数组的搜索比较方便，可以直接用下标，但删除和插入就比较麻烦； 链表与之相反，删除和插入元素很快，但查找比较慢； 此时，二叉顺序树应运而生，二叉顺序树既有链表的好处，也有数组的好处，在处理大批量的动态数据时比较好用，是一种折中的选择。 文件系统和数据库系统一般都是采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。 二叉顺序树是一种最基本最典型的排序树，用于教学和研究树的特性，本身很少在实际中进行应用，因为缺点太明显，就像冒泡排序一样，因为效率问题并不实用，但也是我们必须会的。
二叉排序树。我们之前的huffmanTree 并没有解释 树对于数组或者说链表的优势
Be_With_I的博客
03-06 106
二叉排序树的特点是 左边小于 上边，上边小于右边。 如果有相同的数据：其实可以挂在左边或者右边。 结论是 左边不能大于上边。右边不能小于上边。 这种有序的二叉树。在查找位置的时候，相当于用了二分查找。 在插入的时候，也不会影响其他节点。直接加上，删除需要处理的也不多和链表相似。 所以其效率很高。 ...
各种数据结构及其优缺点和应用
weixin_44802051的博客
12-10 3297
各种数据结构及其优缺点和应用一、顺序表二、链表三、二叉排序树四、平衡二叉树五、红黑树六、B树七、B+树七、哈夫曼树八、堆九、栈十、队列十一、哈希表十二、图生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、顺序表 优点：本身为连续的内存块，访问元素效率高O(1)。 缺点：大小固定，扩展开销大，插入和删除开销大O(n)。 使用场
二叉树的优点和缺点
weixin_30895603的博客
04-28 4584
二叉树的优点和缺点 二叉排序树是一种比较有用的折衷方案。 数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。 链表与之相反，删除和插入元素很快，但查找很慢。 二叉排序树就既有链表的好处，也有数组的好处。 在处理大批量的动态的数据是比较有用。 文件系统和数据库系统一般都采用树（特别是B树）的数据结...
二叉树的存储方式【顺序储存（数组）、链式存储、邻接表存储等】
热门推荐
马小超
09-18 1万+
1.顺序存储结构 二叉树的顺序存储，就是用一组连续的存储单元存放二叉树中的结点。因此，必须把二叉树的所有结点安排成为一个恰当的序列，结点在这个序列中的相互位置能反映出结点之间的逻辑关系，用编号的方法从树根起，自上层至下层，每层自左至右地给所有结点编号,缺点是有可能对存储空间造成极大的浪费，在最坏的情况下，一个深度为k且只有k个结点的右单支树需要2k-1个结点存储空间。 依据二叉树的性质，完全二叉树和满二叉树采用顺序存储比较合适，树中结点的序号可以唯一地反映出结点之间的逻辑关系，这样既能够最大可能地节省存
排序——希尔排序
2301_80662872的博客
06-16 605
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
链表,数组，队列，二叉树，哪些属于存储结构，为什么
12-02
链表、数组、队列和二叉树都属于数据结构中的存储结构。因为它们都是用来存储数据的具体方式，而不是描述数据之间逻辑关系的学科。具体来说： - 数组是一种线性存储结构，用一段连续的内存空间来存储相同类型的数据元素，可以通过下标来访问数组中的元素。 - 链表是一种非线性存储结构，由若干个节点组成，每个节点包含数据和指向下一个节点的指针，通过指针来连接各个节点。 - 队列是一种先进先出的线性存储结构，只允许在队列的一端插入元素，在另一端删除元素。 - 二叉树是一种非线性存储结构，由根节点、左子树和右子树组成，每个节点最多有两个子节点，左子树上的所有节点的值都小于根节点的值，右子树上的所有节点的值都大于根节点的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冷环渊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值