Question

好的，所以我正在C中使用不同的排序方法。最基本的是“气泡排序” 因此，冒泡排序的基本定义是根据要对它们进行排序的方式交换数组中的两个连续框。总共检查了“ n个元素”以交换“ n-1”次，并且编译器最后再次运行该函数以检查排序是否正确完成，因此时间复杂度为O（n ^ 2 ）。

在编写程序时，我认为可以以两种方式完成这种排序。我的问题是：-

是否可以将这两个程序都视为冒泡排序？如果不是，那为什么呢？我认为两种情况下的时间复杂度是相同的。如果我错了，为什么？

#include<stdio.h>
int main()
{
        int n;
        printf("Enter the size of Array: ");
        scanf("%d",&n);
        int a[n];
        int i;
        printf("Enter The Elements Of Array:\n");
        for(i=0;i<n;i++)
        {
                scanf("%d",&a[i]);
        }
        for(i=0;i<n;i++)
        {
                int j;
                for(j=n-1;j>i;j--)
                {
                        if (a[j] < a[j-1])
                        {
                                int temp;
                                temp=a[j];
                                a[j]=a[j-1];
                                a[j-1]=temp;
                        }
                }
        }
        printf("\n\nSorted Array Is:  ");
        for(i=0;i<n;i++)
        {
                printf("%d  ",a[i]);
        }
        printf("\n");
        return 0;
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

#include<stdio.h>
int main()
{
        int n;
        printf("Enter The Size Of Array: ");
        scanf("%d",&n);
        int a[n],i;
        printf("Enter The Elements Of Array:\n");
        for(i=0;i<n;i++)
        {
                scanf("%d",&a[i]);
        }
        int temp;
        for(i=0;i<n-1;i++)
        {
                int j;
                for(j=0;j<n-i-1;j++)
                {
                        if(a[j]>a[j+1])
                        {
                                temp=a[j];
                                a[j]=a[j+1];
                                a[j+1]=temp;
                        }
                }
        }
        printf("Sorted Array Is: ");
        for(i=0;i<n;i++)
        {
                printf("%d  ", a[i]);
        }
        printf("\n");
        return 0;
}

在第一个程序中，交换从末尾开始。更大的数字被一一推到前面。在第二个程序中，交换是从前面进行的。较小的数字被一一逼到最后

Answer 1

是的，乍看之下，除非存在细微的错误，否则它们都是气泡。冒泡的方式并没有什么特别的。大多数实现会从左到右冒泡“向上”，但是没有硬性规定禁止从右到左冒泡“向下”。

作为一般规则，如果问题是“有不止一种方法吗？”，在编程中，答案是“是”。

Answer 2

您拥有的不是气泡排序。气泡排序看起来像这样：

do {
   sorted = true
   sweep through the array, swapping adjacent elements into sorted order
   if we swap any elements, set sorted = false
} while (sorted == false)

真正的冒泡排序没有固定的迭代次数的外部限制，也没有具有随着外部循环的迭代次数增加而执行较少操作的内部循环。是;这些设计方面很愚蠢，但这就是Bubble Sort。

还有一种与冒泡排序相关的更严肃的算法，称为插入排序。插入排序是这样的：

dest_array = []   // start with empty destination array
for each element in source_array
   insert element at appropriate spot in dest_array

插入排序可以在单个数组中实现。最初，整个数组由source_array []组成，dest_array []是source_array []末尾的零长度区域：

[...source_array...][] <- dest array

。我们首先从dest_array []开始的边界处删除source_array []的元素 e 开始排序：

[...source_array...][e][]   <- [e] is removed from source_array

[...source_array...][   ]   <- dest_array acquires an empty spot

[...source-array...][e]     <- [e] is inserted into dest_array, in order

我们一直重复：source_array不断缩小，排序的dest_array不断增长，直到占据整个空间为止。

Insertion Sort的结构类似于您的代码：具有外部循环的三角形迭代，该循环具有与元素数量相对应的固定迭代次数，而内部循环则变得更长（因为dest_array增长得更长）。可以通过一系列相邻元素的交换来将每个元素插入dest_array中的正确位置。

已实现的功能称为“选择排序”。您要反复选择其余source_array分区中的最高（或最低）元素，并将其移至末尾，从而进行构建dest_array分区。您有“选择排序”的两种变体：反复将最高元素移到上部分区，或反复将最低元素移入下部分区。无论哪种方式，上层或下层分区都将接管整个阵列，并使其保持排序状态。

选择排序，插入排序和冒泡排序是不同的算法。冒泡排序是另外两个的笑话。从来没有任何理由实现冒泡排序而不是选择或插入排序。这两个是值得尊重的：它们有其用途，例如在狭小的空间中对少量事物进行分类。（假设您必须在一小部分的引导加载程序机器代码中对一些小的值表进行排序。）

是否可以有多个以上的冒泡程序？

2 个答案: