数据结构与算法之BFPRT算法

傷城~ 2021-12-17 01:25 248阅读 0赞

# 数据结构与算法之BFPRT算法 #

--------------------

## 目录 ##

1.  BFPRT算法介绍
2.  BFPRT算法代码实现

--------------------

### 1. BFPRT算法介绍 ###

> 引用自博客：BFPRT算法O(n)解决第k小的数：[https://www.jianshu.com/p/a43b0e1712d1][https_www.jianshu.com_p_a43b0e1712d1]

**在一大堆数中求其前k大或前k小的问题，简称TOP-K问题。而目前解决TOP-K问题最有效的算法即是BFPRT算法，其又称为中位数的中位数算法，该算法由Blum、Floyd、Pratt、Rivest、Tarjan提出，最坏时间复杂度为O(n)。**

我们通常会简单地进行一个快速排序后，得到第k个位置上的数字即可。  
我们都知道的是快速排序是个不稳定的排序，它的排序过程简单的理解主要是两个概念Partion,pivot(基准数)

一趟快速排序的过程如下：

1.  先从序列中选取一个数作为基准数
2.  将比这个数大的数全部放到它的右边，把小于或者等于它的数全部放到它的左边

一趟快速排序也叫做Partion，即将序列划分为两部分，一部分比基准数小，另一部分比基准数大，然后再进行分治过程，因为每一次Partion不一定都能保证划分得很均匀，所以最坏情况下的时间复杂度不能保证总是O(nlogn)的。

--------------------

##### BFPRT算法 #####

1.  在BFPTR算法中，仅仅是改变了快速排序Partion中的pivot值的选取，在快速排序中，我们始终选择第一个元素或者最后一个元素作为pivot，而在BFPTR算法中，每次选择五分中位数的中位数作为pivot，这样做的目的就是使得划分比较合理，从而避免了最坏情况的发生。
2.  算法步骤如下  
    （1）将输入数组的n个元素划分为n/5组，每组5个元素，且至多只有一个组由剩下的n%5个元素组成。  
    （2）寻找n/5个组中每一个组的中位数，首先对每组的元素进行插入排序，然后从排序过的序列中选出中位数。  
    （3）对于（2）中找出的n/5个中位数，递归进行步骤（1）和（2），直到只剩下一个数即为这n/5个元素的中位数，找到中位数后并找到对应的下标p。  
    （4）进行Partion划分过程，Partion划分中的pivot元素下标为p。  
    （5）进行高低区判断即可。
3.  本算法的最坏时间复杂度为O(n)，值得注意的是通过BFPTR算法将数组按第K小（大）的元素划分为两部分，而  
    这高低两部分不一定是有序的，通常我们也不需要求出顺序，而只需要求出前K大的或者前K小的。

--------------------

### 2. BFPRT算法代码实现 ###

附上堆排序下找k小的值和BFPRT算法的代码实现

public class Code_06_BFPRT {
        
    
    	// O(N*logK)
    	public static int[] getMinKNumsByHeap(int[] arr, int k) {
        
    		if (k < 1 || k > arr.length) {
        
    			return arr;
    		}
    		int[] kHeap = new int[k];
    		for (int i = 0; i != k; i++) {
        
    			heapInsert(kHeap, arr[i], i);
    		}
    		for (int i = k; i != arr.length; i++) {
        
    			if (arr[i] < kHeap[0]) {
        
    				kHeap[0] = arr[i];
    				heapify(kHeap, 0, k);
    			}
    		}
    		return kHeap;
    	}
    
    	public static void heapInsert(int[] arr, int value, int index) {
        
    		arr[index] = value;
    		while (index != 0) {
        
    			int parent = (index - 1) / 2;
    			if (arr[parent] < arr[index]) {
        
    				swap(arr, parent, index);
    				index = parent;
    			} else {
        
    				break;
    			}
    		}
    	}
    
    	public static void heapify(int[] arr, int index, int heapSize) {
        
    		int left = index * 2 + 1;
    		int right = index * 2 + 2;
    		int largest = index;
    		while (left < heapSize) {
        
    			if (arr[left] > arr[index]) {
        
    				largest = left;
    			}
    			if (right < heapSize && arr[right] > arr[largest]) {
        
    				largest = right;
    			}
    			if (largest != index) {
        
    				swap(arr, largest, index);
    			} else {
        
    				break;
    			}
    			index = largest;
    			left = index * 2 + 1;
    			right = index * 2 + 2;
    		}
    	}
    
    	// O(N)
    	public static int[] getMinKNumsByBFPRT(int[] arr, int k) {
        
    		if (k < 1 || k > arr.length) {
        
    			return arr;
    		}
    		int minKth = getMinKthByBFPRT(arr, k);
    		int[] res = new int[k];
    		int index = 0;
    		for (int i = 0; i != arr.length; i++) {
        
    			if (arr[i] < minKth) {
        
    				res[index++] = arr[i];
    			}
    		}
    		for (; index != res.length; index++) {
        
    			res[index] = minKth;
    		}
    		return res;
    	}
    
    	public static int getMinKthByBFPRT(int[] arr, int K) {
        
    		int[] copyArr = copyArray(arr);
    		return select(copyArr, 0, copyArr.length - 1, K - 1);
    	}
    
    	public static int[] copyArray(int[] arr) {
        
    		int[] res = new int[arr.length];
    		for (int i = 0; i != res.length; i++) {
        
    			res[i] = arr[i];
    		}
    		return res;
    	}
    
    	public static int select(int[] arr, int begin, int end, int i) {
        
    		if (begin == end) {
        
    			return arr[begin];
    		}
    		int pivot = medianOfMedians(arr, begin, end);
    		int[] pivotRange = partition(arr, begin, end, pivot);
    		if (i >= pivotRange[0] && i <= pivotRange[1]) {
        
    			return arr[i];
    		} else if (i < pivotRange[0]) {
        
    			return select(arr, begin, pivotRange[0] - 1, i);
    		} else {
        
    			return select(arr, pivotRange[1] + 1, end, i);
    		}
    	}
    
    	public static int medianOfMedians(int[] arr, int begin, int end) {
        
    		int num = end - begin + 1;
    		int offset = num % 5 == 0 ? 0 : 1;
    		int[] mArr = new int[num / 5 + offset];
    		for (int i = 0; i < mArr.length; i++) {
        
    			int beginI = begin + i * 5;
    			int endI = beginI + 4;
    			mArr[i] = getMedian(arr, beginI, Math.min(end, endI));
    		}
    		return select(mArr, 0, mArr.length - 1, mArr.length / 2);
    	}
    
    	public static int[] partition(int[] arr, int begin, int end, int pivotValue) {
        
    		int small = begin - 1;
    		int cur = begin;
    		int big = end + 1;
    		while (cur != big) {
        
    			if (arr[cur] < pivotValue) {
        
    				swap(arr, ++small, cur++);
    			} else if (arr[cur] > pivotValue) {
        
    				swap(arr, cur, --big);
    			} else {
        
    				cur++;
    			}
    		}
    		int[] range = new int[2];
    		range[0] = small + 1;
    		range[1] = big - 1;
    		return range;
    	}
    
    	public static int getMedian(int[] arr, int begin, int end) {
        
    		insertionSort(arr, begin, end);
    		int sum = end + begin;
    		int mid = (sum / 2) + (sum % 2);
    		return arr[mid];
    	}
    
    	public static void insertionSort(int[] arr, int begin, int end) {
        
    		for (int i = begin + 1; i != end + 1; i++) {
        
    			for (int j = i; j != begin; j--) {
        
    				if (arr[j - 1] > arr[j]) {
        
    					swap(arr, j - 1, j);
    				} else {
        
    					break;
    				}
    			}
    		}
    	}
    
    	public static void swap(int[] arr, int index1, int index2) {
        
    		int tmp = arr[index1];
    		arr[index1] = arr[index2];
    		arr[index2] = tmp;
    	}
    
    	public static void printArray(int[] arr) {
        
    		for (int i = 0; i != arr.length; i++) {
        
    			System.out.print(arr[i] + " ");
    		}
    		System.out.println();
    	}
    
    	public static void main(String[] args) {
        
    		int[] arr = {
         6, 9, 1, 3, 1, 2, 2, 5, 6, 1, 3, 5, 9, 7, 2, 5, 6, 1, 9 };
    		// sorted : { 1, 1, 1, 1, 2, 2, 2, 3, 3, 5, 5, 5, 6, 6, 6, 7, 9, 9, 9 }
    		printArray(getMinKNumsByHeap(arr, 10));
    		printArray(getMinKNumsByBFPRT(arr, 10));
    	}
    }

[https_www.jianshu.com_p_a43b0e1712d1]: https://www.jianshu.com/p/a43b0e1712d1