排序算法总结

常见排序算法有三种，现总结如下（都使用升序排序）：

（1）交换排序：

假设有一个数组nums，长度为5，要对它进行升序排序，交换排序总体思路是：

1. 在下标0-4范围内，将该范围内最小的数字提到下标0
2. 在下标1-4范围内，将该范围内最小的数字提到下标1
3. 在下标2-4范围内，将该范围内最小的数字提到下标2
4. 在下标3-4范围内，将该范围内最小的数字提到下标3
5. 排序完成！

写成代码就应该是：

for (int i = 0; i < 4; i++)
{
    //在 i-4 范围内，将该范围内最小的数字提到i
}

这是假设nums数组长度为5，如果nums数组长度为6呢？用同样的方式分析，就应该是：

1. 在下标0-5范围内，将该范围内最小的数字提到下标0
2. 在下标1-5范围内，将该范围内最小的数字提到下标1
3. 在下标2-5范围内，将该范围内最小的数字提到下标2
4. 在下标3-5范围内，将该范围内最小的数字提到下标3
5. 在下标4-5范围内，将该范围内最小的数字提到下标4
6. 排序完成！

写成代码就应该是：

for (int i = 0; i < 4; i++)
{
    //在 i-4 范围内，将该范围内最小的数字提到i
}

可以看出，不管nums的长度是多少，都可以使用这样的代码格式：

for (int i = 0; i < nums.Length - 1; i++)
{
    //在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
}

因此，只要解决了注释部分的问题，整个排序就完成了！

那如何把i-(nums.Length-1)范围内的最小数字提到位置i呢？

在这个问题上，交换排序使用以下方式完成：

1. 将位置i和位置i+1进行比较，如果比i+1大，则交换
2. 将位置i和位置i+2进行比较，如果比i+2大，则交换
3. ……
4. 将位置i和位置nums.Length-1进行比较，如果比nums.Length-1大，则交换

因此，代码如下：

//在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
for (int j = i + 1; j < nums.Length; j++)
{
    if (nums[i] > nums[j])
    {
        //交换
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

合并起来，最终的代码实现如下：

for (int i = 0; i < nums.Length - 1; i++)
{
    //在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
    for (int j = i + 1; j < nums.Length; j++)
    {
        if (nums[i] > nums[j])
        {
            //交换
            int temp = nums[i];
            nums[i] = nums[j];
            nums[j] = temp;
        }
    }
}

（2）冒泡排序：

冒泡排序有两种思路：

• 将最大的数沉到底部
• 将最小的数冒到顶部

考虑到难易度，我这里介绍的是将最大的数沉到底部这种思路。

假设有数组nums，长度为5，要对它进行升序排序，冒泡排序总体思路是：

1. 在下标0-4范围内，将该范围内的最大数字沉到位置4
2. 在下标0-3范围内，将该范围内的最大数字沉到位置3
3. 在下标0-2范围内，将该范围内的最大数字沉到位置2
4. 在下标0-1范围内，将该范围内的最大数字沉到位置1
5. 排序完成！

写成代码就应该是：

for (int i = 4; i > 0; i--)
{
    //在 0-i 范围内，将该范围内最大的数字沉到i
}

这是假设nums数组长度为5，如果nums数组长度为6呢？用同样的方式分析，就应该是：

1. 在下标0-5范围内，将该范围内的最大数字沉到位置5
2. 在下标0-4范围内，将该范围内的最大数字沉到位置4
3. 在下标0-3范围内，将该范围内的最大数字沉到位置3
4. 在下标0-2范围内，将该范围内的最大数字沉到位置2
5. 在下标0-1范围内，将该范围内的最大数字沉到位置1
6. 排序完成！

写成代码就应该是：

for (int i = 5; i > 0; i--)
{
    //在 0-i 范围内，将该范围内最大的数字沉到i
}

可以看出，不管nums的长度是多少，都可以使用这样的代码格式：

for (int i = nums.Length - 1; i > 0; i--)
{
    //在 0-i 范围内，将该范围内最大的数字沉到i
}

因此，只要解决了注释部分的问题，整个排序就完成了！

那如何把0-i范围内的最大数字沉到位置i呢？

在这个问题上，冒泡排序使用以下方式完成：

1. 将位置0和位置1进行比较，如果前者比后者大，则交换
2. 将位置1和位置2进行比较，如果前者比后者大，则交换
3. ……
4. 将位置i-1和位置i进行比较，如果前者比后者大，则交换

因此，代码如下：

//在 0-i 范围内，将该范围内最大的数字沉到i
for (int j = 0; j < i; j++)
{
    if (nums[j] > nums[j+1])
    {
        //交换
        int temp = nums[j];
        nums[j] = nums[j+1];
        nums[j+1] = temp;
    }
}

合并起来，最终的代码实现如下：

for (int i = nums.Length - 1; i > 0; i--)
{
    //在 0-i 范围内，将该范围内最大的数字沉到i
    for (int j = 0; j < i; j++)
    {
        if (nums[j] > nums[j+1])
        {
            //交换
            int temp = nums[j];
            nums[j] = nums[j+1];
            nums[j+1] = temp;
        }
    }

（3）选择排序：

选择排序的总体思路和交换排序的总体思路相似，都是将某个范围内的最小数提到该范围内的第一位，它的代码结构跟交换排序也是完全相同的：

for (int i = 0; i < nums.Length - 1; i++)
{
    //在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
}

知识在实现注释部分产生了差异，选择排序的思路是：

1. 首先找到 i - (nums.Length-1) 范围内的最小数所在的下标，假设找到的下标保存到变量index中
2. 然后将nums[i]和nums[index]的值交换

因此，使用选择排序实现注释部分的代码如下：

//在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
//1. 首先找到 i - (nums.Length-1) 范围内的最小数所在的下标
int index = i; //先假设最小数的下标是i
for (int j = i + 1; j < nums.Length; j++)
{
    if (nums[j] < nums[index])
    {
        //发现了更小的数
        index = j;//记录下标
    }
}
//2. 然后将nums[i]和nums[index]的值交换
int temp = nums[i];
nums[i] = nums[index];
nums[index] = temp;

合并起来，最终的代码实现如下：

for (int i = 0; i < nums.Length - 1; i++)
{
    //在 i-(nums.Length-1) 范围内，将该范围内最小的数字提到i
    //1. 首先找到 i - (nums.Length-1) 范围内的最小数所在的下标
    int index = i; //先假设最小数的下标是i
    for (int j = i + 1; j < nums.Length; j++)
    {
        if (nums[j] < nums[index])
        {
            //发现了更小的数
            index = j;//记录下标
        }
    }
    //2. 然后将nums[i]和nums[index]的值交换
    int temp = nums[i];
    nums[i] = nums[index];
    nums[index] = temp;
}

排序算法总结