冒泡法，熟悉熟悉

来源：互联网发布：原装ubuntu的电脑编辑：程序博客网时间：2024/05/22 07:42

[cpp] view plain copy
1）“冒泡法”   
冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,  
若a[0]>a[i]，则交换它们，一直比较到a[n]。  
同理对a[1],a[2],...a[n-1]处理，即完成排序。   
  
void bubble(int *a,int n)   /*定义两个参数：数组首地址与数组大小*/   
{   
    int i,j,temp;   
    for(i=0;i<n-1;i++)   
        for(j=i+1;j<n;j++)           /*注意循环的上下限*/   
            if(a[i]>a[j])   
                {   
                    temp=a[i];   
                    a[i]=a[j];   
                    a[j]=temp;   
                }  
}   
  
冒泡法原理简单，但其缺点是交换次数多，效率低。   
  
下面介绍一种源自冒泡法但更有效率的方法“选择法”。  
   
（2）“选择法”   
选择法循环过程与冒泡法一致，它还定义了记号k=i  
然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.  
最后看看k=i是否还成立，不成立则交换a[k],a[i]  
这样就比冒泡法省下许多无用的交换，提高了效率。   
  
void choise(int *a,int n)   
{   
    int i,j,min,temp;   
    for(i=0;i<n-1;i++)   
    {   
        min=i;                                              /*给记号赋值*/   
        for(j=i+1;j<n;j++)   
        {  
            if(a[min]>a[j])   
                min=j;                                      /*是k总是指向最小元素*/   
        }  
        if(i!=min)   
        {                                                       /*当k!=i是才交换，否则a[i]即为最小*/   
                temp=a[i];   
                a[i]=a[min];   
                a[min]=temp;   
        }   
    }   
}   
选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。   
  
（3）“快速法”   
快速法定义了三个参数,（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j).  
它首先选一个数组元素（一般为a[ (i+j)/2 ],即中间元素）作为参照,把比它小的元素放到它的左边，比它大的放在右边。  
然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。  
下面分析其代码：   
  
void quick(int *a,int i,int j)   
{   
    int m,n,temp;   
    int k;   
    m=i;   
    n=j;   
    k=a[(i+j)/2]; /*选取的参照*/   
    do   
    {   
        while(  a[m]<k && m<j  )   
            m++;                                            /* 从左到右找比k大的元素*/   
              
        while( a[n] >k && n>i )   
          n--;                                          /* 从右到左找比k小的元素*/   
          
        if(m<=n)   
        {                                                   /*若找到且满足条件，则交换*/   
                temp=a[m];  
                a[m]=a[n];  
                a[n]=temp;  
                m++;  
                n--;  
        }  
    }  
    while(m<=n);   
          
    if(m<j)   
        quick(a,m,j);                           /*运用递归*/   
          
    if(n>i)   
        quick(a,i,n);   
}   
  
（4）“插入法”   
插入法是一种比较直观的排序方法。  
它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。  
把数组元素插完也就完成了排序。   
  
void insert(int *a,int n)   
{   
    int i,j,temp;   
    for(i=1;i<n;i++)   
    {   
        temp=a[i];                          /*temp为要插入的元素*/   
        j=i-1;   
          
        while( j>=0&&temp<a[j] )   
        {                                           /*从a[i-1]开始找比a[i]小的数，同时把数组元素向后移*/   
            a[j+1]=a[j];   
            j--;   
        }   
        a[j+1]=temp; /*插入*/   
    }   
}   
  
（5）“shell法”   
shell法是一个叫 shell 的美国人与1969年发明的。  
它首先把相距k(k>=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。  
下面让我们来分析其代码：   
  
void shell(int *a,int n)   
{   
    int i,j,k,x;   
    k=n/2;                                          /*间距值*/   
    while(k>=1)   
    {   
        for(i=k;i<n;i++)   
        {   
            x=a[i];   
            j=i-k;   
            while(j>=0&&x<a[j])   
            {   
                a[j+k]=a[j];   
                j-=k;   
            }   
                a[j+k]=x;   
        }   
        k/=2;                                       /*缩小间距值*/   
    }   
}   

http://814193594.blog.51cto.com/10729329/1715944

冒泡排序（bubble sort）算法的运作如下：从前往后一次比较相邻的两个元素，如果第二个比第一个元素小，则交换这两个元素，一直到与最后一个元素比较完成，这样最大的元素就放到了最后；这样重复比较（n-1）次即可完成排序。

------------------------------------------------------------------------------------------------------

快速排序（quicksort）算法（冒泡排序的一种优化）：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

设置标志位（sign）（冒泡排序的另一种优化方法）每一趟比较完成后，看元素是否进行交换，如果有，则继续下一次循环，如果没有则结束循环。

“设置标志位”这种方法没有“快速排序算法”效率高。

------------------------------------------------------------------------------------------------------

C语言代码如下：

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/*
** bubble sort
*/ 
void bubble_sort(int *str, int size)
{
     int i = 0, j = 0;
     int tmp = 0;
      
     /*
     ** 进行size-1趟排序；
     */
     for (i = 0; i < size - 1; i++)
     {
         /*
         ** 每排序一趟，将最大的元素沉底。下一趟少比较i次；
         */
 
          for (j = 0; j < size - 1 - i; j++)       
          {
               if (str[j] > str[j + 1])
               {
                    tmp = str[j];
                    str[j] = str[j + 1];
                    str[j + 1] = tmp;
               }
          }
 
     }
}
 
/*
** 优化一：设置一个标志位sign的bubble sort；
*/
 void bubble_sort(int *str, int size)
{
     int i = 0, j = 0;
     int tmp = 0, sign = 0;
      
     for (i = 0; i < size - 1; i++)
     {
          /*
          ** 每趟排序前将sign置为0，如果相邻元素进行了交换则sign>1;
          ** 否则，sign==0，没有进行交换，排序完成，跳出循环；
          */
          flag = 0;
          for (j = 0; j < size - 1 - i; j++)
          {
               if (str[j] > str[j + 1])
               {
                    tmp = str[j];
                    str[j] = str[j + 1];
                    str[j + 1] = tmp;
                    sign++;
               }
          }
          if (0 == sign)
          break;
     }
}
 
 
/*
** 优化二：quick sort；
*/
void quicksort(int *str, int left, int right)
{
     assert(str);
      
     /*
     **如果左边大于或等于右边，则该数组已经排序完成；
     */
     if (left >= right)
     {
          return;
     }
      
     int i = left;
     int j = right;
     int key = str[left];
      
     /*
     **当i=j时，一趟排序完成，将所有数分为一大一小两组；
     */
     while (i < j)
     {
          /*
          **第一次从后向前遍历，遇到第一个比key小的交换两数位置；
          */
          while ((i < j) && (key <= str[j]))
          {
               j--;
          }
          str[i] = str[j];
           
          /*
          **第二次从前向后遍历，遇到第一个比key大的交换两数位置；
          */
          while ((i < j) && (key >= str[i]))
          {
               i++;
          }
          str[j] = str[i];
     }
      
     str[i] = key;
     /*
     **递归调用，完成左、右子序列的排序；
     */
     quicksort(str, left, i - 1);
     quicksort(str, i + 1, right);
}

阅读全文

0 0