堆结构求中位数

最新推荐文章于 2024-01-06 00:10:56 发布

原创最新推荐文章于 2024-01-06 00:10:56 发布 · 491 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java 堆结构

算法专栏收录该内容

15 篇文章

订阅专栏

博客围绕Java堆结构展开，虽暂无具体内容，但可知核心聚焦于Java堆结构这一信息技术领域的关键概念，其在Java编程中有着重要作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * 堆结构实时求中位数
 */
public class Test02ByMedian {
    @Test
    public void test(){
        int [] arr={9,75,6,4,3};
        System.out.println(go(arr));
    }

    public int go(int []arr){
        int [] bigHeap=new int[arr.length];
        int [] smallHeap=new int[arr.length];
        int bigsize=0;
        int smallsize=0;
        for(int i=0;i<arr.length;i++){
            if(i==0 || arr[i]<=bigHeap[0]){
                getBigHeap(bigHeap,arr[i],bigsize);
                bigsize++;
            }else {
                getsmallHeap(smallHeap,arr[i],smallsize);
                smallsize++;
            }
            if(Math.abs(bigsize-smallsize)>1){
                if(bigsize>smallsize){
                    getsmallHeap(smallHeap,bigHeap[0],smallsize);
                    smallsize++;
                    swap(bigHeap,0,bigsize-1);
                    bigsize--;
                    heapfy(bigHeap,bigsize);
                }else {
                    getBigHeap(bigHeap,smallHeap[0],bigsize);
                    bigsize++;
                    swap(smallHeap,0,smallsize-1);
                    smallsize--;
                    heapfy1(smallHeap,smallsize);
                }
            }
        }
        if(bigsize>smallsize){
            return bigHeap[0];
        }else if(smallsize>bigsize){
            return smallHeap[0];
        }else {
            return (bigHeap[0]+smallHeap[0])/2;
        }
    }

    private void heapfy1(int[] smallHeap,int size) {
        for(int i=0;i<size;i++) {
            int left = i * 2 + 1;
            if (left < size) {
                int min=left+1<size?(smallHeap[left]<smallHeap[left+1]?left:left+1):left;
                if(smallHeap[i]<=smallHeap[min]){
                    break;
                }
                swap(smallHeap,i,min);
            }
        }
    }

    private void heapfy(int[] bigHeap,int size) {
        for(int i=0;i<size;i++){
            int left=i*2+1;
            if(left<size){
                int maxid=left+1<size?(bigHeap[left]>bigHeap[left+1]?left:left+1):left;
                if(bigHeap[i]>=bigHeap[maxid]){
                    break;
                }
                swap(bigHeap,i,maxid);
            }
        }
    }

    private void getsmallHeap(int[] smallHeap, int i, int smallsize) {
        smallHeap[smallsize]=i;
        while (smallHeap[smallsize]<smallHeap[(smallsize-1)/2]){
            swap(smallHeap, (smallsize-1)/2, smallsize);
        }
    }

    private void getBigHeap(int[] bigHeap, int i, int bigsize) {
        bigHeap[bigsize]=i;
        if(bigsize!=0){
            while (bigHeap[bigsize]>bigHeap[(bigsize-1)/2]){
                swap(bigHeap, (bigsize-1)/2, bigsize);
            }
        }
    }
    public void swap(int []arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}