【刷题日记】字符串/ 流中第一个不重复的字符&第一个重复的数字 &只出现一次的数字

题目1：第一个只出现一次的字符的位置

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

# -*- coding:utf-8 -*-
class Solution:
    def FirstNotRepeatingChar(self, s):
    	# 字符串空返回-1
        if not s:
            return -1
        #Hash表计数
        count_dict = {} 
        # string转list遍历
        s_list = list(s)
        # 对每个字符计数
        for item in s:
            if item in count_dict:
                count_dict[item] += 1
            else:
                count_dict[item]=0
        # 再次遍历找到第一个重复/不重复
        for i,item in enumerate(s):
            if count_dict[item] ==0:
                return  i # 注意返回的是位置
        return -1

题目4：字符流中第一个不重复的字符

题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:

如果当前字符流没有存在出现一次的字符，返回#字符。

思路
字符流具有：1. 不断更新 。 2. 有顺序
涉及次数：–> 计数hash表
涉及顺序: --> 有序list
总体来说，即使用一个list，使用一个字典。字典做输入字符的计数。list记录输入字符的顺序（只记下第一次出现的字符）。
那怎么返回第一个只出现一次的呢？
让list[0]永远是那个第一次只出现一次的字符：即在输入字符流的过程中，更新list和dict，如果list[0]出现第二次，就pop掉，始终保持list[0]是返回字符。当list长度为0 ，就返回#

# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char
    def __init__(self):
        self.count = {} # 计数hash表
        self.record = [] # 记序list
    #  返回第一个不重复的字符
    def FirstAppearingOnce(self):
    	# 遍历list，当list不空，且其值出现次数大于1，弹出该值
        while len(self.record)>0 and self.count[self.record[0]] ==2:
                self.record.pop(0)
        # 弹出list前面重复的字符后，如果list长度为0，返回#，否则返回list[0]
        if len(self.record) ==0:
            return '#'
        else:
            return self.record[0]
    # 根据输入字符更新list和dict
    def Insert(self, char):
		# 如果字典中没有当前输入，则计数并加入列表
        if char not in self.count.keys():
            self.count[char] =1
            self.record.append(char)
        else:
        	# 如果字典中已有当前输入，则只计数
            self.count[char]=2

题目2： 第一个重复的数字

在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

思路一：
首先毫无疑问，如果不考虑时间和空间复杂度，完全可以类似于前一个题“字符串中第一个只出现一次的字符“一样，准备一个Hash表计数数字出现次数。由于只需要返回任意一个，所以可以遍历键值（乱序），也可以遍历数组（顺序），来找到出现次数为2的第一个值。
代码如下：
时间复杂度和空间复杂度都是$O(n)$

# -*- coding:utf-8 -*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        if len(numbers) == 0 or len(numbers)==1:
            return False
        count = {}
        for item in numbers:
            if item in count:
                count[item]+=1
            else:
                count[item] =1
        # 这里写遍历keys
        for item in count.keys():
            if count[item] ==2:
                duplication[0] = item
                return True
        # 也可以遍历数组
        '''
        for item in numbers:
        	if count[item]==2:
        		duplication[0] =item
        		return True'''
        return False

思路二：
但是上面的思路没有利用到数组长度为n，且值的范围在0~n-1这个有用条件。其实这个数组本身就可以是一个hash表。可以考虑将数字根据值调整到对应索引位置。如果数字没有重复，那么该数组正好每个位置放一个数。但是因为有重复，在调整过程中，发生冲突，即可返回冲突值。
这样空间复杂度是$O(1)$, 时间复杂度是$O(n)$

但是下面这个代码通不过。。Orz。请参考在下面的代码块。

# -*- coding:utf-8 -*-
# 该代码跪求debug
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        if len(numbers) == 0 or len(numbers)==1:
            return False
        for i,item in enumerate(numbers):
        	# 遍历位置的值对不对
        	while item != i:
                # 不对的话，遍历位置的值该在的地方的值对不对：
                if numbers[item] == numbers[i]:
                    # 对的话，冲突了。返回
                    duplication[0] = item
                    return True
                # 不对的话，交换位置调整
                else:
        		    idx = numbers[i]
                    numbers[i],numbers[idx] = numbers[idx],numbers[i]
                    # 下面这种交换方法会出错！！！
                    #numbers[i],numbers[numbers[i]]= numbers[numbers[i]],numbers[i]          	
        return False

# AC 代码
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate2(self,numbers,duplication):
        # 数组长度合法性检查
        if len(numbers) ==0 or len(numbers)==1:
            return False
        # 数组内容合法性检查
        for i in numbers:
            if i<0 or i>len(numbers)-1:
                return False
        
        for i in range(len(numbers)):
            while numbers[i] !=i:
                if numbers[numbers[i]] == numbers[i]:
                    duplication[0] = numbers[i]
                    return True
                else:
                    idx = numbers[i]
                    numbers[i],numbers[idx] = numbers[idx],numbers[i]
                    # 下面这种交换方法会出错！！！
                    #numbers[i],numbers[numbers[i]]= numbers[numbers[i]],numbers[i]
        return False

题目3：数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路1
类似前面几个问题，这个问题当然也可以准备一个计数字典来解决

# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        if len(array) == 0 or len(array) ==1:
            return None
        record = {}
        lis = []
        for item in array:
            if item in record:
                record[item] = 2
            else:
                record[item] =1
        for item in array:
            if record[item] ==1:
                lis.append(item)
        return lis   

当然也可以直接点。。。
但这个算法的复杂度有点高。。。

class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        tmp = set()
        for a in array:
            if a in tmp:
                tmp.remove(a)
            else:
                tmp.add(a)
        return list(tmp)

思路2
但是准备一个计数表，总觉得漏了点题目里面的什么。
空间复杂度$O(n)$可不可以省掉呢？

抄一段思路和java代码先，python有空再补。。。：

考虑这个问题的一个简单版本：一个数组里除了一个数字之外，其他的数字都出现了两次。请写程序找出这个只出现一次的数字。
为什么要强调有一个数字出现一次，其他的出现两次？
异或运算的性质：任何一个数字异或它自己都等于0 。
如果从头到尾依次异或数组中的每一个数字，那么最终的结果刚好是那个只出现一次的数字异或的结果。结果中的1表示他们的不同位。
那些出现两次的数字全部在异或中抵消掉了。
然后回到原始的问题。
如果能够把原数组分为两个子数组。在每个子数组中，包含一个只出现一次的数字，而其它数字都出现两次。如果能够这样拆分原数组，按照前面的办法就是分别求出这两个只出现一次的数字了。
从头到尾依次异或数组中的每一个数字，在结果中数字的二进制表示中至少就有一位为1 。在结果数字中找到第一个为1 的位的位置，记为第N 位。然后以第N 位是不是1 为标准把原数组中的数字分成两个子数组，第一个子数组中每个数字的第N 位都为1 ，而第二个子数组的每个数字的第N 位都为0 。
现在已经把原数组分成了两个子数组，每个子数组都包含一个只出现一次的数字，而其它数字都出现了两次。因此到此为止，所有的问题我们都已经解决。

public class Solution {
    public void FindNumsAppearOnce(int[] array, int[] num1, int[] num2)    {
        int length = array.length;
        if(length == 2){
            num1[0] = array[0];
            num2[0] = array[1];
            return;
        }
        int bitResult = 0;
        for(int i = 0; i < length; ++i){
            bitResult ^= array[i];
        }
        int index = findFirst1(bitResult);
        for(int i = 0; i < length; ++i){
            if(isBit1(array[i], index)){
                num1[0] ^= array[i];
            }else{
                num2[0] ^= array[i];
            }
        }
    }
     
    private int findFirst1(int bitResult){
        int index = 0;
        while(((bitResult & 1) == 0) && index < 32){
            bitResult >>= 1;
            index++;
        }
        return index;
    }
     
    private boolean isBit1(int target, int index){
        return ((target >> index) & 1) == 1;
    }
}