bubbleSort

冒泡排序：
1.idea：
比如从小到大排序，一个数组的两个相邻的元素不断的比较，将较大的一个数放在后面，一轮比较后，最大的数将放在最后,一个位置；
第二轮比较结束后，第二大的数放在了倒数第二个位置。。。。。。

复杂度：n^2;
2.input:
待排序数组 array A; size n;
3.output:
排好 的数组
4.process :

(1) 
bubblesort(int[] A, int n){
for:  i, 0~n-1;i++  {

 for :　j, 0~n-2-i;j++{
  if(A[j]>A[j+1])
  swap(j,j+1);
 }
}
}

/*每个元素与它的下一个元素比较；

j 的范围是0~n-2-i ;

所以 j+1 范围是 1~ n-1-i ;

*/
如果j的范围为0~n-1-i（即0<=j<=n-1-i）则错误，因为i=0时，j=n-1,j+1=n,A[j]越界。



(2) 

swap1(int i,int j){
float temp=A[i];
A[i]=A[j];
A[j]=temp;
}

swap2(int i ,int j){
A[i]+=A[j];
A[j]=A[i]-A[j];
A[i]-=A[j];
}
        (3)改进：
bubblesort(float[] A, int n){
for:  i, 0~n-1;i++  {
flag=1;
 for :　j, 0~n-2-i;j++{
  if(A[j]>A[j+1])
  
{ flag=0;
swap(j,j+1);
}
 }
        if(flag=1) break;
// 如果某一轮没有swap,表示已经排好序。
}
}
5. 具体实现：

范例：
#define N 4
int A[N]={1, 5,2,4};
void swap1(int i,int j);

int main(){
int i,j;
int flag;
for(i=0;i<N;i++)
{    flag=1;
for(j=0;j<N-1-i;j++)
{
if(A[j]>A[j+1])
{  swap1(j,j+1);//任意一种
flag=0;
}
}
        if(flag)  break;
}
return 0;
}

void swap1(int i,int j){
A[i]+=A[j];
A[j]=A[i]-A[j];
A[i]-=A[j];

}

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

（5）改进的冒泡排序：

/*
从小到大排序；
*/
void bubbleSort(int *array ,int n){
 int exchange;
 int temp;
 int i,j;

 for(i=0;i<n;i++){
  exchange=0;//默认每次没有交换，如果有交换则exchange=1;

  for(j=0;j<=n-2-i;j++)
   if(array[j]<array[j+1]){
    swap(&array[j],&array[j+1]);
    exchange=1;
   }

  if(0==exchange) return ;
  //如果某遍没有交换，说明已经排序好。
 }

}

（6）冒泡排序的稳定性：

如果将array[j]<array[j+1] 写为 array[j]<=array[j=1],则是不稳定的排序。

（7）数组的初始顺序对冒泡的影响：

如果初始数组就是从小到大的顺序，则冒泡排序的比较次数为n-1次，移动次数为0次，总的时间复杂度为O(n);
如果初始数组是从大到小的，则时间复杂度为O(n^2);

（8）起始数组有序时，冒泡排序和插入排序：

如果初始数组中所有元素时完全有序，则插入排序和冒泡排序的时间复杂度均为O(n);
如果初始数组中所有元素时基本有序（部分逆序），这是插入排序比冒泡排序更加好，差别主要在元素的移动上面，因为冒泡排序的交换数据更浪费时间。