Algorithm 部分插入排序

是否可以使用插入排序原则仅对数组中的第一个

k

元素进行排序

因为当算法在数组上运行时，它将相应地进行排序

因为需要检查所有的元素（找出谁是最小的），它最终会对整个事情进行排序

例如：

原始数组：{5,3,8,1,6,2,8,3,10}

---

k=3

：{1,2,3,5,8,6,8,3,10}的预期输出（仅对前k个元素进行了排序，其余元素未进行排序）

这样的部分排序是可能的，而结果方法看起来像是选择排序的混合-在搜索数组尾部最小元素的部分，和插入排序-在移位元素部分（但不进行比较）。排序保留尾部元素的顺序（尽管没有明确要求）

void ksort（int a[]，int n，int k）
{int i，j，t；
对于（i=0；ii；j--）
a[j]=a[j-1]；
a[i]=t；
} 
}

是的，这是可能的。这将在时间

O（kn）

中运行，其中

n

是数组的大小

你最好使用heapsort。它将在时间

O（n+k log（n））

中运行。heapify步骤是

O（n）

，然后提取的每个元素都是

O（log（n））

技术说明。如果您很聪明，那么可以将堆向后建立到数组的末尾。因此，当你把它看作一棵树时，把

n-2i，n-2i-1

th元素放在

n-i

th元素下面。以您的阵列为例：

{5, 3, 8, 1, 6, 2, 8, 3, 10}

那是一棵这样的树：

 10
     3
         2
             3
             5
         6
     8
         1
         8

当我们重做时，我们得到了这棵树：

 1
     2
         3
             3
             5
         6
     8
         10
         8

也就是说，数组：

{5, 3, 8, 10, 6, 3, 8, 2, 1}

现在，每个元素提取都需要将最后一个元素交换到最终位置，然后让大元素“从树上掉下来”。像这样：

# swap
{1*, 3, 8, 10, 6, 3, 8, 2, 5*}
# the 5 compares with 8, 2 and swaps with the 2:
{1, 3, 8, 10, 6, 3, 8?, 5*, 2*}
# the 5 compares with 3, 6 and swaps with the 3:
{1, 3, 8, 10, 6?, 5*, 8, 3*, 2}
# The 5 compares with the 3 and swaps, note that 1 is now outside of the tree:
{1, 5*, 8, 10, 6, 3*, 8, 3, 2}

在数组树表示中，以下哪一项是：

{1}
2
    3
        3
             5
        6
    8
       10
        8

重复一遍，我们得到：

# Swap
{1, 2, 8, 10, 6, 3, 8, 3, 5}
# Fall
{1, 2, 8, 10, 6, 5, 8, 3, 3}

又名：

再说一遍：

# swap
{1, 2, 3, 10, 6, 5, 8, 3, 8}
# fall
{1, 2, 3, 10, 6, 8, 8, 5, 3}

或

---

以此类推。

为了防止将来有人需要，我提出了一个“纯粹”的解决方案，即不是原始插入排序和其他排序算法的混合

void partialInsertionSort(int A[], int n, int k){
    int i, j, aux, start;
    int count = 0;
    for(i = 1; i < n; i++){
        aux = A[i];

        if (i > k-1){
            start = k - 1;
            //This next part is needed only to maintain
            //the original element order
            if(A[i] < A[k])
                A[i] = A[k];
        }
        else start = i - 1;

        for(j = start; j >= 0 && A[j] > aux; j--)
                A[j+1] = A[j];

        A[j+1] = aux;
    }
}

void partialInsertionSort（int A[]，int n，int k）{
int i、j、aux、start；
整数计数=0；
对于（i=1；ik-1）{
开始=k-1；
//下一部分仅用于维护
//原始元素顺序
if（A[i]=0&&A[j]>aux；j--）
A[j+1]=A[j]；
A[j+1]=aux；
}
}

基本上，该算法对前k个元素进行排序。然后，第k个元素就像一个轴：只有当剩余的数组元素小于这个轴时，它才会像原始算法一样插入到排序后的k个元素之间的正确位置

void partialInsertionSort(int A[], int n, int k){
    int i, j, aux, start;
    int count = 0;
    for(i = 1; i < n; i++){
        aux = A[i];

        if (i > k-1){
            start = k - 1;
            //This next part is needed only to maintain
            //the original element order
            if(A[i] < A[k])
                A[i] = A[k];
        }
        else start = i - 1;

        for(j = start; j >= 0 && A[j] > aux; j--)
                A[j+1] = A[j];

        A[j+1] = aux;
    }
}

最佳情况：阵列已订购

考虑到比较是基本操作，则比较次数为

2n-k-1

→ Θ（n）

最坏情况：阵列顺序相反

考虑到比较是基本操作，那么比较的数量是

（2kn-k²-3k+2n）/2

→ Θ（千牛）

---

（两者都考虑了为保持数组顺序而进行的比较）

是的，可以仅对数组的第一部分进行排序，使主循环运行k次。但也许你会谈论其他的事情？是的，这可以解释我的问题，但事实并非如此！我添加了一个例子来说明我想要的。我想你的例子中有一个打字错误？不应该有第二个

2

，没有？更正，谢谢。对于我的这个特殊任务，我被要求使用插入排序，但感谢您展示它如何与heapsort一起工作！

{1, 2, 3}
3
    5
        8
        6
    8
       10

void partialInsertionSort(int A[], int n, int k){
    int i, j, aux, start;
    int count = 0;
    for(i = 1; i < n; i++){
        aux = A[i];

        if (i > k-1){
            start = k - 1;
            //This next part is needed only to maintain
            //the original element order
            if(A[i] < A[k])
                A[i] = A[k];
        }
        else start = i - 1;

        for(j = start; j >= 0 && A[j] > aux; j--)
                A[j+1] = A[j];

        A[j+1] = aux;
    }
}