数据结构与算法15——冒泡排序_数据结构实验15 改进的冒泡排序

排序的基本概念与分类

通过例子消化概念：

• 在排序问题中，通常将数据元素称为记录。
  ——显然我们输入的是一个记录集合，排序后输出的也是一个记录集合。
  ——所以我们可以将排序看成是线性表的一种操作。

• 排序的依据是关键字之间的大小关系，那么对同一记录集合，针对不同的关键字进行排序，可以得到不同序列。

排序的稳定性

影响排序算法性能的几个要素

• 时间性能
• 辅助空间
• 算法的复杂度

一般思想：

#include <stdio.h>

void bubblesort( int K[], int n )
{
    int i, j, temp;

    for( i=0; i<n-1; i++ )
    {
        for( j=i+1; j<n; j++ )
        {
            if( K[i]>K[j] )
            {
                temp = K[j];
                K[j] = K[i];
                K[i] = temp;
            }
        }
    }
}

int main()
{
    int i,a[10]={5,2,1,3,4,6,7,7,8,9};

    bubblesort(a,10);

    printf("排序后的结果是：");
    for( i=0; i<10; i++ )
    {
        printf("%d",a[i]);
    }

    printf("\n");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

在下标为0时，下标0的元素和剩下的元素比较大小
在下标为1时，下标1的元素和剩下的元素比较大小
以此类推…

冒泡排序的要点：

1. 两两 注意是相邻的两个元素的意思；
2. 如果有n个元素需要比较n-1次，每轮减少1次比较；
3. 既然叫冒泡排序，那就是从下往上两两比较，所以看上去就跟跑跑往上冒一样。

真正的冒泡排序代码如下：

#include <stdio.h>

void bubblesort( int K[], int n )
{
    int i, j, temp, count1=0, count2=0, flag;

    flag = 1;
    for( i=0; i<n-1 && flag; i++ )
    {
        for( j=n-1; j>i; j-- )
        {
            count1++;
            if( K[j-1]>K[j] )
            {
                count2++;
                temp = K[j-1];
                K[j-1] = K[j];
                K[j] = temp;
                flag = 1;
            }
            else
                flag = 0;
        }
    }
    printf("总共进行了%d次比较，进行了%d次移动！",count1,count2);
}

int main()
{
    int i,a[10]={1,0,2,3,4,5,6,7,8,9};

    bubblesort(a,10);

    printf("排序后的结果是：");
    for( i=0; i<10; i++ )
    {
        printf("%d",a[i]);
    }

    printf("\n");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

像这种特殊的情况，第一次循环是在10个元素里面两两比较，刚好在第9次比较中，要移动位置，所以flag赋值为1；进行第二次循环比较，第二次循环比较是在9个元素里面比较，在9个元素比较完之后呢，没有发生位置交换，说明顺序是正确的，所以flag=0，可以直接退出大循环了。也就是说总共比较了9+8=17次。

加入flag之后呢，可以大大减小比较的时间，因为两两比较之后，如果两个元素没有交换位置说明他们的顺序是正确的。