数据结构与算法基础-学习-30-插入排序之直接插入排序、二分插入排序、希尔排序

一、排序概念

将一组杂乱无章的数据按一定规律顺次排列起来。

将无序序列排成一个有序序列（由小到大或由大到小）的运算。

二、排序方法分类

1、按数据存储介质

名称描述
内部排序数据量不大、数据在内存，无需内外交换存交换存储。
外部排序数据量较大、数据在外存（文件排序）外部排序时，要将数据分批调入内存来排序，中间结果还是要及时放入外存，显然外部排序要复杂得多。

2、按比较器个数

名称描述
串行排序单处理机。（同一时刻比较一对元素）
并行排序多处理机。（同一时刻比较多对元素）

3、按主要操作

名称描述
比较排序用比较的方法（插入排序、交换排序、选择排序、归并排序）
基数排序不比较元素的大小，仅仅根据元素本身的取值确定其有序位置。

4、按辅助空间

名称描述
原地排序辅助空间用量为O(1)的排序方法。（所占的辅助存储空间与参加排序的数据量大小无关）
非原地排序辅助空间用量超过O(1)的排序方法。

5、按稳定性

名称描述
稳定排序能够使任何数值相等的元素，排序以后相对次序不变。
非稳定排序不是稳定排序的方法。

6、按自然性

名称描述
自然排序输入数据越有序，排序的速度越快的排序方法。
非自然排序不是自然排序的方法。

三、排序稳定性的意义

排序的稳定性只对结构类型数据排序有意义。

例如说我们只对分数进行排序，相同分数排序后是否更换位置，对于结果是没有影响的。然而我们对于数学分数、语文分数和人名进行综合排序，虽然数学分数相同的两个同学，但语文成绩不同，名次先后也会有某种变化。

排序方法是否稳定，并不能衡量一个排序算法的优劣。

四、插入排序基本思想

每步将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部插入为止。

即便插入边排序，保证子序列中随时都是排好序的。

五、直接插入排序（哨兵）

1、算法思路

Data           : [ 0 ,1 ,2 ,8 ,5 ,4 ,6 ,3 ]

升序为例，1，2，8是排好序的，发现5比8小，将5放到哨兵位，8往后移动一位，哨兵再和2比，比2大，退出此次循环，原有8的位置换成哨兵5。

Data           : [ 5 ,1 ,2 ,5 ,8 ,4 ,6 ,3 ]

现在移动到下一位4，1，2，5，8是排好序的，发现4比8小，将4放到哨兵位，8往后移动一位，哨兵4再和5比发现小，5往后移动一位，哨兵再和2比，比2大，退出此次循环，原有5的位置换成哨兵4。

Data           : [ 4 ,1 ,2 ,4 ,5 ,8 ,6 ,3 ]

现在移动到下一位6，1，2，4，5，8是排好序的，发现6比8小，将6放到哨兵位，8往后移动一位，哨兵再和5比，比5大，退出此次循环，原有8的位置换成哨兵6。

Data           : [ 6 ,1 ,2 ,4 ,5 ,6 ,8 ,3 ]

现在移动到下一位6，1，2，4，5，6，8是排好序的，发现3比8小，将3放到哨兵位，且比4，5，6，8都小，4，5，6，8往后挪动一位，比2大，退出此次循环，原有4的位置换成哨兵3。

Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]

2、源码

（1）DirectInsertSortSentrySqQueue

Status DirectInsertSortSentrySqQueue(SqQueue* Queue)
{JudgeAllNullPointer(Queue);if (Queue->Flag != INT_TYPE_FLAG){return FailFlag;}int*         Array = (int*)(Queue->Data);QueueLenType i;QueueLenType j;for (i = 2; i < Queue->SqQueueLen; i++){if (Array[i] < Array[i - 1])//升序或降序{Array[0] = Array[i];for (j = i - 1; Array[0] < Array[j]; j--){Array[j + 1] = Array[j];//移动元素}Array[j + 1] = Array[0];//插入到元素的后一位。PrintfSqQueue(Queue);}}LogFormat(Debug,"Direct Insert Sort Sentry SqQueue OK.\n");return SuccessFlag;
}

3、Linux环境编译测试

[gbase@czg2 Sort]$ make
gcc -Wall -Wextra -O3 InsertSort.c main.c -o TestSort -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/Log/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/HashTable/include/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/SqQueue/ -I /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/SqStack/ -L /opt/Developer/ComputerLanguageStudy/C/DataStructureTestSrc/PublicFunction/Make/Libs/ -lPublicFunction -lLog -lSqQueue[gbase@czg2 Sort]$ time ./TestSort 
2023-8-29--[ Debug ]--Init SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 0 ,1 ,2 ,8 ,5 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 5 ,1 ,2 ,5 ,8 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 4 ,1 ,2 ,4 ,5 ,8 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 6 ,1 ,2 ,4 ,5 ,6 ,8 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Direct Insert Sort Sentry SqQueue OK.
2023-8-29--[ Info  ]--Sort Function Elapsed Time   : 0 s
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Destroy SqQueue OKreal    0m0.002s
user    0m0.001s
sys     0m0.001s

六、二分插入排序（哨兵）

1、算法思路

升序为例，1，2，8为有序序列，5小于8，5放到哨兵位， 开始进行二分查找，以Low <= High为进行条件。

2023-8-29--[ Debug ]--Low : 1, High : 3, Mid : 2.

Mid：2对应2，2小于5，Low = Mid + 1 = 3，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 3, High : 3, Mid : 3.

Mid：3对应8，5小于8，High = Mid - 1 = 2，不满足Low <= High，退出循环。

将8往后挪动一位。哨兵填写到原有8的位置，变化如下：

Data           : [ 5 ,1 ,2 ,5 ,8 ,4 ,6 ,3 ]

1，2，5，8为有序序列，4小于8，4放到哨兵位， 开始进行二分查找，以Low <= High为进行条件。

2023-8-29--[ Debug ]--Low : 1, High : 4, Mid : 2.

Mid：2对应2，2小于4，Low = Mid + 1 = 3，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 3, High : 4, Mid : 3.

Mid：3对应5，4小于5，High = Mid - 1 = 2，不满足Low <= High，退出循环。

将5，8往后挪动一位。哨兵填写到原有5的位置，变化如下：

Data           : [ 4 ,1 ,2 ,4 ,5 ,8 ,6 ,3 ]

1，2，4，5，8为有序序列，6小于8，6放到哨兵位， 开始进行二分查找，以Low <= High为进行条件。

2023-8-29--[ Debug ]--Low : 1, High : 5, Mid : 3.

Mid：3对应4，4小于6，Low = Mid + 1 = 4，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 4, High : 5, Mid : 4.

Mid：4对应5，5小于6，Low = Mid + 1 = 5，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 5, High : 5, Mid : 5.

Mid：5对应5，6小于8，High = Mid - 1 = 4，不满足Low <= High，退出循环。

将8往后挪动一位。哨兵填写到原有8的位置，变化如下：

Data           : [ 6 ,1 ,2 ,4 ,5 ,6 ,8 ,3 ]

1，2，4，5，6，8为有序序列，3小于8，3放到哨兵位， 开始进行二分查找，以Low <= High为进行条件。

2023-8-29--[ Debug ]--Low : 1, High : 6, Mid : 3.

Mid：3对应4，3小于4，High = Mid - 1 = 2，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 1, High : 2, Mid : 1.

Mid：1对应1，1小于3，Low = Mid + 1 = 2，Low <= High，继续循环。

2023-8-29--[ Debug ]--Low : 2, High : 2, Mid : 2.

Mid：2对应2，2小于3，Low = Mid + 1 = 3，不满足Low <= High，退出循环。

将4，5，6，8往后挪动一位。哨兵填写到原有4的位置，变化如下：

Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]

 2、源码

（1）BinaryInsertSortSentrySqQueue

Status BinaryInsertSortSentrySqQueue(SqQueue* Queue)
{JudgeAllNullPointer(Queue);if (Queue->Flag != INT_TYPE_FLAG){return FailFlag;}int*         Array = (int*)(Queue->Data);QueueLenType i;QueueLenType j;QueueLenType Mid;QueueLenType High;QueueLenType Low;for (i = 2; i < Queue->SqQueueLen; i++){if (Array[i - 1] < Array[i])//如果已经是有序的就不用进行二分查找{continue;}Array[0] = Array[i];//存放哨兵Low      = 1;High     = i - 1;while (Low <= High)//折半查找{Mid = (Low + High) / 2;LogFormat(Debug,"Low : %lld, High : %lld, Mid : %lld.\n",Low,High,Mid);if (Array[0] < Array[Mid]){High = Mid - 1;}else{Low = Mid + 1;}}for (j = i - 1; j >= High + 1; j--)//为什么High + 1，下次看见需推导几次，方便加深记忆。{Array[j + 1] = Array[j];//移动元素PrintfSqQueue(Queue,Debug);}Array[High + 1] = Array[0];//插入元素}LogFormat(Debug,"Binary Insert Sort Sentry SqQueue OK.\n");return SuccessFlag;
}

3、Linux环境编译测试

[gbase@czg2 Sort]$ time ./TestSort 
2023-8-29--[ Debug ]--Init SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 0 ,1 ,2 ,8 ,5 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Low : 1, High : 3, Mid : 2.
2023-8-29--[ Debug ]--Low : 3, High : 3, Mid : 3.
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 5 ,1 ,2 ,8 ,8 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Low : 1, High : 4, Mid : 2.
2023-8-29--[ Debug ]--Low : 3, High : 4, Mid : 3.
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 4 ,1 ,2 ,5 ,8 ,8 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 4 ,1 ,2 ,5 ,5 ,8 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Low : 1, High : 5, Mid : 3.
2023-8-29--[ Debug ]--Low : 4, High : 5, Mid : 4.
2023-8-29--[ Debug ]--Low : 5, High : 5, Mid : 5.
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 6 ,1 ,2 ,4 ,5 ,8 ,8 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Low : 1, High : 6, Mid : 3.
2023-8-29--[ Debug ]--Low : 1, High : 2, Mid : 1.
2023-8-29--[ Debug ]--Low : 2, High : 2, Mid : 2.
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,4 ,5 ,6 ,8 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,4 ,5 ,6 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,4 ,5 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,4 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Binary Insert Sort Sentry SqQueue OK.
2023-8-29--[ Info  ]--Sort Function Elapsed Time   : 0 s
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Destroy SqQueue OKreal    0m0.003s
user    0m0.001s
sys     0m0.002s

七、希尔排序（哨兵）

1、基本思想

先将整个待排记录序列分割成若干个子序列，分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

2、特点

（1）一次移动，移动位置较大，跳跃式地接近排序后的最终位置。

（2）最后一次只需要少量移动。

（3）增量序列必须是递减的，最后一个必须是1。

（4）增量序列应该是互质的。

3、算法效率与增量序列

（1）Hibbard

Dk = 2^k - 1 （相邻元素互质）

猜想情况算法时间复杂度
最坏O(n^(2 / 3))
平均O(n^(5 / 4))

（3）Sedgewick

Dk = 9 * 4^i - 9 * 2^i + 1 或者 4^i - 3 * 2^i + 1

猜想情况算法时间复杂度
最坏O(n^(4 / 3))
平均O(n^(7 / 6))

4、算法思路

这个算法涉及步长，因为插入排序算法，需要两个大步，一个是查找插入位置，二是移动元素。希尔排序在直接插入排序的基础上优化第二大步移动元素，不像之前是一步步移动，而是几步、几十步、几百步的移动。

假设步长分别为3和1，实际算法中肯定不是这么设置的步长，只是举例，方便之后举一反三。

 比较1和5，发现1小于5，不需要进行排序，1号位的1前推3格超过1号位，不需要回推，前进一格。

 比较2和4，发现2小于4，不需要进行排序，2号位的2前推3格超过1号位，不需要回推，前进一格。

 比较8和6，发现8大于6，进行排序，6放到哨兵位，将8挪动到6的位置，再将哨兵的6放到原来8的位置，3号位的6前推3格超过1号位，不需要回推，前进一格。

 继续往后移动， 比较5和3，发现5大于3，进行排序。

 3放到哨兵位，将5挪动到3的位置，再将哨兵的3放到原来5的位置。

 4号位的3比1号位的1大，不需要回推，3的步长排序结束了，现在开始步长为1的排序。

 比较1和2，发现1小于2，不需要进行排序，1号位的1前推1格超过1号位，不需要回推，前进一格。

 比较2和6，发现2小于6，不需要进行排序， 2号位的2比1号位的1大，不需要回推，往后挪动一位。

比较6和3，发现6大于3，进行排序，3放到哨兵位，将6挪动到3的位置，再将哨兵的3放到原来6的位置。

3号位的3比2号位的2大，不需要回推，往后挪动一位。

比较6和4，发现6大于4，进行排序，4放到哨兵位，将6挪动到4的位置，再将哨兵的4放到原来6的位置，4号位的4比3号位的3大，不需要回推，往后挪动一位。

  比较6和8，发现6小于8，不需要进行排序，往后挪动一位。

比较8和5，发现8大于5，进行排序，5放到哨兵位，将8挪动到5的位置，再将哨兵的5放到原来8的位置。

 6号位的5比5号位的6小，需要回推。

5放到哨兵位，将6挪动到5的位置，再将哨兵的5放到原来6的位置。

 5号位的5比4号位的4大，不需要回推，结束排序。

5、源码

（1）ShellSortSentrySqQueue

Status ShellSortSentrySqQueue(SqQueue* SortQueue)
{JudgeAllNullPointer(SortQueue);if (SortQueue->Flag != INT_TYPE_FLAG){return FailFlag;}SqQueue*     InremrntSeqQueue = NULL;StepLenType  StepLen          = 0;QueueLenType i                = 0;QueueLenType j                = 0;QueueLenType x                = 0;int*         Array            = SortQueue->Data;InitSqQueue(&InremrntSeqQueue, INCREMENT_SEQ_MAX_LEN, INT_TYPE_FLAG);//INCREMENT_SEQ_MAX_LEN队列长度需要待商量,这边我先给了一个大致初值。CreateShellSortInremrntSeq(InremrntSeqQueue, SortQueue);for (i = GetSqQueueLen(InremrntSeqQueue) - 1; i >= 0 ; i--){ReadSqQueue(InremrntSeqQueue,i,&StepLen);//从增量序列中读出步长。for (j = StepLen + 1; j < GetSqQueueLen(SortQueue); j++){if (Array[j] < Array[j - StepLen])//当前值比减步长后的值小，说明需要交换位置。{Array[0] = Array[j];//将比较小的值，放入哨兵位。for ( x = j - StepLen; x > 0 && (Array[0] < Array[x]); x = x - StepLen)//j为最大限制，按照步长向左推进。{Array[x + StepLen] = Array[x];}Array[x + StepLen] = Array[0];PrintfSqQueue(SortQueue,Debug);}}}DestroySqQueue(&InremrntSeqQueue);LogFormat(Debug,"Shell Sort Sentry SqQueue OK.\n");return SuccessFlag;
}

（2）MyIntSquare

int MyIntSquare(int Base, int Index)
{int i;int Res = 1;for ( i = 0; i < Index; i++){Res *= Base;}return Res;
}

返回Base的Index次方。

（3）CreateShellSortInremrntSeq

//希尔排序增量序列的最大值为排序队列长度的二分一。（小于）
Status CreateShellSortInremrntSeq(SqQueue* InremrntSeqQueue, SqQueue* SortQueue)
{JudgeAllNullPointer(InremrntSeqQueue);JudgeAllNullPointer(SortQueue);StepLenType i    = 0;StepLenType Val  = 0;StepLenType Tmp  = GetSqQueueLen(SortQueue) / INCREMENT_SEQ_SPLIT_VAL;while (1){Val = 9 * (MyIntSquare(4,i) - MyIntSquare(2,i)) + 1;if (Val > Tmp){break;}EnterSqQueue(InremrntSeqQueue,&Val);i++;}PrintfSqQueue(InremrntSeqQueue,Debug);LogFormat(Debug,"Create Shell Sort Inremrnt Sequence OK.\n");return SuccessFlag;
}

创建希尔排序使用的增量序列，增量序列的算法用的是Sedgewick。

6、Linux环境编译测试

[gbase@czg2 Sort]$ time ./TestSort 
2023-8-29--[ Debug ]--Init SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 0 ,1 ,2 ,8 ,5 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Init SqQueue OK
2023-8-29--[ Debug ]--Enter SqQueue OK
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 1 ]
FrontIndex     : 0
RearIndex      : 1
SqQueueLen     : 1
SqQueueMaxLen  : 20
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Create Shell Sort Inremrnt Sequence OK.
2023-8-29--[ Debug ]--Read  SqQueue OK
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 5 ,1 ,2 ,5 ,8 ,4 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 4 ,1 ,2 ,4 ,5 ,8 ,6 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 6 ,1 ,2 ,4 ,5 ,6 ,8 ,3 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Destroy SqQueue OK
2023-8-29--[ Debug ]--Shell Sort Sentry SqQueue OK.
2023-8-29--[ Info  ]--Sort Function Elapsed Time   : 0 s
2023-8-29--[ Debug ]--SqQueue Data   :
Data           : [ 3 ,1 ,2 ,3 ,4 ,5 ,6 ,8 ]
FrontIndex     : 0
RearIndex      : 0
SqQueueLen     : 8
SqQueueMaxLen  : 8
Flag           : INT_TYPE_FLAG
2023-8-29--[ Debug ]--Destroy SqQueue OKreal    0m0.002s
user    0m0.000s
sys     0m0.002s

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/116945.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【CLIP详读】

【CLIP详读】

个人网站&#xff1a;https://tianfeng.space 一、前言 OpenAI的CLIP项目自从推出以来&#xff0c;CLIP引起了广泛的关注。它的方法看似简单&#xff0c;但效果非常出色&#xff0c;许多结果令人惊叹。例如&#xff0c;预训练模型可以在任何视觉分类数据集上实现出色的效果&a…
阅读更多...
Elasticsearch 集成--Flink 框架集成

Elasticsearch 集成--Flink 框架集成

一、Flink 框架介绍 Apache Spark 是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。 Apache Spark 掀开了内存计算的先河&#xff0c;以内存作为赌注&#xff0c;赢得了内存计算的飞速发展。 但是在其火热的同时&#xff0c;开发人员发现&#xff0c;在 Spark …
阅读更多...
【Linux】DNS系统，ICMP协议，NAPT技术

【Linux】DNS系统，ICMP协议，NAPT技术

遏制自己内心的知识优越感&#xff0c;才能让你发自内心的去尊重他人&#xff0c;避免狂妄自大&#xff0c;才能让你不断的丰富自己的内心。 文章目录 一、DNS系统1.DNS服务器返回域名对应的ip2.使用dig工具分析DNS过程3.浏览器中输入url后发生的事情&#xff1f; 二、ICMP协议…
阅读更多...
重磅OpenAI发布ChatGPT企业版本

重磅OpenAI发布ChatGPT企业版本

8月29日凌晨&#xff0c;Open AI官网发布ChatGPT企业版本&#xff01; 企业版简介&#xff1a; ChatGPT企业版提供企业级安全和隐私、无限的高速 GPT-4 访问、用于处理更长输入的更长上下文窗口、高级数据分析功能、自定义选项等等。人工智能可以协助和提升我们工作生活的各个…
阅读更多...
postgresql-条件表达式

postgresql-条件表达式

postgresql-条件表达式 简单Case表达式搜索Case表达式缩写函数总结 简单Case表达式 select e.first_name , e.last_name , e.department_id , case e.department_id when 90 then 管理when 60 then 开发else 其他end as "部门" from cps.public.employees e ;-- 统…
阅读更多...
第一课：使用C++实现图片去水印

第一课：使用C++实现图片去水印

1.功能概述 实现图片去水印的方法有很多，下面提供一种基于OpenCV库的C++实现方法。主要思路是利用图像中不同水印区域之间的差异，进行区域提取、重构和合成，从而实现去除水印的效果。 2.具体实现 2.1.导入OpenCV库和头文件 #include <iostream> #include <o…
阅读更多...
如何使用C++11原子操作实现自旋锁

如何使用C++11原子操作实现自旋锁

什么是自旋锁&#xff1f; C自旋锁是一种低层次的同步原语&#xff0c;用于保护共享资源的访问。自旋锁是一种轻量级的锁&#xff0c;适用于短时间的资源锁定。 自旋锁的特点&#xff1a;当一个线程尝试获取已经被另一个线程占有的自旋锁时&#xff0c;这个线程会进入一个循环…
阅读更多...
ElasticSearch基础知识汇总

ElasticSearch基础知识汇总

文章目录 前言一、认识ElasticSearch1.正向索引和倒排索引2. MySql与ElasticSearc3.IK分词器 二、ES索引库操作1.mapping映射属性2.索引库的CRUD 三、ES文档库操作 前言 Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎&#xff0c;基…
阅读更多...
2023年单企业云盘最新产品榜单发布

2023年单企业云盘最新产品榜单发布

企业云盘产品为企业提供了高效、安全、可靠的文件存储和共享服务&#xff0c;因此受到了众多企业用户的喜爱。本文参考各个产品测评网站&#xff0c;总结了几款备受好评的企业云盘产品&#xff0c;供您参考。 1, Zoho Workdrive 2, Google Drive 3, OneDrive 4, Dropbox 5…
阅读更多...
SpringBoot 整合 RabbitMQ

SpringBoot 整合 RabbitMQ

1. 创建 SpringBoot 工程 把版本改为 2.7.14 引入这两个依赖: <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId></dependency><dependency><groupId>org.springfr…
阅读更多...
【目标检测】理论篇（3）YOLOv5实现

【目标检测】理论篇（3）YOLOv5实现

Yolov5网络构架实现 import torch import torch.nn as nnclass SiLU(nn.Module):staticmethoddef forward(x):return x * torch.sigmoid(x)def autopad(k, pNone):if p is None:p k // 2 if isinstance(k, int) else [x // 2 for x in k] return pclass Focus(nn.Module):def …
阅读更多...
Qt无边框青绿色主题

Qt无边框青绿色主题

收费产品&#xff0c;学生党、闹眼子党勿扰 收费金额&#xff1a;500元 1 概述 最近因项目需要&#xff0c;写了一个炫酷的青绿色、无边框界面&#xff0c;和3DSMax的界面有点类似。 2 截图 首先看看3DSMax的界面 不知道大家看出来没&#xff0c;这个ui其实很简单&#xff…
阅读更多...
Python 阿里云盾滑块验证

Python 阿里云盾滑块验证

&#xfeff;<table><tr><td bgcolororange>本文仅供学习交流使用&#xff0c;如侵立删&#xff01;</td></tr></table> 记一次阿里云盾滑块验证分析并通过 操作环境 win10 、 macPython3.9selenium、pyautogui 分析 最近在做中国庭审…
阅读更多...
React 生命周期新旧对比

React 生命周期新旧对比

前言 React16.4版本之后使用了新的生命周期&#xff0c;它使用了一些新的生命周期钩子&#xff08;getDerivedStateFromProps、getSnapshotBeforeUpdate&#xff09;&#xff0c;并且即将废弃老版的3个生命周期钩子&#xff08;componentWillMount、componentWillReceiveProps…
阅读更多...
前端进阶之——模块化

前端进阶之——模块化

在做项目的时候越来越发现模块化的重要性&#xff0c;做好模块化开发不仅给后期的维护带来不少好处而且大大提升项目开发效率&#xff0c;接下来整理一下模块化相关知识吧。 模块化开发的优点 封装方法、提高代码的复用性、可维护性和可读性隔离作用域&#xff0c;避免污染全…
阅读更多...
【LeetCode】《LeetCode 101》第十二章：字符串

【LeetCode】《LeetCode 101》第十二章：字符串

文章目录 12.1 字符串比较242 . 有效的字母异位词&#xff08;简单&#xff09;205. 同构字符串&#xff08;简单&#xff09;647. 回文子串&#xff08;中等&#xff09;696 . 计数二进制子串&#xff08;简单&#xff09; 12.2 字符串理解224. 基本计算器&#xff08;困难&am…
阅读更多...
常用Web漏洞扫描工具汇总（持续更新中）

常用Web漏洞扫描工具汇总（持续更新中）

常用Web漏洞扫描工具汇总 常用Web漏洞扫描工具汇总1、AWVS&#xff0c;2、OWASP Zed&#xff08;ZAP&#xff09;&#xff0c;3、Nikto&#xff0c;4、BurpSuite&#xff0c;5、Nessus&#xff0c;6、nmap7、X-ray还有很多不是非常知名&#xff0c;但可能也很大牌、也较常见的。…
阅读更多...
前端基础4——jQuery

前端基础4——jQuery

文章目录 一、基本了解1.1 导入jQuery库1.2 基本语法1.3 选择器 二、操作HTML2.1 隐藏和显示元素2.2 获取与设置内容2.3 获取、设置和删除属性2.4 添加元素2.5 删除元素2.6 设置CSS样式 三、jQuery Ajax3.1 基本语法3.2 回调函数3.3 常用HTTP方法3.4 案例一3.4.1 准备工作3.4.2…
阅读更多...
react学习之路：InputNumber的parser在ts里面报类型错误

react学习之路：InputNumber的parser在ts里面报类型错误

错误提示&#xff1a; Type ‘(value: string | undefined) > string’ is not assignable to type ‘(displayValue: string | undefined) > 0 | 2 | 20’. Type ‘string’ is not assignable to type ‘0 | 2 | 20’. 代码示例&#xff1a; <InputNumbermin{0}m…
阅读更多...
2511. 最多可以摧毁的敌人城堡数目

2511. 最多可以摧毁的敌人城堡数目

文章目录 Tag题目来源题目解读解题思路复杂度分析写在最后 Tag 【数组】 题目来源 2511. 最多可以摧毁的敌人城堡数目 题目解读 在数组 forts 中&#xff0c;forts[i] 有三种数值&#xff1a; -1&#xff1a; 表示第 i 个位置没有城堡&#xff0c;是空地&#xff1b;0&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发