안전 서비스를 증명 : K의 최소 번호 (자바)

제목 : 입력 n은 정수, 가장 작은 수 k를 찾을 수 있습니다. 4,5,1,6,2,7,3,8 예컨대 8 개의 디지털 입력의 최소 수는 4 인 1,2,3,4-

용액 (N) 알고리즘은 우리가 입력 배열을 수정하는 경우에만 사용할 수있는 O

이전 질문에서, 우리는이 문제를 해결하기 위해 우리는 또한 파티션 함수를 기반으로 수, 영감을 할 수 있습니다. 상기 k 번째 숫자보다 모든 숫자는 어레이의 왼쪽에 위치되도록, 숫자의 k 번째의 배열에 기초하여 조정하는 경우, 제 K 숫자보다 큰 모든 숫자는 어레이의 오른쪽에 위치한다. 이러한 조정으로, 어레이의 왼쪽에있는 k 개의 숫자는 K 작은 숫자이다.

public int partition(int[] arr, int left, int right) {  
        int result = arr[left];  
        if (left > right)  
            return -1;  
  
        while (left < right) {  
            while (left < right && arr[right] >= result) {  
                right--;  
            }  
            arr[left] = arr[right];  
            while (left < right && arr[left] < result) {  
                left++;  
            }  
            arr[right] = arr[left];  
        }  
        arr[left] = result;  
        return left;  
    }  
    public int[] getLeastNumbers(int[] input,int k){  
        if(input.length == 0 || k<= 0)  
            return null;  
        int[] output = new int[k];  
        int start = 0;  
        int end = input.length-1;  
        int index = partition(input,start,end);  
        while(index != k-1){  
            if(index > k-1){  
                end = index -1;  
                index = partition(input,start ,end);  
            }  
            else{  
                start = index+1;  
                index = partition(input,start ,end);  
            }  
        }  
        for(int i = 0;i<k;i++){  
            output[i] = input[i];  
        }  
        return output;  
    }  

용액 2 : 데이터 O (nlogk) 알고리즘 특히 적합한 프로세스 방대한

    우리는 최소한의 번호를 저장할 수있는 크기 K k의 데이터 컨테이너를 만들 수 있습니다, 우리는 입력 n은 정수의 숫자에서 각 시간을 읽습니다. 이미 직접 용기에 읽은 정수 (K) 용기보다 디지털 적은 경우, 컨테이너가 k 개의 숫자 된 경우, 즉, 컨테이너, 다음 우리가 할 수있는 더 이상 삽입 새로운 인물 전체 없습니다 하지만 기존의 번호를 대체합니다. 또한 K의 최대 번호를 확인하고, 최대 정수 값을 비교 삽입 취한다. 최대 전류에 앞서 삽입보다 값이 작 으면 최대 전류는이 수에 의해 대체 된, 삽입되는 값은 종래의 최대 전류를 가능한 한 작은 수의 K보다 크면 정수 중 하나는, 그래서 우리는이 정수를 취소 할 수 있습니다.

    이 데이터 컨테이너는, 우리가 쉽게 최대 힙을 사용하여 생각할 수 있습니다. 최대 스택은 루트 노드의 값은 하위 트리에있는 모든 노드의 값보다 항상 크다. 그래서 우리가 할 수있는 (1) K 번호 O에서 얻어진 최대 값이이 이해는 각각 O (logk) 완전 삭제 및 운영 삽입이 필요합니다.

  public void buildMaxHeap(int[] arr,int lastIndex){  
        for(int i = (lastIndex-1)/2;i>=0;i--){  
            int k = i;  
            while(2*k+1 <= lastIndex){  
                int biggerIndex = 2*k+1;  
                if(biggerIndex <lastIndex){  
                    if(arr[biggerIndex]< arr[biggerIndex+1])  
                        biggerIndex++;  
                }  
                if(arr[k] < arr[biggerIndex]){  
                    swap(arr,k,biggerIndex);  
                    k = biggerIndex;  
                }  
                else  
                    break;  
            }  
        }  
    }  
    public static void swap(int[] arr,int i ,int j){  
        int temp = arr[i];  
        arr[i] = arr[j];  
        arr[j] = temp;  
    }  
    public void heapSort(int[] arr){  
        for(int i = 0;i<arr.length-1;i++){  
            buildMaxHeap(arr,arr.length-i-1);  
            swap(arr,0,arr.length-i-1);  
        }  
    }  
    public void getLeastNumbers(int[] arr,int k){  
        if(arr == null || k<0 || k>arr.length)  
            return;  
        //根据输入数组前k个数简历最大堆  
        //从k+1个数开始与根节点比较  
        //大于根节点，舍去  
        //小于，取代根节点，重建最大堆  
        int[] kArray = Arrays.copyOfRange(arr, 0, k);  
        heapSort(kArray);  
        for(int i = k;i<arr.length;i++){  
            if(arr[i]<kArray[k-1]){  
                kArray[k-1] = arr[i];  
                heapSort(kArray);  
            }  
        }  
        for(int i:kArray)  
            System.out.print(i);  
    }