冒泡排序算法

冒泡排序是一种交换排序，其基本思想是：两两比较代排序的数，发现反序时交换，直到没有反序为止。
以下是按传统算法思想写出来的：
 public static void BubbleSort(int[] R)
        {
            for (int i = 0; i < R.Length - 2; i++)
            {
                bool noswap = true;
                for (int j = R.Length-2; j >=i; j--)
                {
                    if (R[j] > R[j + 1])
                    {
                        int temp = R[j];
                        R[j] = R[j + 1];
                        R[j + 1] = temp;
                        noswap = false;
                    }
                }
                if (noswap)
                {
                    break;
                }
            }
        }
我个人觉得j从后面倒回来有点别扭，所以你也可以这样写：
public static void BubbleSort(int[] R)
        {
            for (int i = 0; i < R.Length - 1; i++)
            {
                bool noswap = true;
                for (int j = 0; j < R.Length - 1-i; j++)
                {
                    if (R[j] > R[j + 1])
                    {
                        int temp = R[j];
                        R[j] = R[j + 1];
                        R[j + 1] = temp;
                        noswap = false;
                    }
                }
                if (noswap)
                {
                    break;
                }
            }
        }
当然，这样的话实际上就不是真正的“冒泡”了，而是“下沉”排序，每次找出最大的把它放到最后。
另外，如果用递归来写的话，因为冒泡每次都选出了数组的最小数放在最前面，所以再递归地对去掉该数后的数组排序就可以了，也就是说冒一次泡调用一次递归：
void BubbleSort2(int[] R,int lenght)
        {
            bool noswap = true;//监视哨
            for (int i = R.Length - 1; i > R.Length - lenght; i--)
            {
                if (R[i] < R[i - 1])
                {
                    int t = R[i]; R[i] = R[i - 1]; R[i - 1] = t;
                    noswap = false;
                }              
            }

            if (!noswap || (lenght > 2))
            {
                BubbleSort(R,lenght-1);
            }
        } 
当然，因为可以用循环的地方都可以用递归，所以你也可以对每次冒泡的过程用递归,(略)。