继续讨论数组问题

关卡名	继续讨论数组问题	我会了✔️
内容	1.数组中出现次数超过一般的数字
	2.数组中只出现一次的数字
	3.颜色分类问题

1 数组中出现次数超过一半的数字 

这是剑指offer中的一道题目，数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
例如：输入如下所示的一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2，如果不存在则输出0。
对于没有思路的问题，我们的策略都是先在脑子里快速过一遍常见的数据结构和常见的算法策略，看看谁能帮我们解决问题，所以很多问题就会自然而然的出现多种解法。
首先，用排序行不行？这里说一定存在出现次数超过一半的数字了，那么先对数组进行排序。在一个有序数组中次数超过一半的必定是中位数，所以可以直接取出中位数。如果不放心，可以再遍历数组，确认一下这个数字是否出现次数超过一半。OK，没问题，第一种方法就出来了。这种方法的的时间复杂度取决于排序算法的时间复杂度，最快为O(nlogn)。由于排序的代价比较高，所以我们继续找其他方法。
其次，用Hash行不行？我们先创建一个HashMap的key是元素的值，value是已经出现的次数，然后遍历数组来统计所有元素出现的次数。最后再次遍历Hash，找到出现次数超过一半的数字。OK，第二种方法出来了，代码就是：

public int moreThanHalfNum(int [] array) {
    if(array==null)
        return 0;
    Map<Integer,Integer> res=new HashMap<>();
    int len = array.length;
    for(int i=0;i<array.length;i++){
        res.put(array[i],res.getOrDefault(array[i],0)+1);
        if(res.get(array[i])>len/2)
            return array[i];
    }
    return 0;
}

上面的方式虽然能解决问题，如果面试时写到这种程度，那就得了80分了。
拓展本题有一种巧妙的解法。上面算法的时间复杂度为O(n)，但是这是用O(n)的空间复杂度换来的。那是否有空间复杂度为O(1)，时间复杂度为O(n)的算法呢？
下面介绍的方法普适性并不好，而且实现也挺麻烦，可以先跳过。根据数组特点，数组中有一个数字出现的次数超过数组长度的一半，也就是说它出现的次数比其他所有数字出现的次数之和还要多。因此，我们可以在遍历数组的时候设置两个值：一个是数组中的数result，另一个是出现次数times。当遍历到下一个数字的时候，如果与result相同，则次数加1,不同则次数减一，当次数变为0的时候说明该数字不可能为多数元素，将result设置为下一个数字，次数设为1。这样，当遍历结束后，最后一次设置的result的值可能就是符合要求的值（如果有数字出现次数超过一半，则必为该元素，否则不存在），因此，判断该元素出现次数是否超过一半即可验证应该返回该元素还是返回0。这种思路是对数组进行了两次遍历，复杂度为O(n)。
在这里times最小为0，如果等于0了，遇到下一个元素就开始+1。看两个例子， [1,2,1,3,1,4,1]和[2,1,1,3,1,4,1]两个序列。
首先看 [1,2,1,3,1,4,1]，

开始的时候result=1，times为1

然后result=2，与上一个不一样，所以times减一为0

然后result=1，与上一个不一样，times已经是0了，遇到新元素就加一为1

然后result=3，与上一个不一样，times减一为0

然后result=1，与上一个不一样，times已经是0了，遇到新元素就加一为1

然后result=4，与上一个不一样，times减一为0

然后result=1，与上一个不一样，times加一为1

所以最终重复次数超过一半的就是1了

这里可能有人会有疑问，假如1不是刚开始的元素会怎样呢？例如假如是序列[2,1,1,3,1,4,1]，你按照上面的过程写一下，会发现扛到最后的还是result=1，此时times为1。
还有一种情况假如是偶数，而元素个数恰好一半会怎么样呢？例如[1,2,1,3,1,4]，很明显最后结果是0，只能说明没有存在重复次数超过一半的元素。假如是奇数个，例如[1,2,1,3,1,4,1]，此时结果是1，明显有超过一半的，所以我们最后还是要再遍历一遍来检查一下，代码如下：

public int majorityElement(int[] nums) {
    int count = 0;
    Integer candidate = null;

    for (int num : nums) {
        if (count == 0) {
            candidate = num;
        }
        count += (num == candidate) ? 1 : -1;
    }

    return candidate;
}

2 数组中只出现一次的数字

LeetCode136.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次，找出那个只出现了一次的元素。

示例1：

输入：[2,2,1] 输出：1

示例2：

输入：[4,1,2,1,2] 输出：4

这个题貌似使用Set集合比较好，Set集合不存重复值，这一特点可以利用。题目明确说其他元素都是出现两次，我们也可以利用这个操作，当要添加的元素key与集合中已存在的数重复时，不再进行添加操作，而是将集合中的key一起删掉，这样整个数组遍历完后，集合中就只剩下了那个只出现了一次的数字了。

public static Integer findOneNum(int[] arr) {
    Set<Integer> set = new HashSet<Integer>();
    for(int i : arr) {
        if(!set.add(i))//添加不成功返回false，前加上！运算符变为true
            set.remove(i);//移除集合中与这个要添加的数重复的元素
    }
    //注意边界条件的处理
    if(set.size() == 0)
        return null;
    //如果Set集合长度为0，返回null表示没找到
    return set.toArray(new Integer[set.size()])[0];
}

 上面要注意，必须存在那个只出现了一次的数字，否则Set集合长度将为0，最后一行代码运行时会出错。
第二种方法：位运算这个题面试官可能还会让你用位运算来做，该怎么办呢？
异或运算的几个规则是：

0^0 = 0;

0^a = a;

a^a = 0;

a ^ b ^ a = b.

0与其他数字异或的结果是那个数字，相等的数字异或得0。要操作的数组中除了某个数字只出现了一次之外，其他数字都出现了两次，所以可以定义一个变量赋初始值为0，用这个变量与数组中每个数字做异或运算，并将这个变量值更新为那个运算结果，直到数组遍历完毕，最后得到的变量的值就是数组中只出现了一次的数字了。这种方法只需遍历一次数组即可，代码如下：

public static int findOneNum(int[] arr) {
    int flag = 0;
    for(int i : arr) {
        flag ^= i;
    }
    return flag;
}

 由此，也回到我们刚开始说的问题，数组的问题不会做，不是说明你数组没学好，而是要学习Hash、集合、位运算等等很多高级问题。
元素次数是非常重要的专题，而且难度略大的问题，而各个大厂又非常喜欢考察。因此，我们提前将常见的场景都研究一遍是非常必要的，重复问题除了我们上面提到的之外，还有大量相关的问题，感兴趣的同学可以继续研究：

• 剑指offer 题目1：找出数组中的重复数字
• 剑指offer题目2：不修改数组找出重复的数字
• LeetCode137：在一个数组中除一个数字出现一次之外，其他数字都出现了三次，请找出那个只出现一次的数字。

3 颜色分类问题（荷兰国旗问题） 

这个也是非常经典的算法问题，LeetCode75，也称为荷兰国旗问题。给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。必须在不使用库的sort函数的情况下解决这个问题。

示例：

输入：nums = [2,0,2,1,1,0]

输出：[0,0,1,1,2,2]

如果你查一下会发现一个有趣的现象，很多几个国家的国旗如下：

你是否感觉这些号称创新力很高的国家竟然这么敷衍，这也太像了吧！这道题你是否感觉叫法国国旗或者意大利国旗更合适啊，那为什么叫荷兰国旗呢？因为这个题的发明者正是大名鼎鼎的荷兰计算机科学家Dijkstra，在图算法中我们已经认识他了。
这个题是非常经典的双指针问题，而且还可以使用多种方式的双指针。这里我们分析两种方法，一种与冒泡排序非常类似，一种与快速排序非常类似。
1.基于冒泡排序的双指针（快慢指针）
冒泡排序我们都知道，就是根据大小逐步和后面的比较，慢慢调整到整体有序。这种方法还是稳定的排序方法。
我们可以考虑对数组进行两次遍历。在第一次遍历，我们将数组中所有的 0 交换到数组的头部，这样第二次遍历只需要处理1和2的问题就行了，而这两次寻找本身又是非常漂亮的双指针。代码如下：

public  void sortColors(int[] nums) {
    int n = nums.length;
    int left = 0;
    //将所有的0交换到数组的最前面
    for (int right = 0; right < n; right++) {
        if (nums[right] == 0) {
            int temp = nums[right];
            nums[right] = nums[left];
            nums[left] = temp;
            left++;
        }
    }

    //将所有的1交换到2的前面
    for (int right = left; right < n; ++right) {
        if (nums[right] == 1) {
            int temp = nums[right];
            nums[right] = nums[left];
            nums[left] = temp;
            ++left;
        }
    }
}

 上面的方式能解决问题，而且效率还不错。但是面试官可能又给你出幺蛾子，能否将两次遍历变成一次搞定？这个稍微有些难 ，如果感觉太烧脑，可以暂时放下，头发长齐了再看。
如果要求只用一次遍历就要解决问题，该怎么办呢？我们隐约感觉到要使用三个指针才行：

• left指针，表示left左侧的元素都是0
• right指针 ，表示right右侧的元素都是2
• index指针，从头到尾遍历数组，根据nums[index]是0还是2决定与left交换还是与right交换。

index位置上的数字代表着我们当前需要处理的数字。当index为数字1的时候，我们什么都不需要做，直接+1即可。如果是0，我们放到左边，如果是2，放到右边。如果index=right，则可以停止。
我们看一下图示：

这里的重点和难点index位置为2进行交换后为什么只进行right--，而不用index++呢？这是因为我们right位置交换过来的元素可能是0，也可能是1。如果是0自然没问题，但是如果是1则执行index++就将1跳过了无法处理了。所以我们先不动index，在下一次循环时继续判断这个index位置元素是不是0。
那为啥index位置是0的时候执行swap就可以index++了呢，这是因为如果index前面位置如果存在位置都会被swap到right位置去了，这里只需要处理0和1的情况就可以了。

public void sortColors(int[] nums) {
    int left=0,right=nums.length-1;
    int index=0;
    while(index<=right){
        if(nums[index]==0)
            swap(nums,index++,left++);
        else if(nums[index]==2)
            swap(nums,index,right--);
        else
            index++;
    }
}
private void swap(int[] nums,int i,int j){
    int temp=nums[i];
    nums[i]=nums[j];
    nums[j]=temp;
}