[LeetCode] 23. Merge k 정렬 리스트 문제 풀이 보고서 (Python)

저자: 음 설 명 초 id: fuxuemingzhu 개인 블 로그:http://fuxuemingzhu.cn/
제목 주소:https://leetcode.com/problems/merge-k-sorted-lists/description/
제목 설명:
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

제목 의 대의
하나의 링크 에 있 는 k 개의 질서 있 는 링크 를 질서 있 는 링크 로 합 쳤 다.
문제 풀이 방법
방법 1: 매번 최소 값 옮 겨 다 니 기 (TLE)
이 문 제 는 21. Merge Two Sorted Lists 의 확장 으로 고전 문제 에 속 합 니 다. 생각 하기 쉬 운 방법 은 lists 에서 가장 작은 값 을 찾 은 다음 에 현재 의 링크 끝 에 연결 하 는 것 입 니 다.주의해 야 할 것 은 링크 지침 을 수정 하 는 방법 으로 lists 의 머리 요 소 를 업데이트 할 수 없 기 때문에 lists 를 강제로 업데이트 할 수 밖 에 없습니다.
시간 카드 는 링크 의 최소 요 소 를 찾 을 때마다 시간 을 초과 합 니 다.
시간 복잡 도 는 O (N * K), 공간 복잡 도 는 O (1) 다.N 은 결과 링크 의 길이 이 고 K 는 매번 문제 가 제시 하 는 링크 갯 수 입 니 다.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = ListNode(-1)
        move = head
        while True:
            curHead = ListNode(float('inf'))
            curIndex = -1
            for i, llist in enumerate(lists):
                if llist and llist.val < curHead.val:
                    curHead = llist
                    curIndex = i
            if curHead.val == float('inf'):
                break
            curNext = curHead.next
            move.next = curHead
            curHead.next = None
            move = curHead
            curHead = curNext
            lists[curIndex] = curHead
        return head.next

방법 2: 작은 루트 저장 값 과 색인
이 방법 은 위 에서 시간 을 초과 한 상황 에 따라 자 연 스 럽 게 생각해 낸 것 이다. 우 리 는 매번 K 개의 체인 헤드 노드 의 최소 치 를 사용 해 야 하기 때문에 모든 링크 의 머리 노드 를 작은 뿌리 더미 안에 넣는다.이렇게 매번 튀 어 나 오 는 것 은 최소 링크 의 값 입 니 다. 그리고 이 값 의 색인 에 따라 Lists 에서 해당 하 는 노드 를 찾 아 끝까지 연결 하면 됩 니 다.
누군가가 사용 하 는 팝 업 더미 에서 가장 작은 값 을 사용 한 다음 에 새로운 노드 를 다시 만 드 는 방식 은 좋 지 않다.
또한 코드 에서 주의해 야 할 문 제 는 방법 과 마찬가지 로 링크 의 머리 결 점 을 업데이트 해 야 한 다 는 것 입 니 다. 지침 을 수정 하 는 방식 으로 수정 할 수 없고 직접 값 을 부여 하여 업데이트 해 야 합 니 다.이 절차 가 적 으 면 색인 에 따라 찾 으 면 오래된 노드 를 계속 얻 을 수 있 습 니 다.
시간 복잡 도 는 O (N) 이 고 공간 복잡 도 는 O (1) 이다.N 은 결과 링크 의 길이 이 고 K 는 매번 문제 가 제시 하 는 링크 갯 수 입 니 다.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = ListNode(-1)
        move = head
        heap = []
        heapq.heapify(heap)
        [heapq.heappush(heap, (l.val, i)) for i, l in enumerate(lists) if l]
        while heap:
            curVal, curIndex = heapq.heappop(heap)
            curHead = lists[curIndex]
            curNext = curHead.next
            move.next = curHead
            curHead.next = None
            move = curHead
            curHead = curNext
            if curHead:
                lists[curIndex] = curHead
                heapq.heappush(heap, (curHead.val, curIndex))
        return head.next

방법 3: 작은 루트 저장 값 과 노드
Python 3 에 대해 서 는 노드 를 직접 쌓 아 둘 수 없습니다. 비교 할 수 없 는 문제 가 발생 할 수 있 기 때 문 입 니 다.그러나 python 2 에 대해 서 는 이렇게 할 수 있 기 때문에 노드 의 값 과 노드 를 더미 에 직접 저장 할 수 있 습 니 다. 그러면 매번 튀 어 나 오 는 것 이 가장 작은 값 의 노드 이 고 직접 사용 하면 됩 니 다.

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        head = ListNode(-1)
        move = head
        heap = []
        heapq.heapify(heap)
        [heapq.heappush(heap, (l.val, l)) for i, l in enumerate(lists) if l]
        while heap:
            curVal, curHead = heapq.heappop(heap)
            curNext = curHead.next
            move.next = curHead
            curHead.next = None
            move = curHead
            curHead = curNext
            if curHead:
                heapq.heappush(heap, (curHead.val, curHead))
        return head.next

시간 복잡 도 는 O (N) 이 고 공간 복잡 도 는 O (1) 이다.N 은 결과 링크 의 길이 이 고 K 는 매번 문제 가 제시 하 는 링크 갯 수 입 니 다.
참고 자료:
날짜.
2018 년 10 월 16 일 - 비 오 는 날 은 그래도 편 해 요.