大话排序算法——bubble

冒泡排序，气泡排序

基本思想：将序列中的第一个元素与第二个元素进行比较，如果前者的大于后者，则两个元素交换位置，否则不交换；再将第二个元素与第三个元素比较，若前者大于后者，两个元素交换位置，否则不交换；以此类推，直到n-1个元素与第n个元素比较（或交换）。经过如此一趟排序，使得n个元素中的最大者被安置在第n个位置上。以后，再对n-1个元素进行同样的过程，使得该n-1个元素的最大者被安置在整个序列的第n-1个位置上；然后再对前n-2个元素重复上述过程……直到对前两个元素重复上述过程为止，排序结束。

说这么多，还不如看看下面：

bubble.cpp

void swap(int *p, int *q)
{
    *p = *p ^ *q;
    *q = *p ^ *q;
    *p = *p ^ *q;
}
//从前面往后面冒泡
void  bubble_sort1(int p[]，int size)
{
    for( int i = size - 1; i > 0 ; i-- )
    {
	for( int j = 0; j < i ; j ++ )
	{
	    if( p[j] > p[j+1] )
	    {
		swap(p[j],p[j+1]);
	    }
	}
    }
}
//从后面往前面冒泡
void bubble_sort2(int p[], int size)
{
    for(int i = size - 1; i > 0 ; i--)
    {
         for(int j = size - 1; j > size - (i + 1) ; j--)
         {
	    if( p[j - 1] > p[j] )
	    {
		swap(p[j-1],p[j]);
	    }
	}
    }
}

时间复杂度计算：

操作：                                                    时间复杂度：

int n = 0;                                                   1

void……                                                   1

        n++;                                                  1

        for …… i < size - 1                           n  

               for……j  < i                                 n

                      if……                                    1

最优时间：n

平均时间：

最坏时间：n*n

O(n) = n*n

空间复杂度计算：O(1)

鸡尾酒排序，双向冒泡排序

首先从前往后把最大数移到最后，然后反过来从后往前把最小的一个数移动到数组最前面，这一过程就是第一轮，然后重复这一过程，最终就会把整个数组从小到大排列好。双向冒泡排序要稍微优于传统的冒泡排序，因为双向排序时数组的两头都排序好了，我们只需要处理数组的中间部分即可，而单向即传统的冒泡排序只有尾部的元素是排好序的，这时每轮处理都需要从头一直处理到已经排好序元素的前面一个元素。虽然它在效率上有了点改进，但它也不能大幅度提高其排序的效率，这是由冒泡排序的基本过程所决定了的。

//改进版的冒泡排序(双向冒泡)
void BidBubbleSort(int array[], int n)
{
    int low, high, flag, i;
    low = 0;
    high = n - 1;
    while(low < high)
    {
        flag=0;
        for(i=low; i<high; i++)  //正向冒泡
        {
            if(array[i] > array[i+1]) //找到剩下中最大的
            {
                Swap(&array[i], &array[i+1]);
                flag = 1;    //标志， 有数据交换
            }
        }
        if( !flag )
            break;
        high--;
        for( i=high; i>low; i-- ) //反向冒泡
        {
            if(array[i] < array[i-1])   //找到剩下中最小的
                Swap(&array[i], &array[i-1]);
        }
        low++;
    }
}

这里有冒泡算法的一些深入理解：http://blog.csdn.net/morewindows/article/details/6657829