排序算法1(冒泡排序、选择排序、插入排序、希尔排序)

排序算法1

冒泡排序

主要思想

对排序序列从前向后，依次比较相邻元素的值，如果逆序则交换。

代码

static void BubbleSort(int[] arr)
{
    for (int i = 0; i < arr.Length - 1; i++)
    {
        for (int j = 0; j < arr.Length - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t;
            }
        }
    }
}

优化

设置一个布尔类型的标志，如果在某趟比较中没有进行过交换，则表明之后的序列都是有序的

代码

static void BubbleSort(int[] arr)
{
    for (int i = 0; i < arr.Length - 1; i++)
    {
        bool flag = false;
        for (int j = 0; j < arr.Length - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                flag = true;
                int t = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = t;
            }
        }
        if (!flag)
            break;
    }
}

选择排序

主要思想

将无序序列的第i { i ∈ (0 , arr.Length-1) } 个元素假定为最小值，从前向后比较，如果找到更小的值，则记录下标和对应值，遍历过后将第一个元素与真正的最小值进行交换。

代码

 static void SelectSort(int[] arr)
 {
     for (int i = 0; i < arr.Length - 1; i++)
     {
         int min = arr[i];
         int minId = i;
         for (int j = i + 1; j < arr.Length; j++)
         {
             if (min > arr[j])
             {
                 min = arr[j];
                 minId = j;
             }
         }
         //简单优化，如果minId == i说明最小值就是当前的假想值，无须替换
         if (minId != i)	
         {
             arr[minId] = arr[i];
             arr[i] = min;
         }
     }
 }

插入排序

主要思想

把n个待排序的元素堪称一个有序表和一个无序表，开始时有序表只包含一个元素，无序表中包含n-1个元素，排序过程中，每次从无序表中取出第一个元素，插入到有序表的适当位置，使其成为新的有序表

代码

static void InsertSort(int[] arr)
{
   for (int i = 1; i < arr.Length; i++)
   {
       int insertVal = arr[i];
       int insertId = i - 1;
       while (insertId >= 0 && insertVal < arr[insertId])
       {
           arr[insertId + 1] = arr[insertId];
           insertId--;
       }
       arr[insertId + 1] = insertVal;
   }
}

希尔排序

主要思想

将数组按照一定的步长进行分组，对每组使用插入排序算法排序，随着步长逐渐减少，每组就越来越趋近于有序，当增量减少到1时，算法终止，排序完成。

代码

static void ShellSort(int[] arr)
{
    for (int gap = arr.Length / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < arr.Length; i++)
        {
            int id = i;
            int t = arr[i];
            if (arr[id] < arr[id - gap])
            {
                while (id - gap >= 0 && t < arr[id - gap])
                {
                    arr[id] = arr[id - gap];
                    id -= gap;
                }
            }
            arr[id] = t;
        }
    }
}

使用希尔排序对冒泡进行优化

冒泡排序每次比较的是相邻两个值，每趟排序需要遍历的数字只比上次小1，可以利用希尔排序的思想对其进行一定的优化

代码

static void ShellSort(int[] arr)
{
    for (int gap = arr.Length / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < arr.Length; i++)
        {
            for (int j = i - gap; j >= 0; j -= gap)
            {
                if (arr[j] > arr[j + gap])
                {
                    int t = arr[j];
                    arr[j] = arr[j + gap];
                    arr[j + gap] = t;
                }
            }
        }
    }
}