【解题报告】《算法零基础100讲》(第33讲) 排序入门 - 冒泡排序

美好的一天从排序开始

原文链接：《算法零基础100讲》(第33讲) 排序入门 - 冒泡排序

不要看这一文章是冒泡排序，按自己想法来做就好。

• 前言
• 冒泡排序原理
• • 实现
• 75. 颜色分类
• • 法一：冒泡排序
  • 法2：首尾双指针
• 4. 寻找两个正序数组的中位数
• • 代码
• 747. 至少是其他数字两倍的最大数
• • 分析
  • 代码

两两相比较，大的向后挪，一轮走完后，最后一个元素就是最大的；依靠这一特性，每一轮找待排序序列的最大值，放到最后。

void Bubble_Sort(int* arr, int len)
{
	assert(arr != NULL);

	bool flag = true;

	for (int i = 0; i < len - 1; ++i)
	{
		flag = true;
		for (int j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				flag = false;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;	
			}
		}
		if (flag)
		{
			break;
		}
	}
}

原题链接：75. 颜色分类

class Solution {
public:
    void sortColors(vector& nums)
    {
        int numSize = nums.size();
        bool flag = true;

        for (int i = 0; i < numSize - 1; ++i)
        {
            flag = true;
            for (int j = 0; j < numSize - i - 1; ++j)
            {
                if (nums[j] > nums[j + 1])
                {
                    flag = false;
                    swap(nums[j], nums[j + 1]);
                }
            }
            if (flag)
            {
                break;
            }
        }    
    }
};

定义两个指针，一个指向头，针对数字0；一个指向尾，针对数字2。

利用下标 i 遍历一遍，若遇到2，则与尾指针对应的数据交换 并将尾指针往前移一格，这里要写成循环，因为交换前尾指针对应的数据本来就是2；

若遇到0，则将他与头指针（0）对应的数据交换，并将头指针往后移；；

class Solution {
public:
    void sortColors(vector& nums)
    {
        int n = nums.size();
        if (n <= 0)
            return ;

        int p0 = 0, p2 = n - 1;

        for (int i = 0; i < n; ++i)
        {
            while (i <= p2 && nums[i] == 2)
            {
                swap(nums[i], nums[p2--]);
            }

            if (nums[i] == 0)
            {
                swap(nums[i], nums[p0++]);
            }
        }    
    }
};

原题链接：4. 寻找两个正序数组的中位数

将两个数组合并为一个数组，然后冒泡排序，取中位数

这里不写冒泡了，直接用的C++的STL，因为是困难题，对时间复杂度有要求，这个题可以收藏，以后练排序用。

class Solution {
public:
    double findMedianSortedArrays(vector& nums1, vector& nums2)
    {        
        nums1.insert(nums1.end(), nums2.begin(), nums2.end());
        
        sort(nums1.begin(), nums1.end());
        int n = nums1.size();

        return (n % 2 != 0) ? nums1[n / 2] : (nums1[n / 2] + nums1[n / 2 - 1]) / 2.0;
    }
};

原题链接：747. 至少是其他数字两倍的最大数

声明两个变量分别代表最大值和第二大的值；

遍历一遍，如果遇到比最大值大的，则顺位更新，遇到比第二大值大的，赋值给第二大；

最后比较最大值和第二大值的关系。。

class Solution {
public:
    int dominantIndex(vector& nums)
    {
        const int ERR = -1;
        int n = nums.size();
        if (n == 0)
            return -1;
        
        int max = -1, second = -1;
        int index = 0;

        for (int i = 0; i < n; ++i)
        {
            if (nums[i] > max)
            {
                second = max;
                max = nums[i];
                index = i;
            }
            else if (nums[i] > second)
            {
                second = nums[i];
            }
        }

        return (second * 2 <= max) ? index : ERR;
    }
};