考研数据结构编程 ch08 排序 —— 折半插入排序

折半插入排序

---

一、算法思想（按递增排序）

• 1、从 第2个元素a[2] 开始遍历；a[0]充当哨兵，负责在每轮循环中存储a[i]。

void BinaryInsertSort(int arrList[], int n)
{
    int i, j, low, high, mid;
    // ! 第i轮循环的时候，a[1]~a[i-1]都排序好了
    for (int i = 2; i <= n; i++) // ! 依次将a[2]~a[n]插入到已排序好的序列(a[1]~a[i-1])中
    {
		……
	}
    ……
}

 

• 2、配合折半查找到 不比a[i]大 的区间(a[1], a[high]) ，也就是 a[i] >= (a[i],a[high])
• 3、当a[mid]等于a[0]时，为了保证算法的稳定性，mid继续在所指位置右边寻找位置

// ! 折半插入排序
void BinaryInsertSort(int arrList[], int n)
{
    int i, j, low, high, mid;
    // ! 第i轮循环的时候，a[1]~a[i-1]都排序好了
    for (int i = 2; i <= n; i++) // ! 依次将a[2]~a[n]插入到已排序好的序列(a[1]~a[i-1])中
    {
        arrList[0] = arrList[i]; // ! 此处a[0]空着，充当哨兵
        low = 1;
        high = i - 1; // ! 折半查找的范围(1,i-1)，就是已经排好序的a[1]~a[i-1]
        
        // ? 目标: 折半查找寻找适合a[i]插入的位置
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (arrList[mid] > arrList[0])
            {
                high = mid - 1;
            }
            else // ! 此时arrList[mid] <= arrList[0]
            {
                // ! 当a[mid]==a[0]时，为了保证算法的稳定，mid继续在所指位置右边寻找位置
                low = mid + 1;
            }
        }
        ……
    }
}

 

• 3、元素后移+插入元素，注意区间和位置

// ! 折半插入排序
void BinaryInsertSort(int arrList[], int n)
{
    int i, j, low, high, mid;
    // ! 第i轮循环的时候，a[1]~a[i-1]都排序好了
    for (int i = 2; i <= n; i++) // ! 依次将a[2]~a[n]插入到已排序好的序列(a[1]~a[i-1])中
    {
        arrList[0] = arrList[i]; // ! 此处a[0]空着，充当哨兵
        low = 1;
        high = i - 1; // ! 折半查找的范围(1,i-1)，就是已经排好序的a[1]~a[i-1]
        // ? 目标: 折半查找寻找适合a[i]插入的位置
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (arrList[mid] > arrList[0])
            {
                high = mid - 1;
            }
            else // ! 此时arrList[mid] <= arrList[0]
            {
                // ! 当a[mid]==a[0]时，为了保证算法的稳定，mid继续在所指位置右边寻找位置
                low = mid + 1;
            }
        }
        // ! 元素后移
        for (j = i - 1; j >= high + 1; --j)
        {
            arrList[j + 1] = arrList[j];
        }
        arrList[high + 1] = arrList[0];
        // ! 从插入位置的结果可以看出来，折半插入排序的思想:
        // ! 找到不比a[i]大的区间(a[1], a[high]) --> a[i] >= (a[i],a[high])
        // ! 先把a[high+1]~a[i-1]的元素后移，与a[high+2]~a[i]一一对应
        // ! 再把a[hight+1] = a[0];
    }
}

 

二、具体测试代码

#include <iostream>

using namespace std;

// ! 折半插入排序
void BinaryInsertSort(int arrList[], int n)
{
    int i, j, low, high, mid;
    // ! 第i轮循环的时候，a[1]~a[i-1]都排序好了
    for (int i = 2; i <= n; i++) // ! 依次将a[2]~a[n]插入到已排序好的序列(a[1]~a[i-1])中
    {
        arrList[0] = arrList[i]; // ! 此处a[0]空着，充当哨兵
        low = 1;
        high = i - 1; // ! 折半查找的范围(1,i-1)，就是已经排好序的a[1]~a[i-1]
        // ? 目标: 折半查找寻找适合a[i]插入的位置
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (arrList[mid] > arrList[0])
            {
                high = mid - 1;
            }
            else // ! 此时arrList[mid] <= arrList[0]
            {
                // ! 当a[mid]==a[0]时，为了保证算法的稳定，mid继续在所指位置右边寻找位置
                low = mid + 1;
            }
        }
        // ! 元素后移
        for (j = i - 1; j >= high + 1; --j)
        {
            arrList[j + 1] = arrList[j];
        }
        arrList[high + 1] = arrList[0];
        // ! 从插入位置的结果可以看出来，折半插入排序的思想:
        // ! 找到不比a[i]大的区间(a[1], a[high]) --> a[i] >= (a[i],a[high])
        // ! 先把a[high+1]~a[i-1]的元素后移，与a[high+2]~a[i]一一对应
        // ! 再把a[hight+1] = a[0];
    }
}

int main()
{
    int a[] = {0, 38, 49, 65, 97, 76, 13, 27, 49};
    BinaryInsertSort(a, 8);
    cout << "数组的元素个数: " << sizeof(a) / 4 << endl;
    for (int i = 1; i <= 8; i++)
    {
        cout << "a[" << i << "]: " << a[i] << "  ";
    }
    return 0;
}