算法研究----排序

首先先生成一个无序的数组

  int[] arr= Enumerable.Range(1, 50).OrderBy(n => Guid.NewGuid()).Take(20).ToArray();

然后对该序列进行使用各种经典的算法排序

1、冒泡排序：每次冒泡都是由下至上相邻的两个元素比较，使较小的关键字交换往上移动，第一次比较出最小元素，以后依次类推。。。

        public void BubbleSort_Help(int[] my_array)
        {
            int count = my_array.Length;

            for (int i = 0; i < count-1; i++)   //冒泡需要排列length-1遍  
            {
                //最小的从最小下面 冒起来，i 为交换次数 第一次冒泡后最小的数在最上面
                //依次类推 第二次冒泡后第二小的数字在正数第二个位置
                //所以每下一次冒泡后 就不需要比较交换 0 至 i 位置的数字 ，所以j > i 忽略 0 -> i
                for (int j = count-1 ; j >i;j--)  
                {
                    int temp;
                    if(my_array[j]<my_array[j-1])    //下面的比上面的小 需要交换
                    {
                        temp = my_array[j];
                        my_array[j] = my_array[j - 1];
                        my_array[j - 1] = temp;
                    }
                }
            }
          }

2、快速排序：从数列中选出一个基准（使用最左边），把比基准小的元素放至基准的左边，把比基准大的元素放至基准的右边，然后递归左边和右边的子序列，直到最小序列，

• 最重要的是把基准值放到最合适的位置，形成左边都比基准小，右边都比基准大，并且返回每次放至基准的位置

 //正序  获得基准元素
        public static int getindex(int[] arr, int left, int right)
        {
            int rbase = arr[left];   //用最左边的值作为 基准值
            while (left < right)    //right 递减 left 递增  一次基准比较结束
            {
                //首先每次都从最右边(right)开始去比较目的找到比基准小的值放到左边去
                while (left < right && arr[right] > rbase)  
                {
                   
                    right--;   //查询第一个小于rbase的值 从右到左找
                }
                arr[left] = arr[right];   //发现了小于rbase的值就放到左边去

                //然后每次都从最左边(left)开始去比较目的找到比基准大的值放到右边去
                while (left < right && arr[left] < rbase)
                {
                  
                    left++;  //查询第一个大于rbase的值 从左到右找
                }
                arr[right] = arr[left];  //发现了大于rbase的值就放到左边去
            }
            arr[left] = rbase;  //每次比较结束 把基准值放到中间去
            return left;   //返回这次比较后的基准值的位置  左边都比基准小 右边都比基准大
        }

• 在已经返回的基准位置的位置，然后再次去递归基准左边的子序列的顺序，和递归基准右边的子序列的顺序

  public static void QuickSort(int[] arr, int left, int right)
        {
            if (left < right)
            {
                //返回基准放至的位置 
                int index = getindex(arr, left, right);
                //在新的左边  left 至新的index-1 去生成新的序列 基准位置不需要比较 
                QuickSort(arr, left, index - 1);
                //在新的右边  index+1 至新的right去生成新的序列
                QuickSort(arr, index + 1, right);
            }
        }

 

 最后传递数组给排序算法：    QuickSort(arr, 0, arr.Length - 1);

3、简单选择排序法：对数列中的元素找出最小的放到第一个位置，然后从剩下的数列中的元素找最小放到第二个位置，再次又从剩下的数列中的元素找到最小放到第三个位置，而后依次类推实现排序。

        public static void SelectSort(int[] arr)
        {
            //i 为需要放置的本次最小值的位置 第一次找出在所有元素中找出最小值，以后依次在剩下中查找，

            //最后一个位置只剩下自己不需要查找最小值，所以i < arr.Length-1
            for (int i = 0; i < arr.Length-1; i++)
            { 
                int min = arr[i]; //每次首先设置第一个为最小值
                int index = i;//最小索引
                //每次都是从第二个开始寻找剩下的 最小值
                for (int j = i+1; j < arr.Length ; j++)
                {
                    if (arr[j] < min)
                    {
                        min = arr[j];
                        index = j;
                    }
                }
               arr[index]=arr[i];  //把第i个位置的值放到未交换前最小值的位置中
               arr[i]=min; //把本次查找的最小值放到本次循环的对应的数组位置i中
            }

        }

4、直接插入排序：对于未排序的元素在已排序的数列中找到合适位置，并每次比较都需要移动位置。

所以从第二个位置开始，和前面的元素比较，发现前面的元素比自身大就与其交换位置。直到前面元素和自身相等或是前面元素比自身小就停止遍历

 public static void InsertSort(int[] arr)
        {
            //不需要从第0个开始，从第一个开始就可以了
            for (int i = 1; i < arr.Length; i++)
            {
                //if (i == 0) continue;
                int temp = arr[i];  //获取需要比较的基准  开始都选中当前的自己
                for (int j = i - 1; j >= 0; j--)  //基准和之前的所有有序数字比较 
                {
                    if (temp > arr[j]) break;  //基准大于前一个数字需要停止遍历
                    else
                    {
                        arr[j + 1] = arr[j];  //基准每小于一次 就需要和前面的数字对换一下
                        arr[j] = temp;
                    }
                }
            }

未完待续。。。