冒泡法一般做交换的次数比选择要多，但冒泡法一旦发现某些比较没有做任何一次交换的话，就可以确定排序完成而立即中止。因此冒泡法在处理“大致有序”的数据排序中有优势。

冒泡  

  void   sort(int   arr[],int   n)  

  {  

          int   i,j,temp;  

          for(i=0;   i<n-1;   i++)                            

          {  

                  for(j=0;   j<n-i-1;   j++)            

                  {  

                          if(arr[j]>arr[j+1])            

                          {  

                                  temp=arr[j];  

                                  arr[j]=arr[j+1];  

                                  arr[j+1]=temp;  

                          }  

                  }  

          }  

  }  

  选择  

  void   sort(int   arr[],int   n)  

  {  

          int   i,j,temp;  

          for(i=0;   i<n-1;   i++)  

          {  

                  for(j=i+1;   j<n;   j++)  

                  {  

                          if   (arr[i]>arr[j])                

                          {                                                  

                                  temp=arr[i];  

                                  arr[i]=arr[j];  

                                  arr[j]=temp;  

                          }  

                  }  

          }  

  }   

 

 

 

//----数学中有乘法口诀。。那只是工具。我们都很熟悉。

//----C++中有一些基本的程序。也只是工具。我们必须像熟悉乘法口诀一样去熟悉这些程序。

//----很基础的一些东西，必须熟练。。。

|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

================自己慢慢体会吧。。。。累了。不想解释了。。。。。。。

 

void bubblesort(int a[],int n)   //---  一维数组做参数
{
 int t;
 for(int j=0;j<9;j++)

          //     为什么叫气泡法呢。这个算法是比较相邻两个数，让小的那个数上升。大的下降。就              

          //        类似于冒泡泡了。。。重复这样的操作时，会将最大的那个数下沉的最下面。。。
  for(int i=0;i<9-j;i++) 
   if(a[i]>a[i+1])       //------找出最大的数，让他下沉。。。。。。。。。。。
   {
    t=a[i];
    a[i]=a[i+1];
    a[i+1]=t;
   }
}

========================================================================================================================================

void select_sort(int array[],int n)    // -----选择法。找出最小的数，放在第一位。。依次找下去。。。
{
 int i,j,k,t;
 for(i=0;i<n-1;i++)           //-----而且，这里用的是数组作为参数。。要理解这其中的语法。。。
 {
  k=i;
  for(j=i+1;j<n;j++)
   if(array[j]<array[k])       //------找出最小的数，将它赋给第一位。。。。一次找下去。。。
    k=j;
   t=array[k];
   array[k]=array[i];
   array[i]=t;
 }
}

 

====================================================================================================

学好C语言的数组,选择法和冒泡法是必须要了解了.

现在我们来比较一下.

例如,题目为:对10个数进行排序,由从小到大的顺序.

1:选择法

所谓的选择法就是先将10个数中最小的数与a[0]对换;再将a[1]到a[9]中的最小数与a[1]对换,依次类推,每比较一次,就找出一个没有经过排序的数中最小的一个.所以一共比较9轮.

例如用4个数排序,第一次比较就是把4个数中的最小的数与a[0]对换,

                第二次:把余下的3个数中最小的数与除了a[0]的最小的数与a[1]对换.

以此类推.

根据此思路,编写程序如下:

#include<stdio.h>

void main()

{void s(int arr[],int n)

int a[10],i;

printf("enter the array\n");

for(i=0;i<10;i++)

  scanf("%d",&a[i]);

s(a,10);

printf("the sorted array:\n");

for(i=0;i<10;i++)

   printf("]",a[i]);

printf("\n");

}

void s(int arr[],int n)

{int i,j,k,t;

for(i=0;i<n-1;i++)

  { k=i;

    for(j=i+1;j<n;j++)

     if(arr[j]<arr[k])

        k=j;

     t=arr[k];arr[k]=arr[i],arr[i]=t;

   }

}

2:冒泡法

冒泡法也称为起泡法,原理就是相邻的两个数比较,将小的调到前头,若是从大到小,则是将大的调到前头.

分为外循环和内循坏.

根据此思路,编写程序如下:

#include<stdio.h>

void main()

{int a[10];

 int i,j,t;

printf("enter the array\n");

for(i=0;i<10;i++)

  scanf("%d",&a[i]);

printf("\n");

for(i=0;i<9;i++)

  for(j=0;j<9-i;j++)

  if(a[j]>a[j+1])

   {t=a[j];a[j]=a[j+1],a[j]=t; }

printf("the sorted array:\n");

for(i=0;i<10;i++)

   printf("]",a[i]);

printf("\n");

}

重要的就是红色那两名,其余的输入与输出都是公共的.希望对大家有帮助.

三种排序对比：选择法，插入法，冒泡法

三种排序对比：选择法，插入法，冒泡法

三种排序都是最基本的，时间复杂度最大为O(n*n)的排序方法。这里给出的是采用数组形式的简单序列排序（从小到大）。

＃i nclude<stdio.h>
int main()
{
int a[10]={4,6,8,2,0,1,5,7,3,9};
int i,j,k;
for(j=0;j<9;j++)
for(i=j+1;i<9;i++)
if(a[i]<a[j]){
k=a[i];
a[i]=a[j];;
a[j]=k;
}

for(j=0;j<=9;j++)printf("%d\n",a[j]);
system("pause");
}

＃i nclude<stdio.h>
int main()
{
int a[10]={4,6,8,2,0,1,5,7,3,9};
int i,j,k;
for(j=0;j<9;j++)
for(i=0;i<9-j;i++)
if(a[i]>a[i+1]){
k=a[i];
a[i]=a[i+1];
a[i+1]=k;
}
for(j=0;j<=9;j++)printf("%d\n",a[j]);
system("pause");
}

＃i nclude<stdio.h>
int main()
{
int a[10]={9,2,2,5,6,7,4,5,1,0},i,j,k,m;
for(i=1;i<=9;i++)
{
m=a[i];
for(j=i-1;j>=0 && m<a[j];j--)

a[j+1]=a[j];
a[j+1]=m;
}
for(k=0;k<=9;k++)
printf("%d\n",a[k]);
system("pause");
}

大部分数据结构书上插入排序的写法，感觉用while反而不太清楚：

＃i nclude<stdio.h>
int main()
{
int i,j,k,l;
int a[10]={4,6,8,2,0,1,5,7,3,9};
for(i=1;i<=9;i++)
{
k=a[i];
j=i-1;
while(j>=0 && a[j]>k)
{
a[j+1]=a[j];
j--;
}
a[j+1]=k;
}
for(l=0;l<=9;l++)
printf("%d\n",a[l]);
system("pause");
}

选择冒泡排序法比较

//SortFunction.java
public class SortFunction
{
    //冒泡排序
    public void maoPao(int[]arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            for(int j = i+1; j < arr.length; j++)
            {
                if(arr[i] < arr[j])
                {
                    int m = arr[i];
                    arr[i] = arr[j];
                    arr[j] = m;
                }
            }
        }
        //return arr;
    }
    //选择排序
    public void xuanZhe(int[]arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            int p = i;
            for(int j = i + 1; j < arr.length; j++)
            {
                if(arr[p] < arr[j])
                {
                    p = j;
                }
            }
            int m = arr[i];
            arr[i] = arr[p];
            arr[p] = m;
            
        }
        //return arr;
    }
    
    //另外一种排序,冒泡排序优化
    public void sortTest(int[]arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            for(int j = i+1; j < arr.length; j++)
            {
                if(arr[i] < arr[j])
                {
                    arr[j] = arr[i] | ((arr[i] = arr[j]) & 0);
                }
            }
        }
        //return arr;
    }
    //选择排序优化
    public void sort_xuanZhe(int[]arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            int p = i;
            for(int j = i + 1; j < arr.length; j++)
            {
                if(arr[p] < arr[j])
                {
                    p = j;
                }
            }
            arr[i] = arr[p] | ((arr[p] = arr[i]) & 0);
            
        }
        //return arr;
    }
}

//主测试类SortExample
import java.util.Random;


public class SortExample
{

   
    public static void main(String[] args)
    {
        int len = 50000;
        System.out.println("数据量为" + len + "个int");
        // TODO Auto-generated method stub
        int [] temparr = new int[len];
        int [] temparr1 = new int[len];
        int [] temparr2 = new int[len];
        int [] temparr3 = new int[len];
        Random ran = new Random();
        
        for(int i = 0; i < len; i++)
        {
            int n = ran.nextInt(len);
            temparr[i] = n;
            temparr1[i] = n;
            temparr2[i] = n;
            temparr3[i] = n;
        }
        SortFunction sort = new SortFunction();
        //3种排序算法比较
        
        long tim = System.currentTimeMillis();
        sort.sortTest(temparr);
        long tim1 = System.currentTimeMillis();
        System.out.println("优化冒泡时间为 :" + (tim1 - tim));
        
        tim = System.currentTimeMillis();
        sort.maoPao(temparr1);
        tim1 = System.currentTimeMillis();
        System.out.println("冒泡处理时间为 :" + (tim1 - tim));
        //printArr(test);
        
        tim = System.currentTimeMillis();
        sort.xuanZhe(temparr2);
        tim1 = System.currentTimeMillis();
        System.out.println("选择处理时间为 :" + (tim1 - tim));
        //printArr(test);
        
        tim = System.currentTimeMillis();
        sort.sort_xuanZhe(temparr3);
        tim1 = System.currentTimeMillis();
        System.out.println("优化选择时间为 :" + (tim1 - tim));
        
        //printArr(temparr3);
        
        
    }
    
    public static void printArr(int[]arr)
    {
        for(int i = 0; i < arr.length; i++)
        {
            System.out.print("|" + arr[i]);
        }
        System.out.println();
    }

}


数据量为50000个int
优化冒泡时间为 :12672
冒泡处理时间为 :12500
选择处理时间为 :7687
优化选择时间为 :7657

数据量为50000个int
优化冒泡时间为 :12734
冒泡处理时间为 :12500
选择处理时间为 :7688
优化选择时间为 :7656

数据量为50000个int
优化冒泡时间为 :12609
冒泡处理时间为 :12625
选择处理时间为 :7656
优化选择时间为 :7672

数据量为50000个int
优化冒泡时间为 :12656
冒泡处理时间为 :12500
选择处理时间为 :7687
优化选择时间为 :7704

数据量为50000个int
优化冒泡时间为 :12765
冒泡处理时间为 :12625
选择处理时间为 :7703
优化选择时间为 :7672

数据量为5W,排序所花的时间以上4种方案经过比较,选择排序法比冒泡排序法要快很多,大概在450ms左右,而所谓的优化排序法并不见得是好的排序方法,除了在选择排序法中有时候能快30ms左右外,冒泡排序法一般效率还慢了100多ms.而在选择排序法中有时候其实也比普通的选择排序法慢.所以,排序方法基本上用最传统的选择排序已经完全可以胜任!
--也许我真的忘记了那种特别有效的排序方法,记得好像只用一个循环,可我怎么也想不出来,只用一个循环怎么可能对一个数组进行排序呢!当然,很明显上次注意到的排序方法有两个特别的知识的点,可惜我只记得一个点,另一个点什么时候才能想起来呢!

排序算法思想：

     采用2轮循环，外循环是有序后的元素遍历，内循环用于寻找最值。

 假设最小元素在数组的第0个位置上，从数组的第一个元素开始遍历数组，找出最小的元素

 分别和数组的第0个位置上的元素分别比较，如果该元素小于第0个元素，则交换该元素，

 则交换后该元素就是有序的。说的通俗一点就是：每次选择剩余数据中的最值调整到有序

 部分的后面去。

冒泡法排序算法思想：

    程序采用2轮循环，外循环遍历要排序的元素，内循环用于挑选出最值。

内循环用于将相邻的两个元素进行比较，将小的元素调到大元素的前头。。

内循环的循环次数表示相邻元素的交换趟数。

3、for语句下一条语句

for语句的书写格式：

   for(e1;e2;e3)

        statement

首先，运行e1,它通常是赋值语句，然后对e2求值，它通常是一个比较。如果e2的值为false,则结束循环。

如果e2的值为true,则执行statement。最后，执行e3，它通常是赋值语句，然后控制转移到对e2再次求值。

for 语句用来描述已知重复次数的循环结构。for 语句有两种形式：

  (1) for 控制变量：＝初值 to 终值 do 语句；

  (2) for 控制变量：＝初值 downto 终值 do 语句；

  第一种形式的for语句是递增循环。首先将初值赋给控制变量，接着判断控制变量的值是否小于或等于终值，若是，则执行循环体，在执行了循环体之后，自动将控制变量的值变为它的后继值，并重新判断是否小于或等于终值。当控制变量的值大于终值时，退出for循环，执行for语句之后的语句。

  第二种形式的for 语句是递减循环。首先将初值赋给控制变量，接着判断控制变量的值是否大于或等于终值，若是，则执行循环体，在执行了循环体之后，自动将控制变量的值变为它的前趋值，并重新判断是否大于或等于终值。当控制变量的值小于终值时，退出for循环，执行for语句之后的语句。

  for 语句中的初值、终值、控制变量的数据都必须是顺序类型。当初值和终值确定后，重复的次数就确定不变了，并且控制变量在循环语句内不能施加任何赋值操作。

  例：计算1+2+3+……+99+100

program jia;

var i,sum:integer;

begin

  sum:=0;

  for i:=1 to 100 do

   sum:=sum+i;

  writeln(sum);

end.