经典的排序算法，冒泡排序

0准备

 1//建立一个排序用的顺序表结构L
 2#define MAXSIZE 9
 3typedef struct SqList
 4{
 5    int r[MAXSIZE];
 6    int length;
 7}SqList;
 8/*排序的交换函数*/
 9void swap(SqList* L,int i,int j)
10{
11    int temp = L->r[i];
12    L->r[i] = L->r[j];
13    L->r[j] = temp;
14}

冒泡排序BubbleSort

一种简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为元素会经由交换慢慢“浮”到数列的顶端。

  1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
  3. 针对所有的元素重复以上的步骤，除了最后一个
  4. 重复步骤1~3，直到排序完成

C的版本

 1//BubbleSort
 2void BubbleSort(SqList *L)
 3{
 4    int i,j;
 5    //最后只剩下一个数，无须比较，因此最后比较的是倒数第二个
 6    for(i = 0; i < L->length - 1; i++)
 7    {
 8        //这里减2的含义是j需要有一个j+1的数去比较
 9        for(j = L->length - 2; j >= i; j-- )
10            if( L->r[j+1] < L->r[j])
11                swap(L, j+1, j);
12    }
13}

i = 0的时候

i = 1的时候

最后的时候

最后结果

Java版本

 1//BubbleSort
 2public int[] BubbleSort(int[] nums)
 3{
 4    if(0 == nums.length)
 5    {
 6        return nums;
 7    }
 8    //循环数组长度的次数
 9    for(int i = 0; i < nums.length; i++)
10    {
11        //从第0个元素开始，依次和后面的元素进行比较
12        //j<array.length - 1 - i表示第array.length - 1 - i个元素
13        //已经冒泡到了何时的位置，无需进行比较，可以减少比较次数
14        for(int j = 0; j < nums.length; j++)
15        {
16            //如果第j个元素比后面的j+1元素大，交互位置
17            if(nums[j + 1] < nums[j])
18            {
19                int tmp = nums[j + 1];
20                nums[j + 1] = nums[j];
21                nums[j] = tmp;
22            }
23            PrintArray.print(nums);
24        }
25        System.out.println("---------");
26    }
27    return nums;
28}