要求：从键盘里输入数值

自从用了VS以后，渐渐地用记事本就写不出完整的代码了~~，所以只说下逻辑吧。
冒泡就是把一组数中，相邻两个的数比较大小，如果较小的数在前面，就把这两个数交换位置，否则不交换。经过一个嵌套循环，最后就可能把数字按从小到大，或从大到小排列好。

using System;
using System.Collections.Generic;
using System.Text;

namespace 冒泡排序
{
    class Program
    {
        static void Main(string[] args)
        {
           double[] arr=new double[3];
           double temp;
           Console.WriteLine("请输入3个数：");
            for(int i=0;i<arr.Length;i++)
            {
                arr[i]=double.Parse(Console.ReadLine());
            }
            for (int i = 0; i < arr.Length; i++)
            {
                for (int j = i; j < arr.Length; j++)
                    if (arr[i] > arr[j])
                    {
                        temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                    }
            }
            Console.WriteLine("结果：");
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
        

            }
           Console.ReadLine();  
        }
    }
}

谢谢！！！！！

不错，不错。。。。

你这个可以实现排序的功能，但不是冒泡排序的算法吧。
我以前也是这样写的冒泡排序，但昨天才发现这种写法是错误的。
循环里面应该是这样的
 

所谓的冒泡排序就是先进行一轮排序，找出做大或最小的排在第一位，再从第二位开始进行下一轮排序，如此循环而已
楼上的排序法虽然是可以，可原理是一样的...只是楼上的程序比较规范而已...

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。
  由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

我这写了一个区别，二者的过程完全不是一致的。冒泡排序是比较的想邻的两个数。

 static void Main(string[] args)
        {
            int[] array = new int[] { 3, 4, 2, 1, 6, 5 };
            Console.Write("排序前：");
            for (int i = 0; i < array.Length;i++ )
                Console.Write("array[{0}]={1}  ", i, array[i]);
            sord1(array);
            Console.Write("排序后：");
            for (int i = 0; i < array.Length; i++)
                Console.Write("array[{0}]={1}  ", i, array[i]);


            array = new int[] { 3, 1, 2, 4, 6, 5 };
            Console.Write("排序前：");
            for (int i = 0; i < array.Length;i++ )
                Console.Write("array[{0}]={1} ", i, array[i]);
            Console.WriteLine();
           
            sord2(array);
            Console.Write("冒泡排序后：");
            for (int i = 0; i < array.Length; i++)
                Console.Write("array[{0}]={1} ", i, array[i]);
            Console.ReadKey();
        }

        //冒泡排序法
        static void sord2(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine();
                Console.Write("第{0}轮排序：", i);
                for (int j = 0; j < array.Length - i - 1; j++)
                {
                    if (array[j] < array[j + 1])
                    {
                        int temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = temp;
                    }
                    Console.Write("array[{0}]={1} ", j, array[j]);
                }
            }
            Console.WriteLine();
           
        }

        static void sord1(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine();
                Console.Write("第{0}轮排序：", i);
                for (int j = i; j < array.Length; j++)
                {
                    if (array[i] < array[j])
                    {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                    Console.Write("array[{0}]={1} ", j, array[j]);
                }               
            }Console.WriteLine();
        }

   
两个的运行结果是一致的，但过程是有差别的。
排序前：array[0]=3  array[1]=4  array[2]=2  array[3]=1  array[4]=6  array[5]=5

第0轮排序：array[0]=3 array[1]=3 array[2]=2 array[3]=1 array[4]=4 array[5]=5
第1轮排序：array[1]=3 array[2]=2 array[3]=1 array[4]=3 array[5]=4
第2轮排序：array[2]=2 array[3]=1 array[4]=2 array[5]=3
第3轮排序：array[3]=1 array[4]=1 array[5]=2
第4轮排序：array[4]=1 array[5]=1
第5轮排序：array[5]=1
排序后：array[0]=6  array[1]=5  array[2]=4  array[3]=3  array[4]=2  array[5]=1
排序前：array[0]=3 array[1]=1 array[2]=2 array[3]=4 array[4]=6 array[5]=5

第0轮排序：array[0]=3 array[1]=2 array[2]=4 array[3]=6 array[4]=5
第1轮排序：array[0]=3 array[1]=4 array[2]=6 array[3]=5
第2轮排序：array[0]=4 array[1]=6 array[2]=5
第3轮排序：array[0]=6 array[1]=5
第4轮排序：array[0]=6
第5轮排序：
冒泡排序后：array[0]=6 array[1]=5 array[2]=4 array[3]=3 array[4]=2 array[5]=1

其实就排序来说,没有什么方法是最好的,因为要关联到实际的情况,同种算法在不同情况下运算量会相差非常大
所以楼上的来一个例子来说明算法的优越性是有问题的

优越性这个肯定没有什么，只是说明这冒泡排序法的一个原理而已。当然优越性应根据程序需求的实际情况来制定