Question

我有一个大小恒定的数组（现实生活中大小= 20），允许重复例如：

1 2 2 3 3 4 5 6 7 8 9

现在只有一个元素更新：

1 5 2 3 3 4 5 6 7 8 9

我需要求助这个数组。我应该只使用bubblesort吗？

更新我不知道如何打电话给我写的内容。但我认为不可能更快地排序。欢迎提出意见！

    // array is already almost sorted and INCREASING, element at pos need to be inserted to the right place
    private void SortQuotes(List<Quote> quoteList, int pos)
    {
        var quoteToMove = quoteList[pos];
        if (pos == 0 || quoteList[pos - 1].Price < quoteToMove.Price)
        {
            MoveElementsDown(quoteList, pos);
        } else if (pos == quoteList.Count - 1 || quoteList[pos + 1].Price > quoteToMove.Price)
        {
            MoveElementsUp(quoteList, pos);
        }
    }

    private void MoveElementsDown(List<Quote> quoteList, int pos)
    {
        var quoteToInsert = quoteList[pos];
        var price = quoteToInsert.Price;
        for (int i = pos - 1; i >= 0; i--)
        {
            var nextQuote = quoteList[i];
            if (nextQuote.Price > price)
            {
                quoteList[i + 1] = quoteList[i];
                if (i == 0)   // last element
                {
                    quoteList[i] = quoteToInsert;
                }
            }
            else
            {
                quoteList[i + 1] = quoteToInsert;
                break;
            }
        }
    }

    private void MoveElementsUp(List<Quote> quoteList, int pos)
    {
        var quoteToInsert = quoteList[pos];
        var price = quoteToInsert.Price;
        for (int i = pos + 1; i < quoteList.Count; i++)
        {
            var nextQuote = quoteList[i];
            if (nextQuote.Price < price)
            {
                quoteList[i - 1] = quoteList[i];
                if (i == quoteList.Count - 1)   // last element
                {
                    quoteList[i] = quoteToInsert;
                }
            }
            else
            {
                quoteList[i - 1] = quoteToInsert;
                break;
            }
        }
    }

更新我确实知道哪个元素是奇数，即它的位置是已知的！

Answer 1

此解决方案将每个元素移位一，直到找到奇数元素的右侧位置。由于它已在第一步中被覆盖，因此将其保存在临时变量“h”中，然后写入最终位置。它需要最少的比较和转移操作：

 static void MoveOddElementToRightPosition(int[] a, int oddPosition)
 {
   int h = a[oddPosition];
   int i;
   if (h > a[oddPosition + 1])
     for (i = oddPosition; i < a.Count()-1 && a[i+1] <= h; i++)
        a[i] = a[i+1];
   else
     for (i = oddPosition; i > 0 && a[i-1] >= h; i--)
        a[i] = a[i - 1];
   a[i] = h;
 }

Answer 2

如果最后一个元素需要到达前面，Bubblesort将使用n ^ 2次。使用插入排序。

Answer 3

由于数组很小，插入排序对于小数组大约需要约O（n）时间，如果您只是更新1个值，插入排序应该以最佳方式实现您的目的。

Answer 4

It can be done in O(n)。如果您不知道该元素，那么在O（n）中搜索元素，然后您只需要比较和交换每个元素，这将需要O（n）。总共2n表示O（n）。如果你知道已被修改的元素，那么比较并交换每个元素。

Answer 5

您无需再次对其进行排序。

只有一个元素发生变化。因此，您只需要浏览列表并将更改后的号码放到适当的位置。 这将是O（n）复杂性。

int a[] = {1, 5, 2, 3, 3, 4, 5, 6, 7, 8, 9};
int count = 0;

//find the odd element
for(int jj=1; jj< a.length; jj++){
    if(a[jj] < a[count])
        break;
    else count++;
}
System.out.println(" Odd position "  + count);

//put odd element to proper position
for(int k= count+1; k<a.length; k++){
    if(a[count] > a[k]){
        int t = a[count];
        a[count] = a[k];
        a[k] = t;
        count++;
    }
}

以上是针对给定输入测试的工作代码。享受。

Answer 6

如果您对快速替换元素感兴趣，那么您还可以使用删除和插入速度快的结构，例如Java中的TreeSet。这在理论上意味着O（log（n）），但是如果你只是操纵20个元素的数组就可能不值得了
如果所有不同元素的集合都是有限的，就像在你的例子中你只使用1到9的数字一样，那么在O（1）中有一个解决方案。您只需保留一个包含元素出现次数的数组，而不是排序列表。
如果您仍想将所有内容保存在数组中，那么最快的方法就是这样
1. 在O（log（n））中通过二分法找到要删除的元素的位置A.
2. 以相同的方式找到新元素最终结束位置B.更确切地说，B是new_element＆lt;每个k> a [k]乙
3. 如果A＆lt; B，将A + 1和B之间的所有元素移动到它们的左边，然后将新元素设置到位置B.如果B> A，你做同样的事情，但在右边。现在这一步是在O（n）中，但是没有逻辑，它只是移动内存。在C中你会使用memmove并且它已经过大量优化，但我不知道任何Java等价物。

Answer 7

在这种情况下，Bubblesort非常好，最多只有20个比较

但是使用二分搜索找到新位置是O（log（n）），在这种情况下是5比较有点快，如果你需要最后一位奇数速度使用二进制搜索，否则你可以坚持使用冒泡排序。

Answer 8

这是普通C中的一个天真实现。测试后删除fprintf(stderr, ...。只要可以进行比较功能，ITEM就可以是任何东西。否则：使用指向ITEM的指针，（并且可能添加额外的sizeofelem参数，ala qsort）

#include <stdio.h>
#include <string.h>

typedef int ITEM;

int item_cmp(ITEM one, ITEM two);
unsigned one_bubble( ITEM *arr, unsigned cnt, unsigned hot , int (*cmp)(ITEM,ITEM) );

int item_cmp(ITEM one, ITEM two)
{
fprintf(stderr,"Cmp= %u to %u: %d\n", one, two, one-two);
if (one > two) return 1;
else if (one < two) return -1;
else return 0;
}

unsigned one_bubble( ITEM *arr, unsigned cnt, unsigned hot , int (*cmp)(ITEM,ITEM) )
{
unsigned goal = cnt;
int diff;
ITEM temp;

        /* hot element should move to the left */
if (hot > 0 && (diff=cmp( arr[hot-1], arr[hot])) > 0) {
        /* Find place to insert (this could be a binary search) */
        for (goal= hot; goal-- > 0; ) {
                diff=cmp( arr[goal], arr[hot]);
                if (diff <= 0) break;
                }
        goal++;
        fprintf(stderr,"Move %u LEFT to %u\n", hot, goal);
        if (goal==hot) return hot;
        temp = arr[hot];
                /* shift right */
        fprintf(stderr,"memmove(%u,%u,%u)\n", goal+1, goal, (hot-goal) );
        memmove(arr+goal+1, arr+goal, (hot-goal) *sizeof temp);
        arr[goal] = temp;
        return goal; /* new position */
        }
        /* hot element should move to the right */
else if (hot < cnt-1 && (diff=cmp( arr[hot], arr[hot+1])) > 0) {
        /* Find place to insert (this could be a binary search) */
        for (goal= hot+1; goal < cnt; goal++ ) {
                diff=cmp( arr[hot], arr[goal]);
                if (diff <= 0) break;
                }
        goal--;
        fprintf(stderr,"Move %u RIGHT to %u\n", hot, goal);
        if (goal==hot) return hot;
        temp = arr[hot];
                /* shift left */
        fprintf(stderr,"memmove(%u,%u,%u)\n", hot, hot+1, (goal-hot) );
        memmove(arr+hot, arr+hot+1, (goal-hot) *sizeof temp);
        arr[goal] = temp;
        return goal; /* new position */
        }
fprintf(stderr,"Diff=%d Move %u Not to %u\n", diff, hot, goal);
return hot;
}

ITEM array[10] = { 1,10,2,3,4,5,6,7,8,9,};
#define HOT_POS 1
int main(void)
{
unsigned idx;

idx = one_bubble(array, 10, HOT_POS, item_cmp);

printf("%u-> %u\n", HOT_POS, idx );

for (idx = 0; idx < 10; idx++) {
        printf("%u: %u\n", idx, array[idx] );
        }

return 0;
}

如何重新排序已排序的数组，其中一个元素更新

8 个答案: