数据结构 - Jul1en

前言

Tue, 27 May 2025 08:30:48 +0000

前言

数据结构是一种基于多维数据的多种处理方式，对合适的数据运用合适的数据结构

集合框架

又称为容器，是在java.util包里的一些Interface和实现类Class，有强大的功能，且平时用到的Scanner、Arrays、Iterator都在Utils包下

工作中最高频使用的数据结构

ArrayList / 数组
HashMap
Queue

其他的Stack、Linkedlist，TreeSet等等很少用到

‍

Map & Set

Mon, 19 May 2025 13:26:18 +0000

Map & Set

#搜索树#

概念

二叉搜索树/二叉排序树，满足以下性质

若左树不为空，则左树上所有节点的值都小于父节点的值
若右树不为空，则右树上所有节点的值都大于父节点的值
它的左右子树也满足以上性质

二叉搜索树的中序遍历是有序的：{0，1，2，3，4，5，6，7，8，9}

搜索树操作

插入`Insert`

搜索树的插入也要满足本身性质，若插入元素在原本的搜索树中已经拥有，则插入失败

思路：定义Cur走到null位置，同时Parent做Cur的根节点，记录Cur之前走过的位置，避免cur定位丢失

public boolean insert(int key) {
        if (root == null) {
            root = new TreeNode(key);
            return true;
        }
        TreeNode cur = root;
        TreeNode parent = null;
        while (cur != null) {
            if (cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else if (cur.val > key){
                parent = cur;
                cur = cur.left;
            }else {
                return false;
            }
        }
        TreeNode newNode = new TreeNode(key);
        if (parent.val > key) {
            parent.left = newNode;
        }else {
            parent.right = newNode;
        }
        return true;
    }

查找`Remove`

定义Cur遍历搜索树，在对比左右子树.val 与Key的大小关系时，注意Cur的遍历方向

public TreeNode searchTree (int key) {
        if (root == null) {
            return null;
        }
        TreeNode cur = root;
        while (cur != null) {
            if (cur.val < key) {
                cur = cur.right;
            }else if (cur.val > key){
                cur = cur.left;
            }else {
                return cur;
            }
        }
        return null;
    }

删除

删除节点时，要注意不要破坏二叉搜索树的性质

思路：定义Cur并定位到待删除节点，待删除节点的父节点为Parent，找到Cur后分三种情况

cur.left == null 三种情况
cur.right == null 三种情况
cur两边都不为空的情况

此时需要替换法进行删除，找到右子树中的最小节点（即最左节点），用它的值来填补到被删除节点中，覆盖Cur节点，再处理节点的指向问题

Q&A
- 为什么不直取一层左子节点？—— 我验证过了用while确实没问题，用if仅检查一层，是无法找到真正的最小节点

主框架：删除的准备工作

public void remove(int key) {
        if (root == null) {
            System.out.println("树为空");
            return;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while (cur != null) {
            if (cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else if (cur.val > key){
                parent = cur;
                cur = cur.left;
            }else {
                removeNode(parent,cur);
                return;
            }
        }
    }

删除的实际操作在removeNode方法中

private void removeNode(TreeNode parent, TreeNode cur) {
        if (cur.left == null) {
            if (cur == root) {
                root = root.right;
            }else if (cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if (cur.right == null){
            if (cur == root) {
                root = root.left;
            } else if (cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            TreeNode targetParent = cur;
            TreeNode target = targetParent.right;
            //找到右树中最左边的节点
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;

            if (target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }

搜索

Map和Set是专门搜索的数据结构，但他们的搜索效率与其他们具体实例化的子类有关——两者都是接口

以前的搜索方式有遍历搜索，二分查找，但都是适用于静态查找。当涉及到插删查改的操作时，我们需要效率更高的查找方式，即动态查找，此时引出查找工具——Map和Set——适合动态查找的集合容器

模型

我们一般把要搜索的数据叫做关键字，而关键字中可能或带有对应的“值”，我们叫键值对Key-Value

比如一个数组{1，2，3，4，4，4}，我们要寻找每一个数字出现的次数，此时寻找的数字是关键字，而它们出现的次数则称之为对应的“值” 如数字4出现了3次，则键值对是<4 , 3>或<3 , 4>

纯Key模型
Key-Value模型

Set中只存储Key模型，而Map存储Key-Value模型

Map

Map是一个接口，存储的是<Key , Value>键值对，并且k是唯一的

实例化对象需要实现类#TreeMap#或#HashMap#，还有个#LinkedHashMap#，基于HashMap维护了一个双向链表记录来记录元素的插入次序

TreeMap和HashMap的区别

TreeMap的Key不能传null

常用方法

V put——存放键值

🧭 步骤：
1. 调用 key 的 hashCode() 方法
2. 扰动函数处理（JDK 1.8 引入，提升 hash 分布质量）
```
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```
小技巧：h ^ (h >>> 16) 这一步是为了让高位参与运算，因为哈希表大小是 2 的幂，只看低位的话容易冲突。
1. 根据数组长度计算 index
```
index = (n - 1) & hash;
```
⚠️ 这里是一个位与操作，比取模 % 快得多（因为 n 是 2 的幂）
1. 判断桶是否为空：
  - 如果是空，直接插入
  - 如果不为空，遍历链表：
    - 如果已有相同 key（hash 相同 && equals() 返回 true），则覆盖
    - 否则添加到链表尾部（或树）
2. 链表长度超过 8 时（阈值）：转为红黑树
3. 元素总数超过负载因子 × 容量时：触发扩容（resize）
V get——返回key对应的value
V getOrDefault——返回key对应的value，如果key不存在，==则建立新的key并返回新默认的value==
V remove——移除的key
Set<> keySet（需要Set<>来接收）——返回所有不重复的key值的集合
Collection<> values（需要Collection<>来接收）——返回所有不重复的value的集合
✨Set<Map.entry<K , V» entrySet（需要Set<Map.entry<K , V»接收）——返回所有的Key-Value的映射关系的集合

关于Map.entry<K , V>

entry可以看成是一个节点，相当于二叉树的Node节点，将键值打包成entry节点放入Set里面，同时它自身也实现了getValue和getKey方法

Set<Map.Entry<Object, Integer>> set = map.entrySet(); for (Map.Entry<Object, Integer> entry: set) { System.out.println("key: "+entry.getKey()+" -> val: "+entry.getValue()); }

若直接打印set则是各个Key-Value的集合
boolean containsKey
boolean containsValue

总结

Map是一个接口，不能直接实例化对象，如果要实例化对象需要实现类TreeMap或HashMap
Map中的Key / Value都可以被全部分离出来存到Set / Collection当中，Key是唯一的，Value可以重复
Map中的Key不能被修改，Value可以被修改，如果要修改Key只能先删除再建立新的Key
TreeMap的Key不能传null，HashMap可以——TreeMap的remove就不能传null，HashMap可以
✨Map中传的Key一定要可以比较——搜索树本质上来说每插入一个元素都要进行大小比较

解决办法：
1. 给自定义类实现Comparable接口——（TreeMap）
2. 构造TreeMap时传比较器，注意HashMap不能传比较器——（TreeMap）
3. 重写equals和hashCode方法——（HashMap）

Set

Set也是一个接口，他没有具体的对象，继承自Collection接口类，只能存储Key模型，而且Key也是唯一的，可以把它看成一个塑料袋（集合），里面装着杂乱无序的不重复的数据。

实现Set接口要实现类#TreeSet#和#HashSet#，还有个#LinkedHashSet#，是在HashSet的基础上维护了一个双向链表来记录元素的插入次序

TreeSet和HashSet区别

TreeSet插入的Key不能是null——会空指针异常，但HashSet可以

常见方法

boolean add——添加数据，但重复元素不会被添加成功
boolean remove——删除集合中的所选数据
void clear——清空集合
boolean contains
Iterator iterator——返回迭代器

注意Map没有本身继承迭代器接口，如果需要迭代器遍历，需要强转为Set/List/Queue接口或者通过 keySet()、entrySet()、values() 来获取集合视图并迭代

总结

Set只能存储K，且K也是和Map一样唯一的
💫TreeSet的底层是用Map实现的，其使用的Key与Object的一个默认的对象（Value）组成键值插入到Map中
TreeSet插入的Key不能是null，但HashSet可以——故TreeSet的remove不能传null，HashSet可以传null
Set最大的功能是对Key去重——TreeSet是天然去重的
Set中的Key也是像Map一样不能修改的，如需修改要删除
✨Set中的Key也是一定要可比较——原理同Map

解决方法：
1. 给自定义类实现Comparable接口——（TreeSet）
2. 构造TreeSet传入比较器，同理HashSet不能传比较器——（TreeSet）
3. 重写equals和hashCode方法——（HashSet)

Map和Set的关系

TreeSet的底层是用Map实现的，其使用的Key与Object的一个默认的对象（Value）组成键值插入到Map中
TreeMap和TreeSet的复杂度都是log₂N，它们的 K 都是要能比较大小的。
HashMap和HashSet的复杂度都是O（1），
两者都是集合类型，且底层通常基于哈希表或红黑树来实现，两者的数据结构存在差异：Set主要关注元素的唯一性，但Map更关注键值对的关系

‍

前面提到了HashMap，HashSet，LinkedHashMap，LinkedHashSet，那Hash到底是什么呢？为什么他们的效率这么高？这就引入哈希表的概念

哈希表/散列表

概念

理想的搜索方法：不经过任何的比较，一次直接从表中得到想要的元素。如果构造一种存储结构，能够通过某种函数使得元素与它的关键字/码之间建立某种联系，那么在查找的时候就很容易得到这些元素

该方式就叫哈希方法，哈希方法中使用的函数就叫做==哈希函数/散列函数==，构造出来的结构就为==哈希表/散列表==

‍

每一种数据结构它的哈希函数都不一致，但是哈希表本质上是一个数组，不过数组不是放的单一数据，而是存放的键值对，所以哈希表是数组的一种拓展，这是哈希表的表现形式

我们将学生信息包括名字和岁数（Key—Value），我们先通过哈希函数让Key进行计算，得出Index，确定键值对entry存放的位置，但是有一个问题，如果数据多了，别的key通过哈希函数可能也会得到相同的下标Index，像这样具有不同关键码但具有相同哈希地址的数据元素称为“同义词”，这个问题我们称之==哈希冲突，==哈希是一种用来进行高效查找的==数据结构==

哈希冲突

那么有哈希冲突就会有解决哈希冲突问题的办法

‍

哈希冲突是必然的，我们做的应该是降低冲突率，引起冲突的一个原因可能是哈希函数设计不合理，但是我们一般都不会涉及到设计哈希函数，但常用的哈希函数我们需要了解

哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

那反应哈希冲突率的一个数据叫负载因子

负载因子

哈希列表的负载因子定义为 α = 填入表中的元素 / 哈希表的长度

避免哈希冲突

两个方法 : 优化哈希函数、降低负载因子✨

💯降低负载因子即需要对数组进行扩容，扩容之后需要对原来的数组的元素进行重新哈希分配——即重新哈希

public void resize() {
	Node[] newArray = new Node[array.length * 2];
	for(int i = 0; i < array.length; i++) {
		Node cur = array[i];
		while(cur != null) {
			int newIndex = cur.key%(newArray.length);
			Node curN = cur.next;
			cur.next = newArray[newindex];
			newArray[newindex] = cur;
			cur = curN;
		}
	}
	array = newArray;
}

解决哈希冲突

两种常见方法：#闭散列#和#开散列#

注意要区分清楚：哈希冲突的处理方法和哈希函数

哈希函数作用是：建立元素与其存储位置之前的对应关系的，在存储元素时，先通过哈希函数计算元素在哈希表格中的存储位置，然后存储元素。好的哈希函数可以减少冲突的概率，但是不能够绝对避免，万一发生哈希冲突，得需要借助哈希冲突处理方法来解决。

常见的哈希函数有：直接定址法、除留余数法、平方取中法、随机数法、数字分析法、叠加法等
常见哈希冲突处理：闭散列（线性探测、二次探测）、开散列(链地址法)、多次散列

闭散列

也叫#开放地址法#，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表还有位置可以放，那么就可以把Key放到空的位置上

线性探测：从发生冲突的位置开始找到空位置放
二次探测：优化了线性探测的问题（不重点解释，需要可再查找）

💫开散列（重点）

开散列，又叫#链地址法#（#拉链法#），首先对关键码集合用哈希函数计算哈希地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

与闭散列不同，这种将链表的头地址存储在哈希表的方式，不会影响与自己哈希地址不同的元素的增删查改的效率

放入的entry可以用头插也可以用尾插法，与链表的操作相似，由此可见，开散列的每个桶当中都放的哈希冲突的元素，

但如果出现极端情况，即所有元素都产生了冲突，都放到了同一个桶之中，那哈希表的增删查改的效率就退化为O（N），此时我们可以把这个桶转化为红黑树 TreeMap or TreeSet，效率就为O（log₂N）

树化条件：链表的长度 >= 8 && 数组长度 >= 64 如果红黑树删除后不满足条件或没必要再用红黑树时可以变回为哈希桶的结构

开散列可以认为是把大集合中的搜索问题转化为了小集合中做搜索了

💫与Java类集合的关系

HashMap和HashSet都是Java中利用哈希表来实现的Map和Set
Java会在冲突链表长度大于一定阈值的时候，将链表树化为红黑树TreeSet or TreeMap
Java是用哈希桶来解决哈希冲突的（链表）
✨Java计算的哈希值实际上是调用类的hashCode方法，进行Key的对比时是调用equals方法。所以如果要调用自定义类作为HashMap或HashSet的值，必须覆写hashCode和equals方法，而且做到equals相等的对象，其hashCode一定是相等的，反之则不一定——hashCode相等equals未必相等（哈希冲突）

自定义类重写hashCode（）和equals（）接口

#平均查找长度#

len = 总的比较次数 / 元素个数

‍

数据结构——排序

Mon, 19 May 2025 02:43:08 +0000

数据结构——排序

排序概念

在数据结构中，有许多无序的数据，所谓排序，就是使一串无序的记录，按照其中某个或某些关键字的大小，来进行递增或者递减的排列起来的操作

#稳定性#

在待排序的数据中，存在一些相同数据的，如果排序之后他们的相对位置保持不变，那么这个排序就是稳定的，相反则不稳定

常见排序

直接插入排序 `InsertSort`

类似于扑克牌的排法，先有第一张”牌“，然后插入新的元素进来与前面的”牌“比较，最终使得整幅”牌“趋于有序

直接插入排序特性总结

元素集合越接近有序，直接插入排序的效率越高——可以嵌套快排中，优化排序效率
时间复杂度 o（N²）——每张”牌“都需要进行对比
空间复杂度 o（1）——基于原本的数组进行排序，没有开辟新的空间
稳定性：稳定

‍

代码块

public void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0; j--) {
                //如果是 >= 那就不稳定了
                if (array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    //array[j+1] = tmp;
                    break;
                }
            }
            //j == -1
            array[j+1] = tmp;
        }
    }

希尔排序`ShellSort`——优化直接插入排序 ✨

先选定一个整数 Gap，把数据分成多个组，所有距离为 Gap 的记录分在同一个组内，对组内进行排序，然后让 Gap 趋于 1，此时再排序数据就是有序的

希尔排序特性总结

希尔排序是对直接插入排序的优化
Gap > 1 的时候都是预排序，是为了等 Gap = 1 的时候的排序效率更加高效（ Gap= 1 时是直接插入排序）
时间复杂度 o（N^1.3~1.5）
空间复杂度 o（1）——没有开辟内存
稳定性：不稳定

代码块

public void shellSort(int[] array) {
        int gap = array.length;
        while (gap >= 1) {
            shell(array,gap);
            gap = gap/2;
        }
    }

    public void shell (int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for ( ;j >= 0; j -= gap) {
                if (array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

选择排序`SelectSort`

每次向后寻找最小（或者最大）的元素，找出下标 minIndex（maxIndex）与初始位置进行交换，直到全部待排序的数据元素排完

选择排序特性总结

选择排序的效率不高，通常很少使用
时间复杂度 o（N²）
空间复杂度 o（1）
稳定性：不稳定

代码块

public void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
               if (array[j] < array[minIndex]) {
                   minIndex = j;
               }
            }
            swap(array,i,minIndex);
        }
    }

堆排序`HeapSort`

是指利用堆积树（堆）这种数据结构所设计的⼀种排序算法，它是选择排序的⼀种。它是通过堆来进行选择数据。需要注意的是排升序建大堆，排降序建小堆

堆排序特性总结

堆排序使用堆来选数，效率高
时间复杂度 o（N * log₂N）——数据 N * 树的高度 log₂N
空间复杂度 o（1）
稳定性：不稳定

代码块

public void heapSort(int[] array) {
        int end = array.length-1;

        //创建大根堆
        for (int parent = (end-1)/2; parent >= 0; parent-- ) {
            siftDown(array,parent,array.length-1);
        }
        while (end > 0){
            swap(array,0,end);
            siftDown(array,0,end);
            end--;
        }
    }

    public void siftDown(int[] array, int parent,int length) {
        int child = 2*parent + 1;
        while (child < length) {
            //判断是否有右树
            if (child + 1 < length && array[child] < array[child+1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array,parent,child);
                parent = child;
                child = 2*parent + 1;
            }else {
                break;
            }
        }
    }

冒泡排序`BubbleSort`

冒泡排序特性总结

非常容易理解
时间复杂度 o（N²）
空间复杂度 o（1）
稳定性：稳定

代码块

public void bubbleSort(int[] array) {
        //i表示趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;//优化
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            if (!flg){
                break;
            }
        }
    }

快速排序`QuickSort`✨

任取待排序元素作为基准值，按照该排序将排序集合分为两个子序列（一边是小于基准值，另一边是大于基准值），然后最左右子序列重复该过程，直至所有元素排列完成

public void quickSort(int[] array){
        //接口统一性 ---重载
        quickSort(array,0,array.length-1);
    }
    private static void quickSort(int[] array,int left,int right){
        if (left >= right) {
            return;
        }
        int par = partition(array,left,right);
        quickSort(array,left,par-1);
        quickSort(array,par+1,right);
    }

以上代码为快排的主框架，发现与二叉树的前序遍历规则非常像，此地方写递归方法时可想到二叉树前序遍历规则即可快速写出来，后面只需要分析如何按照基准值对数据进行划分即可

快速排序三种方法的效率对比

挖坑版 > Hoare 版 > 前后指针版

‍

将区间按照基准值划分为左右部分的方式有：

Hoare 版

private int partitionHoare(int[] array,int low,int high) {
        int i = low;
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            while (low < high && array[low] <= tmp) {
                low++;
            }
            swap(array,low,high);
        }
        //left == high
        swap(array,low,i);
        return low;
    }

挖坑版

private int partition(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= tmp) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = tmp;
        return low;
    }

前后指针法

private int partition1(int[] array,int low,int high) {
        int prv = low;//
        int cur = low+1;//找tmp小的
        int tmp = array[low];
        while (low < high) {
            if (array[cur] < tmp && array[++prv] != array[cur]) {
                swap(array,prv,cur);
            }
            cur++;
        }
        swap(array,prv,low);
        return prv;
    }

快排的内部优化

为了使得最开始找的基准值更加合理，提高排序效率，利用三数取中

1.三数取中

找数据的最左边的元素和最右边的元素，再找中间值，取出他们三者之间的平均值的下标

private static int threeMid(int[] array,int low, int high) {
        int mid = (low + high) / 2;
        if (array[low] > array[high]) {
            if (array[mid] < array[high]) {
                return high;
            }else if (array[mid] > array[low]) {
                return low;
            }else {
                return mid;
            }
        }else {
            if (array[mid] < array[low]) {
                return low;
            }else if (array[mid] > array[high]) {
                return high;
            }else {
                return mid;
            }
        }
    }

2.嵌套直接插入排序

当数据集合有序的时候，快排还需要遍历只有右子树的情况，浪费了时间，此时嵌套直接插入排序则可以直接减少遍历

此时针对快排主框架的情况，直接插入排序要做出一点改变，总体框架不变

private static void insertSortRange(int[] array,int low,int high) {
        for (int i = low + 1; i < high; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= low; j--) {
                // 这里 >= 就不是稳定的排序了！！
                if (array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    //array[j+1] = tmp;
                    break;
                }
            }
            //j == -1
            array[j+1] = tmp;
        }
    }

优化后的 QuickSort 的主框架

private static void quickSort(int[] array,int left,int right){
        if (left >= right) {
            return;
        }
        //优化 内置插入排序 趋于有序时减少检查的次数
        if (right - left + 1 <= 8) {
            insertSortRange(array,left,right);
            return;
        }

        //优化 采用三数取中法 找下标 使得tmp更加合理
        int index = threeMid(array,left,right);
        swap(array,index,left);

        int par = partition(array,left,right);
        quickSort(array,left,par-1);
        quickSort(array,par+1,right);
    }

‍

快速排序的特性总结

快排顾名思义，效率高，综合性能与应用场景都是比较好的
时间复杂度：
- 最好情况下 o（N * log₂N）
- 最坏情况下o（N²）
空间复杂度 o：
- 最好情况下 o（log₂N）——满二叉树的情况
- 最坏情况下 o（N）——
稳定性：不稳定

非递归快排`QuickSortNor`

利用栈进行排序

代码块

public static void quickSortNor(int[] array) {
        int start = 0;
        int end = array.length-1;
        int par = partition(array,start,end);

        Deque<Integer> stack = new LinkedList<>();
        if (par > start+1) {
            stack.push(start);
            stack.push(par-1);
        }
        if (par < end - 1) {
            stack.push(par + 1);
            stack.push(end);
        }
        while (!stack.isEmpty()){
            end = stack.poll();
            start = stack.poll();
            par = partition(array,start,end);
            if (par > start+1) {
                stack.push(start);
                stack.push(par-1);
            }
            if (par < end - 1) {
                stack.push(par + 1);
                stack.push(end);
            }
        }
    }

归并排序`MergeSort`

运用了”分而治之“的思想，采用”分治法“，即是将每个子序列变得有序，再使子序列段有序。若将两个有序表合并成一个有序表，叫二路归并。

‍

归并排序特性总结

归并排序需要开辟新的空间内存来，所以更多考虑的是解决磁盘中的外排序问题
时间复杂度 o（N * log₂N）
空间复杂度 o（N）
稳定性：稳定

代码块

public static void mergeSort(int[] array) {
        mergeSortChild(array,0,array.length-1);
    }
    public static void mergeSortChild(int[] array,int left,int right) {
        //判断结束
        if (left >= right) {
            return;
        }
        int mid = (right + left) / 2;

        mergeSortChild(array,left,mid);
        mergeSortChild(array,mid + 1,right);
        //合并数组
        merge(array,left,mid,right);
    }

    private static void merge(int[] array, int left, int mid, int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;

        int[] tmp = new int[right - left + 1];
        int k = 0;
        while (s1 <= e1 && s2 <= e2) {
            if (array[s1] < array[s2]) {
                tmp[k++] = array[s1++];
            }else {
                tmp[k++] = array[s2++];
            }
        }
        while (s1 <= e1) {
            tmp[k++] = array[s1++];
        }
        while (s2 <= e2){
            tmp[k++] = array[s2++];
        }
        //赋值给数组
        for (int i = 0; i < tmp.length; i++) {
            //i+left 使得右树tmp数组的数值也能正确对应原数组的下标
            array[i + left] = tmp[i];
        }
    }

非递归归并排序`MergeSortNor`✨

代码块

public void mergeSortNor(int[] array) {
        int gap = 1;
        while (gap < array.length) {
            for (int i = 0; i < array.length; i = i + 2*gap) {
                int left = i;
                int mid = i + gap - 1;
                if (mid >= array.length) {
                    mid = array.length-1;
                }
                int right = mid + gap;
                if (right >= array.length) {
                    right = array.length-1;
                }
                merge(array,left,mid,right);
            }
            gap *= 2;
        }
    }

‍

数据结构 - Jul1en

前言

前言

集合框架

Map & Set

Map & Set

#搜索树#

概念

搜索树操作

插入Insert

查找Remove

删除

搜索

模型

Map

TreeMap和HashMap的区别

常用方法

总结

Set

TreeSet和HashSet区别

常见方法

总结

Map和Set的关系

哈希表/散列表

概念

哈希冲突

负载因子

避免哈希冲突

解决哈希冲突

注意要区分清楚：哈希冲突的处理方法和哈希函数

闭散列

💫开散列（重点）

💫与Java类集合的关系

#平均查找长度#

数据结构——排序

数据结构——排序

排序概念

#稳定性#

常见排序

直接插入排序 InsertSort

希尔排序ShellSort——优化直接插入排序 ✨

选择排序SelectSort

堆排序HeapSort

冒泡排序BubbleSort

快速排序QuickSort✨

快速排序三种方法的效率对比

Hoare 版

挖坑版

前后指针法

快排的内部优化

1.三数取中

2.嵌套直接插入排序

非递归快排QuickSortNor

归并排序MergeSort

非递归归并排序MergeSortNor✨

插入`Insert`

查找`Remove`

直接插入排序 `InsertSort`

希尔排序`ShellSort`——优化直接插入排序 ✨

选择排序`SelectSort`

堆排序`HeapSort`

冒泡排序`BubbleSort`

快速排序`QuickSort`✨

非递归快排`QuickSortNor`

归并排序`MergeSort`

非递归归并排序`MergeSortNor`✨