算法——常见排序算法

1.冒泡排序

  /// 冒泡排序
        static void BubbleSort(ref int[] array)
        {
            int temp;
            for (int j = array.Length-1; j >=1; j--)  //每执行完一次外层，就算出当前最大值，然后总排序数-1
            {
                for (int i = 0; i < j; i++)   //i和i+1依次比较，把最大值送到最后，
                {
                    if (array[i] > array[i+1])
                    {
                        temp = array[i+1];
                        array[i+1] = array[i];
                        array[i] = temp;
                    }
                }
            }
        }

---

2.选择排序

 /// 选择排序
        static void SelectionSort(ref int[] array)
        {
            int temp, min;
            for (int j = 0; j < array.Length; j++)   //每执行完一次内循环，min存放计算出的最小值，数组从0开始保存当前最小值；
            {
                min = j;
                for (int i = j+1; i < array.Length; i++)
                {
                    if (array[i] < array[min])
                        min = i;
                }
                temp = array[j];
                array[j] = array[min];
                array[min] = temp;
            }
        }

选择排序：

• 和冒泡相似的地方是，每次执行完一次内循环计算出最小值；
• 不同的是内循环，选择排序单纯地找出最小索引，在最后进行一次调换，而冒泡排序每次发现前面比后面大都会进行调换；
-

---

3.插入排序（和按学号排作业本神似）

///插入排序

 static void InsertSort(ref int[] array)
    {
        int inner, temp;
        for (int j = 1; j < array.Length; j++)
        {
            temp = array[j];
            inner = j;
            while (inner>0&&array[inner-1]>=temp)
            {
                array[inner] = array[inner-1];
                inner--;
            }
            array[inner] = temp;
        }
    }

和排作业本神似，每次j到的位置，就和之前排好的序列比较，直到找见前面比自己小的位置。

---

4.快速排序（小数据量最快排序）

    ///快速排序
        static void QuickSort(ref int[] array,int low,int high)
        {
            if (low >= high)   //如果low大于等于high说明已经排完
                return;
            int index = QuickSortUnit(ref array,low,high);
            QuickSort(ref array,low,index-1);  //对左边进行递归排序
            QuickSort(ref array,index+1,high); //对右边进行递归排序             
        }
        static int QuickSortUnit(ref int[] array,int low,int high)
        {
            int key = array[low];  //这里去第一位数
            while (low<high)
            {
                while (array[high] > key && low < high)
                    high--;
                array[low] = array[high];
                while (array[low] < key && low < high)
                    low++;
                array[high] = array[low];
            }
            //结束了上面的一轮之后，左边都比key小，右边都比key大,中间值还不是key
            array[low] = key;  //中间值变成key
            foreach (int i in array)
            {
                Console.WriteLine(i);
            }
            Console.WriteLine("------------------------------");
            return high;
        }      

6,5,1,2,8,3,4,9,7 进行排序

---

5.希尔排序(插入排序的改进版，又叫缩小增量排序)

非稳定排序，在中等数据量下性能较好；

 ///希尔排序
        static void ShellSort(ref int[] array)
        {
            for (int gap = array.Length / 2; gap>0; gap/=2)//增量初始为数组长度/2，之后一次循环折半
            {
                //从gap开始，逐个对所在组进行直插排序
                for (int i = gap; i < array.Length; i++)
                {
                    int j = i;
                    int temp = array[j];
                    if (array[j] < array[j - gap])
                    {
                        while (j-gap>=0&&temp<array[j-gap])
                        {
                            array[j] = array[j - gap];
                            j -= gap;
                        }
                        array[j] = temp;
                    }                
                }
            }
        }

假设数组为{6,5,1,2,8,3,4,9,7}

• 首先确定一个增量gap，这里初始为数组长度/2=4；
• 把索引相差等于增量的元素分到一个组内，即[6,8,7][5,3][1,4][2,9]
  
• 对各组进行直接插入排序，得到
  
• 将增量折半，即gap=2，从第一步开始，分组完成之后为[6,1,7,4,8][3,2,5,9]
  
• 对组内进行直插排序，得到
  
• 在进行折半，即gap=1，分组为[1,2,4,3,6,5,7,9,8]
• 组内直插，得到
  

即在gap=1时完成组内排序，就是完成了整个希尔排序；