力扣-统计数组中的元素（645、697、448、442、41、274）

力扣-统计数组中的元素（645、697、448、442、41、274）

1. 统计数组元素出现的个数(存放到字典中)

dict={}
for x in list:
	if x in dict:
		continue
	else:
		d[x]=list.count(x)

2. 统计一个元素在数组中出现的最左和最右的位置（也就是第一次出现和最后一次出现的位置）

first=list.index(x)   #第一次出现
last=len(list)-list[::-1].index(x)-1   #先倒置数组，计算倒置后第一次出现的位置，也就是原来最后一次的位置。

还可以用一个counter来计数，每遇到一个x，counter就+1，当counter=list.count(x)时，就说明这是x最后一次出现。

for k,v in enumerate(list):
	if v==x:
		counter=counter+1       #每遇到一个x，counter+1
	if counter==list.count(x):
		right=k    		#right表示最后一次出现的位置

3. 判断一个数是否在数组中

if x in list:
	pass
if x not in list:
	pass

---

错误的集合（645）

思路： 原集合的和为sum1，1-N集合的和为sum2，将原集合set后求和为sum3，重复的数为sum1-sum3，丢失的数为sum2-sum3

class Solution:
    def findErrorNums(self, nums: List[int]) -> List[int]:
        sum1=sum(nums)
        sum2=sum(range(1,len(nums)+1))
        sum3=sum(set(nums))
        return [sum1-sum3,sum2-sum3]

---

数组的度（697）

思路： 找到出现频率最大的元素（即众数，可能不止一个），然后计算众数出现的第一个位置和最后一个位置，众数相差长度=最后一个位置 - 第一个位置，最后比较每个众数的相差长度，最小的即为解。

class Solution:
    def findShortestSubArray(self, nums: List[int]) -> int:
        min=len(nums)
        d={}
        m=0
        dist=0
        for x in nums:
            if x in d:
                continue
            else:
                d[x]=nums.count(x)
                if d[x]>m:
                    m=d[x]        
        for k,v in d.items():
            if m==v:
                first=nums.index(k)
                last=len(nums)-nums[::-1].index(k)-1
                dist=last-first+1
                if dist<min:
                    min=dist
        return min

---

找到数组中消失的数（448）

思路： 遍历1-n这个整数序列，然后判断该整数是否在set(nums)中，如果不在则这个整数即是缺失的数。

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        result=[]
        l=len(nums)
        numset=set(nums)
        i=1
        while i<=l:
            if i not in numset:
                result.append(i)
            i=i+1
        return result

---

数组中重复的数据(442)

思路： 遍历数组，令nums[x]为相反数，下次再遇到x时，对应的nums[x]若为负数，说明这是第二次出现，为什么要取相反数呢？因为取相反数不会改变该位置值得特性，我们取绝对值之后还是原来的数。

class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        result=[]
        for k,v in enumerate(nums):
            if nums[abs(v)-1]<0:
                result.append(abs(v))
            else:
                nums[abs(v)-1]=-nums[abs(v)-1]
        return result     

缺失得第一个正数（41）

思路： 设置一个 j ，表示下一个本需要出现得正整数，遍历数组，从第一个大于0的数开始，如果nums[i]==j，说明 j 代表的这个整数出现了，这时 需要 j+1，表示需要下一个正整数，依此进行下去，直到遍历完，j 最后的值就是代表没有出现过的正整数。

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        j=1
        nums.sort()
        for i in range(len(nums)):
            if nums[i]>0:
                if nums[i]==j:
                    j=j+1
        return j

---

H指数(274)

方法一： 暴力破解
遍历每一种可能的指数，然后再遍历看citations中是否有h篇论文大于等于h。遍历下来得到H指数。

class Solution:
    def hIndex(self, citations: List[int]) -> int:
        max=0
        l=len(citations)
        for i in range(1,l+1):   
            m=0        #有多少篇论文大于i引用量
            for j in range(l):
                if citations[j]>=i:
                    m=m+1
            if m>=i:   #恰好有i篇
                max=i
        return max

方法二： 先将citations排序，令h=len(citations)-i，如果citations[i]>=h，则 i 之后的论文都会大于h，这样就可以求得H指数。
例如：
[3,0,6,1,5]
排序得
[0,1,3,5,6]
l=len(citations)=5
h=l-i
要求citations[i]>=h才能保证有h篇论文引用量大于h。

class Solution:
    def hIndex(self, citations: List[int]) -> int:
        citations.sort()
        l=len(citations)
        for i in range(l):
            h=l-i
            if citations[i]>=h:
                return h
        return 0