数据结构系列：排序算法[C#]（冒泡排序，插入排序，选择排序，直接排序）

冒泡排序：

//冒泡排序是最基本的排序方法，主要是通过，
第一循环： 先挑选从【0- 数组长度】的元素，让他作为比较的数字。
第二循环：挑选 当前比较的数字之后的所有数字里面，比他小的数字，将最小的那一个，跟当前的数字进行交换。最后使得第二循环结束的时候，当前第一循环中的 第一个数字，将是当前数组里面最小的数字。

重新开始一整轮的第二循环（然后推进第一循环一次）

最后每一次第一循环都会使一个位置成为当前之后的最小数字

static  void BubbleSort(int[] dataArray)//冒泡排序
        {
            for (int i = 0; i < dataArray.Length; i++)
            {
                for (int j = i+1; j < dataArray.Length; j++)
                {
                    if(dataArray[i]>dataArray[j])
                    {
                        int temp = dataArray[j];
                        dataArray[j] = dataArray[i];
                        dataArray[i] = temp;
                    }            
                }        
            }
        }

插入排序：

首先是 第一循环：遍历整个数组的 从 【1- 数组长度】
使得第一循环会遍历 除了0 以外的所有数字

并且，第一循环将会储存所有【第一循环信标的值】
bool [ 是否有成功插入位置 ] 初始为 否

第二循环开始，将会遍历整个数组 信标前面的所有元素
如果第二信标 比我们的第一信标要大，那么直接让他到后一个位置
第二信标 向前移动
第二循环这个一部分的动作很像 抽牌插入时，一个个的把位置向后挪

然后如果前面的数字（第二信标）比 当前信标（第一信标）小时，意味着到了合适的位置。
当前第二信标后面 空出一个位置插入 第一信标 ，bool 改变为 插入已经完成。退出第二循环

然后我们再次进入第一循环
//如果某个第一信标 比所有的 第二信标都大时，位置一直被空开来，最后，bool值也没有变化。证明插入还未完成，只是空出了位置。
所以，第一信标直接插入0号元素，也就是第一个。

static void InsertSort(int[] dataArrary)
        {
            for (int i =1 ; i < dataArrary.Length;i ++)
            {   // 第一循环      dataArrary【i】   //第一信标
                int value = dataArrary[i];
                bool isInsert = false;
                for (int j = i - 1; j >= 0; j--)  //第二循环
                {               dataArrary【j】   //第二信标
                    if (dataArrary[j] > value) 
                    {
                        dataArrary[j + 1] = dataArrary[j];
                        //如果前面的j比后面的i大，换一个位置
                    }
                    else //发现一个比i小的值就不进行移动
                    {
                        dataArrary[j + 1] = value;
                        //把i的值放到j+1的位置。
                        isInsert = true;
                        break;
                    }
                }
                if(isInsert == false)
                {
                    dataArrary[0] = value;
                }          
            }
        }

选择排序：【下面的解释依旧会用 第一循环 第一信标 第二循环 第二信标来解释】

第一循环：遍历队列中从【0 到 数组长度-1】的数字，但在一轮第二循环中，只有一次第一循环
第二循环：遍历从【i+1 到 数组长度】的数字， 称为 第二信标

所以这次我们有一个小信标来承载循环中最小的数字，
他初始是在第一信标的位置。
首先小信标会在 第一信标的 初始位置
跟第二循环的所有元素进行比较（其实就是跟他位置后面的所有元素进行比较）
最后小信标将变成这一组比较中最小的数字。

然后单次 第一循环 将 得出单个最小的数字 然后跟 第一信标的数据调换。
单轮 第一循环过后 得出 排序

   static void SelectSort(int[] dataArray)
        {
            for (int i = 0; i < dataArray.Length-1; i++)
            {
                int min = dataArray[i];//小信标
                int minxIndex = i;     //小信标的序号
                for (int j = i+1; j < dataArray.Length; j++)
                {
                    if(dataArray[j]<min)//如果 后面的数字 比  前面的大
                    {
                        min = dataArray[j];//后面的数字称为新的信标
                        minxIndex = j;     //新的序号
                    }
                }
                if(minxIndex  != i)//如果信标有发生改动
                {
                    int temp = dataArray[i];//临时变量
                    dataArray[i] = dataArray[minxIndex];
                    //将原本第一信标的数据 发送到小信标的位置，替换过去
                    dataArray[minxIndex] = temp;
                    //将小信标插到 第一信标的位置
                }
            }
        }

快速排序：
排序原理解释，

一直用 x（第一个数字） 作为 比较的条件 称为 第一信标
从右边开始寻找，比第一信标小的数字将被调到第一信标之前的位置，
从左边开始寻找，比第一信标大的数字将被跳到第一信标之后的位置。

然后最后 当左右坑 在同一位置时，证明分界已经结束。第一信标所在位置就是分界点

//即便第一个数就为100(最大），他也会先找一个右坑，发现最后一个是右坑，然后调换，
//之后直接一路遍历过去，直接变成最后一个 i ==j；
//开始下一次的循环。

static void QuickSort(int[] dataArray,int left,int right)
        {
            if(left < right)//设置左右界限
            {
                int i = left; int j = right;//将左右界限 位置 整形化
                int x = dataArray[left];//第一信标，初始在左边界限处，同时也挖空了，这个位置
    
                while (true && i<j)//当i == j的时候 。 
                {
                    while (true && i < j)//只要i<j， 从右到左 ， 死循环寻找。
                    {
                        if (dataArray[j] <= x)//当 “右信标”小于 “第一信标x”的时候
                        {                     //证明最开始“第一信标”的坑 可以被填上了。
                            dataArray[i] = dataArray[j]; //第一个坑 被 “右信标”的元素替换
                                                         //同时也是新的 第二个坑
                            break;                       //离开循环
                        }
                        else
                        {
                            j--;//让“右信标”从右向左遍历，寻找比第一信标大的数字。
                        }
                    }
                    //break 之后 到了新的死循环 不过这次是从左到右的。
                    while (true && i < j)
                    {
                        if (dataArray[i] > x)//【i】因为第一个坑被填上了，i成为了新的“左信标”
                        {                    //一直遍历，直到找到大于第一信标的数字。
                            dataArray[j] = dataArray[i];//填上第二个坑。
                                                        //同时J这个位置成了第三个坑。
                            break;
                        }
                        else
                        {
                            i++;
                        }
                    }
                }
                //  不断的循环 直到 现在左坑等于右坑， 第一信标的位置正式成为中间。
                //  因为左边的都是左坑，被填上了小于x的数，右边的都是比x大的数。
                //   x的位置不一定是中心，但一定是分届。
                dataArray[i] = x;   //最后 将分界画出来
                QuickSort(dataArray, left, i - 1);
                QuickSort(dataArray, i + 1, right);
                //再次无限分界。最后得出排序。
            }
            return;
        }