C#排序1（冒泡排序、直接排序、快速排序） 下

冒泡排序：就是两个两个的这个比较好理解，代码也比较好写出来。

　　　　　　它的原理就是相邻的两个两个的比较,如果前面的数比后面的大，那么交换，它这个在比较完一次的时候可以得到最大的一个数，然后接着循环,每次外循环中内循环的次数比原来少一次。

　　　　　　

下面是C#代码

    #region 冒泡排序
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public List<int> BubbleSort(List<int> list)
        {
            for (int i = 0; i < list.Count - 1; i++)
            {
                for (int j = 0; j < list.Count - 1 - i; j++)
                {
                    if (list[j] > list[j + 1])
                    {
                        int temp = list[j];
                        list[j] = list[j + 1];
                        list[j + 1] = temp;
                    }
                }
            }
            return list;
        }
        #endregion

 直接排序原理是，让第一个元素和之后的每一个元素相互比较，如果大就交换，每次可以让第一个元素为最小值,如图：

代码：

#region 直接排序
        /// <summary>
        /// 直接排序
        /// </summary>
        /// <param name="list"></param>
        public void SelectionSort(List<int> list)
        {
            for (int i = 0; i < list.Count; i++)
            {
                for (int j = i + 1; j < list.Count; j++)
                {
                    if (list[i] > list[j])
                    {
                        int temp = list[i];
                        list[i] = list[j];
                        list[j] = temp;
                    }
                }
            }
        }
        #endregion

快速排序：貌似效率是最高的，在C#中的类库排序就是用的它：

它的原理是：有两个指针left和right  left默认先指向  最左边的元素 right默认指向最右边的元素，然后把指针为left的元素定义为标准，实现在标准左边的元素比标准小，右边的元素比标准大，然后经过递归不断的建立标准 ，而实现排序

下面是我的一些理解：

比如要排序的数组是  643581这些数，黄色代表Left指针；红色代表right指针;蓝色表示left和right重合

开始：left指向第一个元素，right指向最后一个元素 

第1次：left指针和left+1比较，6>4，left指针向右移动，right不变;left的值和left+1的值互换

第2次：left指针和left+1比较，6>3，left指针向右移动，right不变;left的值和left+1的值互换

第3次：left指针和left+1比较，6>5，left指针向右移动，right不变;left的值和left+1的值互换

第4次：left指针和left+1比较，6<8，left指针不动，right向左移动;right的值和left+1的值互换

第5次：left指针和left+1比较，6>1，left指针向右移动，right不变;left的值和left+1的值互换；

发现left和right重合 ，实现6左边的比6小，6右边的比6大。然后重新定义

left=原来的left；right=left-1

left=left+1 与right=原来的right 接着进行下次遍历

下面是C#代码：

#region 快速排序
        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="list"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        public void QuickSort(List<int> list, int left, int right)
        {
            if (left < right)
            {
                int i = Division(list, left, right);
                QuickSort(list, i + 1, right);
                QuickSort(list, left, i - 1);
            }
        }

        /// <summary>
        ///把列表按照list[left]分到左右两边 
        /// </summary>
        /// <param name="list"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        private int Division(List<int> list, int left, int right)
        {
            while (left < right)
            {
                int num = list[left];
                if (num > list[left + 1])
                {
                    list[left] = list[left + 1];
                    list[left + 1] = num;
                    left++;
                }
                else
                {
                    int temp = list[right];
                    list[right] = list[left + 1];
                    list[left + 1] = temp;
                    right--;
                }
                Console.WriteLine(string.Join(",", list));
            }
            Console.WriteLine("--------------\n");
            return left;
        }
        #endregion

这段C#代码在每次循环的时候都打印出来这次的值，如图：