冒泡排序，选择排序，快速排序

简单的排序算法

冒泡排序：主要是拿数组的两个相邻元素比较大小，然后交换他们之间的位置第一次外层循环确定一个最大（最小值），第二次确定剩余数据中的最大（最小值）依次下去。

代码：

int []a={1,5,3,7,8,4,9};


            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0}	", a[i]);  //输出原始数据
            }

            bool IsAsc = false; // true 是升序，false 是降序
            Console.WriteLine();
            for (int i = 0; i <a.Length-1; i++)//每一次在剩余数据中确定一个最大（最下）存放在a[i]，因为最后两个只需要比较一次所以i< a.length-1
            {
                for (int j = i+1; j < a.Length; j++) 
                {
                    if (IsAsc? a[i] > a[j]:a[i]<a[j]) //比较a[i]与a[j]满足条件就交互a[i]与a[j]的值。
                    {
                        int temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;
                    
                    }
                }
            }


            for (int i = 0; i < a.Length; i++)  //输出排序后的结果
            {
                Console.Write("{0}	", a[i]);
            }
            Console.ReadLine();

简单说明下原理
{1,5,3,7,8,4,9};  按从大到小排序 
i=0,j=1 1与5比 满足条件交换a[0]与a[1] 数组变为 {5,1,3,7,8,4,9}
i=0,j=2 5与3比 不满足条件 继续循环。
i=0,j=3 5与7比 满足条件交换a[0]与a[3] 数组变为 {7,1,3,5,8,4,9}
依次类推，但里面的j循环完后 ，9就到了a[0]的位置
然后 i=1,j=2 又走上面的步骤。8就到了a[1]的位置。
当i=6时退出循环所有的数也排好了。

选择排序：顾名思义，每一次循环选择一个满足条件的数据放到对应的位置。比如第一循环 找到最大值下标与a[0]交换，第二次 找到剩余数据最大值下标 与a[1]交换 依次类推。

代码：

            int []a={1,5,3,7,8,4,9};


            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0}	", a[i]);
            }

            bool IsAsc = true;
            Console.WriteLine();
           
            for (int i = 0; i <a.Length-1; i++)
            {
                int index = i;  //默认下标为i的就是满足条件
                for (int j = i+1; j < a.Length; j++)
                {
                    if (IsAsc? a[index] > a[j]:a[index]<a[j])  //每次下标为j的满足条件 就把index记录为j.
                    {
                        index = j;                    
                    }
                }

                if (index != i)  //当index不等于i时说明找到了真的满足条件（找到了真正的最大（最小）值下标）就与下标为i的数进行交换
                {
                    int temp = a[i];
                    a[i] = a[index];
                    a[index] = temp;
                }              

            }


            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0}	", a[i]);
            }
            Console.ReadLine();

 简单说明下原理

{1,5,3,7,8,4,9};  按从大到小排序 
i=0  找到最大的下标6（9）  a[0]与a[6]交换 数组变为 {9,5,3,7,8,4,1}
i=1  找到剩余数中最大值下标 4（8） a[1]与a[4]交换 数组变为{9，8，3，7，5，4，1}
依次类推...

快速排序： 在数组中取任意一个数（一般取a[0]）将数组比这个数大的放一边，小的放另一边，然后 把数组大的一边和小的一边又按前面的重复，直到每一边只剩一个数。
          快速排序用到了递归（方法自己调用自己），如有不懂可以查资料
代码：

　　

int []a={1,5,3,7,8,4,9};


            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0}	", a[i]);
            }

            bool IsAsc = true;  // true 升序 ,false 降序
            Console.WriteLine();
            Order(0, a.Length-1, a,IsAsc); //第一划分是整个数组所以是0-a.length-1

            for (int i = 0; i < a.Length; i++)
            {
                Console.Write("{0}	", a[i]);
            }
            Console.ReadLine();
　　

上面是main 方法体 ，下面是Order方法

  void Order(int left,int right,int []a,bool  IsAsc)
        {

            if (left >=right) return;  //左边的下标不能大于右边的下标        
            int low = left;  //记录左边下标
            int hight = right; //记录右边下标
            int Val = a[left]; //默认取左边的第一值，第一次是a[0]
            while (left < right)
            {
                while (left < right && (IsAsc ? a[right] > Val : a[right]<Val))
                {
                    right--;
                }

                if (left < right)
                {
                    a[left] = a[right];
                    left++;

                }

                while (left < right && (IsAsc ? a[left] < Val : a[left]>Val))
                {
                    left++;
                }

                if (left < right)
                {
                    a[right] = a[left];
                    right--;

                }
            }

            if (left == right)
            {
                a[left] = Val;
            }
             //以上将下标 left到right 之间的数 按 Val 分成三块：下标[low到(left-1)]｛ 都大(小)于a[left]｝ ,[left(right)],[right+1,hight]｛ 都小(大)于 a[left]｝
            //上面执行完 left是等于right的
            firstOrder(low, right - 1, a,IsAsc); //重新比较第一块
            firstOrder(left + 1, hight, a,IsAsc);//重新比较第三块
        
        }

以上都是个人理解，如有错误深感抱歉。