区块链所需要了解学习的数据结构及排序算法

本篇博客，本准备只是简单提一些概念，但是想着都写这些了，就对数据结构中的某一些篇章进行了详细解释，可以用于数据结构的基本学习了解。

折半查找

分块查找
树表的查找
平衡二叉树的变换

B-树
B树也称B-树,它是一颗多路平衡查找树，一般用字母m表示阶数。当m取2时，就是我们常见的二叉搜索树

x<39
39<x<42
42<x<52
52<x

一颗m阶的B树定义如下：
1）每个节点最多有m-1个关键字。
2）根结点最少可以只有1个关键字。
3）非根结点至少有Math.ceil(m/2)-1个关键字。
4）每个结点中的关键字都按照从小到大的顺序排列，每个关键字的左子树中的所有关键字都小于它，而右子树中的所有关键字都大于它。
5）所有叶子结点都位于同一层，或者说根结点到每个叶子结点的长度都相同。

B树的插入操作：https://zhuanlan.zhihu.com/p/449485738

B+树
规则:
B+跟B树不同B+树的非叶子节点不保存关键字记录的指针，只进行数据索引，这样使得B+树每个非叶子节点所能保存的关键字大大增加
B+树叶子节点保存了父节点的所有关键字记录的指针，所有数据地址必须要到叶子节点才能获取到。所以每次数据查询的次数都一样
B+树叶子节点的关键字从小到大有序排列，左边结尾数据都会保存右边节点开始数据的指针
非叶子节点的子节点数=关键字数（来源百度百科）(Mysql 的B+树）
B+树相比于B树的优点
由于B+树在内部节点上不好含数据信息，因此在内存页中能够存放更多的key。 数据存放的更加紧密，具有更好的空间局部性。因此访问叶子几点上关联的数据也具有更好的缓存命中率；
B+树的叶子结点都是相链的，因此对整棵树的便利只需要一次线性遍历叶子结点即可。而且由于数据顺序排列并且相连，所以便于区间查找和搜索。而B树则需要进行每一层的递归遍历。相邻的元素可能在内存中不相邻，所以缓存命中性没有B+树好。
总结：B+树的I/O次数更少，磁盘读写代价更低，时间更稳定，范围搜索更好

散列表的查找
数据结构之平衡二叉树的平衡调整
1：LL型调整
2：RR型调整
3：LR型调整
4：RL型调整
将导致不平衡的结点称作被破坏者，破坏了结点的平衡的结点成为破坏者，经过调整可以让该树平衡的结点称为调整结点。
1，LL型调整
LL型不平衡调整方法：以调整结点为中心，进行右旋操作，就可以使树平衡。

2，RR型调整
RR型不平衡调整方法：以调整结点为中心，进行左旋操作，就可以使树平衡。
1.

3，LR型调整
LR型不平衡调整方法：以调整结点为中心，进行左旋操作，在进行右旋操作，就可以使树平衡

【0】【】【2】【】【4】【】【】【7】【8】
提取不一样的特征，

34 54 79 68 21 35
【54】【79】【68】【21】【34】【35】

除留取余法
34%6=4
54%6=0
79%6=1
68%6=2
21%6=3
35%6=5
36%6=0

情况三：

4，RL型调整
RL型不平衡调整方法：以调整结点为中心，进行右旋操作，在进行左旋操作，就可以使树平衡

情况2：

总结：
LL型：
以被破坏者的左孩子结点作为调整结点，对其进行右旋。如果调整结点有右子树，将其右子树作为被破坏者的左子树。
LR型：
以被破坏者的左孩子的右孩子结点为调整结点。
如果破坏者为调整结点的左孩子，以调整结点进行左旋，将破坏者作为调整结点的父节点的右子树，后进行右旋，破坏者位置保持不变。
如果破坏者为调整结点的右孩子，以调整结点进行左旋，破坏者位置保持不变。后进行右旋，将破坏者作为被破坏者的左子树。
RR型：
以被破坏者的右孩子结点为调整结点，对其进行左旋。如果调整结点有左子树，将其右子树作为被破坏者的右子树。
RL型：
以被破坏者的右孩子的左孩子结点为调整结点。
如果破坏者为调整结点的左孩子，以调整结点进行右旋，破坏者位置保持不变，后进行左旋，将破坏者作为被破坏者的右子树。
如果破坏者为调整结点的右孩子，以调整结点进行右旋，将破坏者作为调整结点的父节点的左子树。后进行左旋，破坏者位置保持不变。

排序

直接插入排序：基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表，在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动
https://pic3.zhimg.com/v2-fbd84dd20f273fb30d134f31c801d8ca_b.webp
3 5 15 26 36 38 44 47

实例：
下面来说用插入排序对3，1，5，2，4进行排序（从小到大排序）
1 首先选定第一个数3为有序序列，拿着第二个数1往前面那个有序序列中插入值，插入的方法是用要插入的1依次和有序序列的值比较（从有序序列的后面依次往前比较），知道发现一个数比这个要插入的1小或者要插入的数走到了有序序列的头部为止。
2 经比较发现发现1<3，那就把有序序列的3后移一个位置（注意不是1和3这俩数）。这时候走到了头，那就把数字1放到头部。这时候数组元素为1，3，5，2，4
3 继续拿着5去有序序列中比较，发现5>3,那就不用继续比较了，因为3前面的数肯定比3小这时候数组元素为1，3，5，2，4
4 继续拿着2去和有序序列比较，首先发现2<5，那就把5后移一个位置（注意是后移）。再用2和3比较，发现2<3，那就把3后移一个位置，继续用2和1比较，发现1<2。那就找到了放2的位置，把2在1后面就可以了。 只是后数组元素为1，2，3，5，4
5 按照上面的方法，用4去一一比较即可，最后得到的结果就是1，2，3，4，5

希尔排序：

冒泡排序：【交换型】【从小到大】
49,38,65,97,76,13,27
13,27,65,97,76,49,38

void bubble_sort(int* arr, int length)
{
    int i = 0;
    for (i=0; i<length-1; i++)            //遍历n-1次
    {
        int j = 0;
        for (j=0; j<length-1-i; j++)    //相邻两个数据依次进行比较
        {
            if (arr[j] > arr[j+1])        //顺序不对的交换位置
            {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

快速排序：https://zhuanlan.zhihu.com/p/642152546
实现原理：
首先给出一个无序序列[21, 100, 3, 50, 1]，选取一个元素为基准元素，一般选择序列第一个元素21作为枢轴，然后设置两个指针，一个low指针指向左侧第一个位置，一个high指针指向右侧最后一个位置。
首先取出基准元素21，此时low指向的位置留出一个空位。我们规定，指向空的指针不移动。此时应该操作high指针，如果high指针指向的元素大于基准元素21，那么high指针左移；如果high指针指向的元素小于基准元素21，那么将high指针指向的元素放到low指针指向的空位处。显然，当前high指向的1小于21，所以把1放到low指向的位置，此时high指向为空。

简单选择排序：

void arr_sort(int *p,int n)
{
    int i,j;
    int min = 0;
    for(i = 0;i < n - 1;i++)//排序次数
    {
        min = i;
        for(j = i + 1;j < n;j++)
        {
            if(p[j] < p[min])
            {
                min = j;//记录交换的元素下标值
            }
        }
        if(i != min)
        {
            int temp = p[i];
            p[i] = p[min];
            p[min] = temp;
        }  
    }

归并排序：归井排序(Merging Sort)就是将两个或两个以上的有序表合并成一个有序表的过程

基数排序：基数排序法是属于稳定性的排序，基数排序法是效率高的稳定排序法
https://blog.csdn.net/m0_46975599/article/details/112174826