python 처리 list 에서 set, 최대 집합 을 가 져 옵 니 다.

얼마 전에 데이터 분석 을 할 때 이런 수 요 를 만 났 습 니 다. n 가지 물건 이 있 습 니 다. m 개인 은 모든 사람 이 n 가지 물건 중 여러 개 를 산 적 이 있 습 니 다. 두 사람 사이 에 똑 같은 물건 을 산 적 이 있다 면 몇 개 든 우 리 는 그 를 같은 사람 으로 생각 합 니 다.설령 a 와 b 두 사람 사이 에 같은 물건 을 산 적 이 없다 하 더 라 도 c 는 모두 a 와 b 중의 물건 을 산 적 이 있다. 그러면 a, b, c 는 모두 같은 부류 로 볼 수 있다.구체 적 인 형식 은 다음 과 같다. list = [{1, 4, 7}, {2, 5, 7}, {1, 5, 6}, {9, 11, 23}, {4, 23, 39}, {34, 6, 10}]
       list 의 set 대표 인의 쇼핑 상황 (이 예제 에는 len (list) 개인 이 있 음), 하나의 set 의 데이터, 예 를 들 어 {1, 4, 7} 은 현재 사람들 이 구 매 하 는 물품 색인 이 1, 4, 7 임 을 나타 낸다.우리 가 얻어 야 할 결 과 는 [{1, 4, 7, 2, 5, 1, 6, 34, 10}, {9, 11, 23}, {4, 23, 39}] 그 의 미 는 1, 4, 7, 2, 5, 6, 34, 10 아 이 템 을 구 매 하 는 사람 은 1 류 이 고 9, 11, 23 아 이 템 을 구 매 하 는 사람 은 1 류 이 며 4, 23, 39 아 이 템 을 구 매 하 는 사람 은 1 류 이다.emm... 그렇습니다.
주체 사상 은 두 set 가 교 집합 되 지 않 으 면 두 가 지 를 합쳐서 새로운 집합 으로 삼 는 다 는 것 이다.
두 가지 해결 방법 을 제공 합 니 다.
첫째: 귀속, 코드 는 다음 과 같다.

# one      list  
finallist = [] #         
one.apend({len(one)})  #          （list   ，           ）
#     
def dealwithlist(first, one):
    residue = []
    if len(one) > 0:
        for i in range(0, len(one)):
            if first & one[i]:
                first = first | one[i]
            else:
                residue.append(one[i])
        #                 set
        if finallist.__contains__(first):
            if len(residue) > 1:  #     list     
                finallist.insert(0, finallist[-1])  #        finalist    
                dealwithlist(residue[0], residue)
                return
            else: #             ，   
                return
        else:
            if len(finallist) > 0:
                finallist.pop(-1)  #   finalist      
            finallist.append(first)
    dealwithlist(first, residue)

one. pop (- 1) \ # 마지막 결과 집 얻 기
재 귀 의 단점 도 뚜렷 하 다. 데이터 의 양 이 커지 고 비교 횟수 가 증가 할 때 최대 재 귀 깊이 를 초과 하여 스 택 이 넘 치 는 문제 가 발생 할 수 있다!대신의 해결 을 기다리다
 
 
둘 째: 동적 변경 list:
list_처리 할 list

def set_group(list_a):
    tgt = []
    #       ，    
    for i, x in enumerate(list_a):
        z = x  #       
        flag = []  #

        #         ，     ，           
        if len(tgt) > 0:
            for j, y in enumerate(tgt):
                #         
                if z.intersection(y):
                    z = z.union(y)
                    #      ，        
                    flag.append(j)

                    #          ，       
            if len(flag) > 0:
                flag.reverse()  #         ，   list          
                for k in flag:
                    tgt.pop(k)

        tgt.append(z)
    return tgt