数据结构与算法-087-106 哈希表与二叉树

最新推荐文章于 2024-07-25 15:54:48 发布
最新推荐文章于 2024-07-25 15:54:48 发布
阅读量165 收藏 1
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46998705/article/details/108394530
版权

087-089 哈希表

087 哈希表实现思路图解

基本介绍：
哈希表的基本介绍（Hash table，也叫哈希表），是根据关键码值（key value）而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

088-089 哈希表代码实现1-2

package com.old.hashTable_087_089;

import java.util.Random;
import java.util.Scanner;

public class HashTableDemo {
   
    public static void main(String[] args) {
   
        //创建哈希表
        HashTable hashTable = new HashTable(7);
        int size = hashTable.getSize();
        int count = size * 2;
        Random random = new Random(count);
        for (int i = 0; i < size; i++) {
   
            int id = random.nextInt();
            hashTable.add(new Emp(id, id + "号"));
        }
        //写一个简单菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        boolean flag = true;
        while (flag) {
   
            System.out.println("1.添加");
            System.out.println("2.显示");
            System.out.println("3.退出");
            key = scanner.nextLine();
            try {
   
                switch (key) {
   
                    case "1":
                        System.out.println("输入id");
                        int id = scanner.nextInt();
                        System.out.println("输入名称");
                        String name = scanner.next();
                        Emp emp = new Emp(id, name);
                        hashTable.add(emp);
                        break;
                    case "2":
                        hashTable.list();
                        break;
                    case "3":
                        flag = false;
                        break;
                    case "4":
                        System.out.println("输入要查找的id");
                         id = scanner.nextInt();
                        hashTable.findEmpById(id);

                        break;
                }
                key = null;
                System.out.println();
            } catch (Exception e) {
   
                e.printStackTrace();
            }
        }
        scanner.close();

    }
}


/**
 * 创建 HashTable 管理多条链表
 */
class HashTable {
   

    private EmpLinkedList[] empLinkedListArray;
    private int size;

    public int getSize() {
   
        return size;
    }

    /**
     * 构造器
     */
    public HashTable(int size) {
   
        this.size = size;
        empLinkedListArray = new EmpLinkedList[size];
        for (int i = 0; i < size; i++) {
   
            empLinkedListArray[i] = new EmpLinkedList();
        }
    }

    /**
     * 添加雇员
     */
    public void add(Emp emp) {
   
        //根据员工的 id ， 得到该员工应当添加到哪条链表
        int empLinkedListNO = hashFun(emp.id);

        EmpLinkedList empLinkedList = empLinkedListArray[empLinkedListNO];
        empLinkedList.add(emp);
    }

    /**
     * 遍历所有的链表，遍历哈希表
     */
    public void list() {
   
        for (int i = 0; i < empLinkedListArray.length; i++) {
   
            empLinkedListArray[i].list( i + 1);
        }
    }

    /**
     *
     */
    public void findEmpById(int id){
   
        //使用散列函数确定到哪条链表
        int empLinkedListNO = hashFun(id);
        Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
        System.out.println("第" + (empLinkedListNO + 1) + "条链表中找到: " + emp);
    }

    /**
     * 编写散列函数，使用一个简单取模法
     *
     * @param id
     * @return
     */
    public int hashFun(int id) {
   
        return id % size;
    }

}

class Emp {
   
    public int id;
    public String name;
    public Emp next;

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

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


//创建 EmpLinkedList ，表示链表
class EmpLinkedList {
   
    //头指针，执行第一个Emp，因此我们这个链表的 head，是直接指向第一个 Emp
    private Emp head; //默认是空的

    /**
     * 添加员工
     * 1. 假定，当添加雇员时，id 是自增长的，即id的分配问题从小到大
     * 2. 因此我们将该雇员直接加入到本链表的最后即可
     *
     * @param emp
     */
    public void add(Emp emp) {
   
        //如果是添加第一个
        if (head == null) {
   
            head = emp;
            return;
        }
        //如果不是第一个雇员，则使用一个辅助指针，帮助定位到最后
        Emp curEmp = this.head;
        while (true) {
   
            //说明到链表最后
            if (curEmp.next == null) {
   
                break;
            }
            //后移
            curEmp = curEmp.next;
        }
        //退出时，直接将 emp 加入链表
        curEmp.next = emp;
    }

    public void list(int no) {
   
        if (head == null) {
   
            //说明链表为空
            System.out.println("链表为空");
            return;
        }
        //辅助指针
        Emp curEmp = head;
        while (true) {
   
            System.out.println("第" + no + "条链表，id:" + curEmp.id  + "名称："+ curEmp.name);
            if (curEmp.next == null) {
   
                //说明已经是最后结点
                break;
            }
            //后移，遍历
            curEmp = curEmp.next;
        }
        System.out.println();
    }

    /**
     *
     */
    public void mylist() {
   
        if (head == null) {
   
            //说明链表为空
            System.out.println("链表为空");
            return;
        }
        for (Emp curEmp = head; curEmp != null; curEmp = curEmp.next) {
   
            System.out.println(curEmp);
        }
    }

    /**
     * my 是我写的
     *
     * @param emp
     */
    public void myAdd(Emp emp) {
   
        //如果是添加第一个
        if (head == null) {
   
            head = emp;
            return;
        }
        //如果不是第一个雇员，则使用一个辅助指针，帮助定位到最后
        Emp temp = this.head;
        while (temp != null) {
   
            temp = temp.next;
        }
        temp = emp;
        return;
    }

    public Emp findEmpById(int id){
   
        if (head == null){
   
            System.out.println("链表为空");
            return null;
        }

        //辅助指针
        Emp curEmp = head;
        while (true){
   
            if (curEmp.id == id){
   
                //找到
                break;
            }
            //退出
            if (curEmp.next == null){
   
                //说明遍历当前链表没有找到该雇员，即退出
                curEmp = null;
            }
            curEmp = curEmp.next;
        }
        return curEmp;
    }

    /**
     * 根据id查找雇员
     * @param id
     * @return
     */
    public Emp myFindEmpById(int id){
   
        for (Emp curEmp = head; curEmp != null; curEmp = curEmp.next) {
   
            if (curEmp.id == id){
   
                return curEmp;
            }
        }
        return null;
    }
}

090-106 二叉树

090 数组、链表、树存储方式

二叉树

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

  • 链式存储方式的分析
    优点：在一定程度上对数组存储方式有优化（比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好）
    缺点：在进行检索时，效率仍然较低，比如：检索某个值，需要从头节点开始遍历

  • 树存储方式的分析
    能提高数据存储，读取的效率，比如利用 **二叉排序树（Binary Sort Tree），既可以保证数据的检索速度，同时可以保证数据的插入，删除，修改的速度）

ArrayList 的底层操作机制源码分析

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

#＃ 091 二叉树的概念和常用术语
树的常用术语

  • 节点
  • 根节点
  • 父节点
  • 子节点
  • 叶子节点（没有子节点的节点）
  • 节点的权（节点值）
  • 路径（从 root 节点找到该节点的路线）
  • 层
  • 子树
  • 树的高度（最大层度）
  • 森林：多颗子树构成森林

在这里插入图片描述

二叉树的概念

  • 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树
  • 二叉树的子节点分为左节点和右节点
  • 如果该二叉树的的所有叶子节点都在最后一层，并且结点总数(这里的结点总数，是指所有的结点)=2n - 1 , n 为层数，则我们称为二叉树
  • 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

在这里插入图片描述

在这里插入图片描述

092 前序中序后序遍历二叉树的图解

在这里插入图片描述

前序遍历：先输出父节点，再遍历左子树和右子树
中序遍历：先遍历左子树，再输出父节点，再遍历右子树
后序遍历：先遍历左子树，再遍历右子树，最后输出父节点
小结：看输出父节点的顺序，就确定是前序、中序不是后序

图解

  1. 创建一棵二叉树
  2. 前序遍历
    1. 先输出当前节点（初始的时候是root节点）
    2. 如果左子节点不为空，则递归继续前序遍历
    3. 如果右子节点不为空，则递归继续前序遍历
  3. 中序遍历
    1. 如果当前节点的左子节点不为空，则递归继续中序遍历
    2. 先输出当前节点
    3. 如果当前节点的右子节点不为空，则递归继续中序遍历
  4. 后序遍历
    1. 如果当前节点的左子节点不为空，则递归后序遍历
    2. 如果当前节点的右子节点不为空，则递归后序遍历
    3. 先输出当前节点

在这里插入图片描述

093-094 前序中序后序遍历代码实现

package com.old.Tree_90;

public class BinaryTreeDemo {
   
    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, "关胜");
        //先手动创建二叉树，后面以递归的方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);

        node3.setRight(node4);

        binaryTree.setRoot(root);
        System.out.println("前序遍历");
        binaryTree.preOrder();//1,2,3,4
        System.out.println();

        System.out.println("中序遍历");
        binaryTree.infixOrder();//2,1,3,4
        System.out.println();


        System.out.println("后序遍历");
        binaryTree.postOrder();//2,4,3,1
        System.out.println();


        node3.setLeft(node5);
        System.out.println("前序遍历");
        binaryTree.preOrder();//1,2,3,5,4
        System.out.println();

        System.out.println("中序遍历");
        binaryTree.infixOrder();//2,1,5,3,4
        System.out.println();


        System.out.println("后序遍历");
        binaryTree.postOrder();//2,5,4,3,1
        System.out.println();
    }
}

/**
 * 定义BinaryTree
 */
class BinaryTree {
   
    private HeroNode root;

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

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

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

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

}

/**
 *
 */
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 void setNo(int no) {
   
        this.no = no;
    }

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

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

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

    public int getNo() {
   
        return no;
    }

    public String getName() {
   
        return name;
    }

    public HeroNode getLeft() {
   
        return left;
    }

    public HeroNode getRight() {
   
        return 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);

    }
}

095-097 前序中序后序查找

095 思路图解

前序、中序、后序的方式来查询指定的结点

前序查找

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

中序查找

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

后序查找

  • 判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
  • 如果找到，就返回，如果没有找到，就判断当前结点的右子节点是否为空，如果不为空，则右递归进行后序查找，如果找到，就返回
  • 就和当前结点进行，比如，如果是则返回，否则返回null

在这里插入图片描述

096-097 代码实现

package com.old.Tree_90;

public class BinaryTreeDemo {
   
    public static void main(String[] args) {
   
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的节点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new
最低0.47元/天 解锁文章
1854君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法-127-134-二叉排序树
m0_46998705的博客
11-02 810
127 二叉排序树（BST）的介绍 数列：{7，3，10，12，5，1，9}，要求能高效的完成对数据的查询和添加 解决方案分析： 使用数组， 数组未排序，优点直接在数组尾添加，速度快。缺点：查找速度慢 数组排序，优点：可以使用二分查找，查找速度快，缺点：为了保证数组有序在添加新数据时，找到插入位置后，后面的数据需整体移动，速度慢 使用链式存储-链表 不管链表是否有序，查找都慢，添加数据速度比数组快，不需要整体移动 使用二叉排序树 二叉树排序树 介绍： 二叉排序树：BST（Binary Sort（Sear
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
【算法与数据结构】哈希表
weixin_54383080的博客
05-04 1508
数据结构之哈希表，从生活实例引入哈希表存在的意义，重点讲述了哈希函数的意义以及如何应对哈希冲突。
重学数据结构五：数据结构基础-树和二叉树、哈希表
qq_44969643的博客
07-12 7893
树 树是由结点和边组成的，不存在环的一种数据结构。 树满足递归定义的特性。也就是说，如果一个数据结构是树结构，那么剔除掉根结点后，得到的若干个子结构也是树，通常称作子树。 1）A 结点是 B 结点和 C 结点的上级，则 A 就是 B 和 C 的父结点，B 和 C 是 A 的子结点。 2）B 和 C 同时是 A 的“孩子”，则可以称 B 和 C 互为兄弟结点。 3）A 没有父结点，则可以称 A 为根结点。 4）G、H、I、F 结点都没有子结点，则称 G、H、I、F 为叶子结点。 二叉树 1）满二叉树，定义为
极客时间-数据结构与算法-王争.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法-小例子.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构与算法-学习笔记 Java 版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
DataStructure-尚硅谷-数据结构与算法-数据结构.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
计算机基础-数据结构与算法.pdf
10-07
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。在这个领域，我们涉及的知识点广泛，主要包括数据结构如栈、队列、二叉树，以及解决哈希冲突的方法和各种排序算法。 栈是一种特殊线性表，遵循...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 162
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 292
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 412
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 724
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 959
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1155
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
最新发布
2303_81073778的博客
07-25 184
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 456
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构与算法》- 王晓东解读
"《数据结构与算法》是王晓东编著的一本教材，主要涵盖了数据结构和算法的基础概念，包括表、栈、队列、递归、排序与选择、树、集合、符号表、字典、优先队列、并查集和图等内容。本书旨在适应21世纪计算机人才的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值