무한 목록에서 100 개의 가장 높은 숫자 얻기

내 친구 중 한 명이이 인터뷰 질문을 받았습니다.

"무한한 숫자 목록에서 나오는 숫자의 흐름이 일정하다. 그 중 어느 시점에서든 최고 100 개의 최고 숫자를 반환하기 위해 데이터 구조를 유지해야한다. 모든 숫자는 정수일 뿐이다."

이것은 간단합니다. 정렬 된 목록을 내림차순으로 유지하고 해당 목록에서 가장 낮은 번호의 트랙을 유지해야합니다. 얻은 새 숫자가 가장 낮은 숫자보다 큰 경우에는 가장 낮은 숫자를 제거하고 필요에 따라 정렬 된 목록에 새 숫자를 삽입해야합니다.

그런 다음 질문이 확장되었습니다-

"삽입 순서가 O (1)이어야합니까? 가능합니까?"

내가 아는 한 정렬 알고리즘을 사용하여 목록에 새 번호를 추가하고 다시 정렬하더라도 퀵 정렬을 위해 O (로그온)이 가장 좋습니다 (생각합니다). 그래서 친구는 불가능하다고 말했습니다. 그러나 그는 확신이 없었으며 목록이 아닌 다른 데이터 구조를 유지하도록 요청했습니다.

균형 잡힌 이진 트리를 생각했지만 거기에서도 1의 순서로 삽입 할 수는 없습니다. 그래서 같은 질문이 있습니다. 위의 문제에 대해 1의 순서로 삽입 할 수있는 데이터 구조가 있는지 또는 전혀 불가능한지 알고 싶었습니다.

k는 알고 자하는 가장 높은 숫자의 수라고 가정합니다 (예에서 100). 그런 다음에 새 번호를 추가 할 수 O(k)도있는가 O(1). 왜냐하면 O(k*g) = O(g) if k is not zero and constant.

목록을 정렬하지 마십시오. 새 숫자를 삽입할지 여부를 알아내는 데 시간이 오래 걸리지 만 삽입 은 O (1)입니다.

이것은 쉬워요. 상수 목록의 크기, 따라서 목록의 정렬 시간은 일정합니다. 일정한 시간에 실행되는 작업을 O (1)라고합니다. 따라서 고정 크기 목록의 경우 목록 정렬은 O (1)입니다.

100 개의 숫자를 통과하면 다음 숫자에 발생할 수있는 최대 비용은 숫자가 가장 높은 100 개의 숫자인지 확인하는 비용 ( CheckTime 이라고 레이블을 붙입니다 )과 해당 세트에 입력하고 배출하는 비용입니다 가장 낮은 것 ( EnterTime 이라고 부름 ), 상수 시간 (적어도 경계 숫자의 경우) 또는 O (1) .

Worst = CheckTime + EnterTime

다음으로, 숫자 분포가 무작위이면 평균 비용은 더 많은 숫자를 줄입니다. 예를 들어, 101 번째 숫자를 최대 세트에 입력해야 할 확률은 100/101이고, 1000 번째 숫자는 1/10이고, n 번째 숫자는 100 / n입니다. 따라서 평균 비용에 대한 방정식은 다음과 같습니다.

Average = CheckTime + EnterTime / n

따라서 n 이 무한대에 가까워 지면 CheckTime 만 중요합니다.

Average = CheckTime

숫자가 바인딩되어 있으면 CheckTime 이 일정하므로 O (1) 시간입니다.

숫자가 제한되지 않으면 검사 시간이 더 많아 질수록 증가합니다. 이론적으로 이것은 최대 세트에서 가장 작은 숫자가 충분히 커지면 더 많은 비트를 고려해야하기 때문에 검사 ​​시간이 길어지기 때문입니다. 그것은 일정 시간보다 약간 더 높은 것처럼 보입니다. 그러나 n 이 무한대에 가까워 지면 다음 숫자가 가장 높은 세트에 있을 확률이 0에 가까워지고 더 많은 비트를 고려해야 할 가능성도 0에 가까워 질 것입니다. 이는 O (1)에 대한 인수입니다 시각.

나는 긍정적이지 않지만 내 직감은 그것이 O (log (log (n))) 시간 이라고 말합니다 . 숫자가 가장 적게 증가 할 확률은 로그이고 각 검사에 대해 고려해야 할 비트 수가 로그 일 수도 있기 때문입니다. 나는 확실하지 않기 때문에 다른 사람들 이이 일에 관심이 있습니다 ...

Binary Heap Trees 를 알고 있다면 이것은 쉽다 . 이진 힙은 평균 상수 시간 O (1)에서의 삽입을 지원합니다. 첫 x 요소에 쉽게 액세스 할 수 있습니다.

질문에 의해 면접관이 실제로“각 수신 번호가 일정한 시간에 처리되도록 할 수 있습니까?”라고 물었다면 이미 많은 사람들이 지적한대로 (예 : @ duedl0r의 답변 참조) 친구의 해결책은 이미 O (1)이며, 그가 정렬되지 않은 목록을 사용했거나 거품 정렬을 사용했거나 다른 것을 사용하더라도 그렇게 될 것입니다. 이 경우 까다로운 질문이 아니거나 잘못 기억하지 않는 한 질문은 의미가 없습니다.

나는 면접관의 질문이 의미가 있다고 생각하는데, 그는 무언가를 O (1)로 만드는 방법을 묻지 않았으며, 그것은 이미 매우 명백합니다.

입력 알고리즘의 크기가 무한정 커질 때에 만 질문 알고리즘의 복잡성이 의미가 있으며 여기서 커질 수있는 유일한 입력은 100입니다. 나는 실제 질문이 "친구의 솔루션에서와 같이 O (N)이 아닌 숫자 당 O (1) 시간을 소비 할 수 있습니까?"라고 가정했습니다.

가장 먼저 염두에 두어야 할 것은 계수 정렬입니다 .O (m) 공간 사용 가격에 대한 Top-N 문제의 숫자 당 O (1) 시간의 복잡성을 구입할 것입니다. 여기서 m 은 들어오는 숫자의 길이입니다. . 네, 가능합니다.

삽입 시간이 일정한 Fibonacci heap으로 구현 된 최소 우선 순위 큐를 사용하십시오 .

1. Insert first 100 elements into PQ
2. loop forever
       n = getNextNumber();
       if n > PQ.findMin() then
           PQ.deleteMin()
           PQ.insert(n)

이 작업은 필요한 숫자 목록의 길이 N에서 O (1) 인 알고리즘을 분명히 찾는 것입니다. 따라서 상위 100 개 숫자 또는 10000 개 숫자가 필요한 경우 삽입 시간은 O (1)이어야합니다.

여기서 요점은 목록 삽입에 O (1) 요구 사항이 언급되었지만 질문은 정수 공간에서 검색 시간 순서에 대해 아무 말도하지 않았지만 O (1)로 만들 수 있음이 밝혀졌습니다 게다가. 해결책은 다음과 같습니다.

1. 키의 숫자와 값의 연결된 목록 포인터 쌍으로 해시 테이블을 배열하십시오. 각 포인터 쌍은 연결된 목록 시퀀스의 시작과 끝입니다. 이것은 일반적으로 다음 요소 중 하나 일 것입니다. 링크 된 목록의 모든 요소는 다음으로 높은 숫자를 가진 요소 옆에 있습니다. 따라서 링크 된 목록에는 정렬 된 필수 숫자 순서가 포함됩니다. 가장 낮은 숫자의 레코드를 유지하십시오.

2. 랜덤 스트림에서 새로운 숫자 x를 가져옵니다.

3. 마지막으로 기록 된 가장 낮은 숫자보다 높습니까? 예 => 4 단계, 아니오 => 2 단계

4. 방금 가져온 숫자로 해시 테이블을 누르십시오. 출품작이 있습니까? 예 => 5 단계. 아니오 => 새로운 숫자 x-1을 가져 와서이 단계를 반복하십시오 (이것은 간단한 하향 선형 검색입니다. 여기 나와 함께하시면됩니다. 개선 될 수 있으며 방법을 설명하겠습니다)

5. 해시 테이블에서 가져온 목록 요소를 사용하여 링크 된 목록의 요소 바로 뒤에 새 숫자를 삽입하고 해시를 업데이트하십시오.

6. 기록 된 가장 낮은 숫자 l을 가져 와서 해시 / 목록에서 제거하십시오.

7. 방금 가져온 숫자로 해시 테이블을 누르십시오. 출품작이 있습니까? 예 => 8 단계. 아니오 => 새로운 숫자 l + 1을 취하고이 단계를 반복하십시오 (이것은 간단한 상향 선형 검색입니다).

8. 긍정적 인 숫자로 숫자는 새로운 가장 낮은 숫자가됩니다. 2 단계로 이동

중복 값을 허용하려면 해시는 실제로 중복 된 요소의 링크 된 목록 순서의 시작과 끝을 유지해야합니다. 주어진 키에서 요소를 추가하거나 제거하면 지정된 범위가 증가하거나 감소합니다.

여기에 삽입은 O (1)입니다. 언급 된 검색은 O (숫자 사이의 평균 차이)와 같은 것 같습니다. 평균 차이는 숫자 공간의 크기에 따라 증가하지만 필요한 숫자 목록의 길이에 따라 감소합니다.

따라서 숫자 공간이 큰 경우 (예 : 4 바이트 int 유형, 0에서 2 ^ 32-1까지) N = 100 인 경우 선형 검색 전략은 매우 좋지 않습니다. 이 성능 문제를 해결하기 위해 적절한 키를 만들기 위해 숫자가 더 큰 크기 (예 : 1, 10, 100, 1000)로 반올림되는 병렬 해시 테이블 세트를 유지할 수 있습니다. 이런 식으로 기어를 위아래로 움직여 필요한 검색을 더 빨리 수행 할 수 있습니다. 그런 다음 성능은 O (log numberrange)가된다.

이것을 더 명확하게하기 위해, 197이라는 숫자가 있다고 상상해보십시오. '190'으로 10s 해시 테이블을 치면 가장 가까운 10으로 반올림됩니다. 아무것도? 아니요. 120이 될 때까지 10 초 안에 내려갑니다. 그러면 1s 해시 테이블에서 129에서 시작한 다음 무언가를 칠 때까지 128, 127을 시도 할 수 있습니다. 연결 목록에서 197을 삽입 할 위치를 찾았습니다. 197 해시 테이블을 197 항목으로, 10s 해시 테이블을 190으로, 100s로 100을 100으로 설정해야합니다. 숫자 범위 로그의 10 배입니다.

나는 세부 사항 중 일부가 잘못되었을 수도 있지만 이것이 프로그래머 교환이고 컨텍스트가 인터뷰이기 때문에 위의 상황이 그 상황에 대해 설득력있는 대답이기를 바랍니다.

편집 병렬 해시 테이블 체계를 설명하기 위해 여기에 약간의 세부 사항을 추가했으며 언급 한 가난한 선형 검색이 O (1) 검색으로 대체 될 수 있음을 의미합니다. 또한 가장 낮은 숫자로 해시 테이블을보고 다음 요소로 진행하여 바로 다음 단계를 검색 할 수 있기 때문에 다음으로 가장 낮은 숫자를 검색 할 필요가 없다는 것을 깨달았습니다.

숫자가 Integer와 같은 고정 데이터 유형이라고 가정 할 수 있습니까? 그렇다면 추가되는 모든 단일 숫자의 집계를 유지하십시오. 이것은 O (1) 작업입니다.

1. 가능한 많은 요소가있는 배열을 선언하십시오.
2. 스트리밍 될 때 각 번호를 읽습니다.
3. 숫자를 집계하십시오. 당신이 그것을 절대로 필요로하지 않기 때문에 그 숫자가 100 번 이미 계산 되었다면 그것을 무시하십시오. 이를 통해 오버플로가 무한히 커지는 것을 방지 할 수 있습니다.
4. 2 단계부터 반복하십시오.

VB.Net 코드 :

Const Capacity As Integer = 100

Dim Tally(Integer.MaxValue) As Integer ' Assume all elements = 0
Do
    Value = ReadValue()
    If Tally(Value) < Capacity Then Tally(Value) += 1
Loop

목록을 반환하면 원하는 시간이 소요될 수 있습니다. 목록의 끝에서 간단히 종료하고 기록 된 최고 100 개의 값으로 새 목록을 작성하십시오. 이것은 O (n) 연산이지만, 그것은 무의미합니다.

Dim List(Capacity) As Integer
Dim ListCount As Integer = 0
Dim Value As Integer = Tally.Length - 1
Dim ValueCount As Integer = 0
Do Until ListCount = List.Length OrElse Value < 0
    If Tally(Value) > ValueCount Then
        List(ListCount) = Value
        ValueCount += 1
        ListCount += 1
    Else
        Value -= 1
        ValueCount = 0
    End If
Loop
Return List

편집 : 실제로 고정 데이터 유형인지는 중요하지 않습니다. 메모리 (또는 하드 디스크) 소비에 대한 제한이없는 경우 양의 정수 범위에서이 작업을 수행 할 수 있습니다.

백개의 숫자는 크기가 100 인 배열에 쉽게 저장됩니다. 현재 작업이 주어지면 모든 트리, 목록 또는 세트가 과도합니다.

들어오는 숫자가 배열에서 가장 낮은 값 (= 마지막)보다 높으면 모든 항목을 실행합니다. 새로운 숫자보다 작은 첫 번째 숫자를 찾으면 (멋진 검색을 사용하여), 나머지 배열을 실행하여 각 항목을 "아래로"밀어냅니다.

목록을 처음부터 정렬 한 상태로 유지하므로 정렬 알고리즘을 전혀 실행할 필요가 없습니다. 이것은 O (1)입니다.

이진 최대 힙을 사용할 수 있습니다. 최소 노드 (알 수 없거나 널일 수 있음)에 대한 포인터를 추적해야합니다.

처음 100 개의 숫자를 힙에 삽입하여 시작합니다. 최대 값이 맨 위에 있습니다. 이 작업이 완료되면 항상 100 개의 숫자를 유지합니다.

그런 다음 새로운 번호를 받으면 :

if(minimumNode == null)
{
    minimumNode = findMinimumNode();
}
if(newNumber > minimumNode.Value)
{
    heap.Remove(minimumNode);
    minimumNode = null;
    heap.Insert(newNumber);
}

불행히도 findMinimumNodeO (n)이며 인서트 당 한 번만 비용이 발생합니다 (그러나 인서트 중은 아님). 최소 노드를 제거하고 새 노드를 삽입하는 것은 평균적으로 힙의 맨 아래로 향하기 때문에 O (1)입니다.

Binary Min-Heap을 사용하여 다른 방법으로 갈 때, min은 맨 위에 있으며, 비교할 min을 찾는 데는 좋지만 min을> min 인 새 숫자로 바꿔야 할 때 짜증이납니다. 최소 노드를 제거하고 (항상 O (logN)) 새 노드를 삽입해야합니다 (평균 O (1)). 따라서 여전히 Max-Heap보다 우수하지만 O (1)이 아닌 O (logN)이 있습니다.

물론 N이 일정하면 항상 O (1)이됩니다. :)