347. 前 K 个高频元素 Top K Frequent Elements

题目 <https://leetcode-cn.com/problems/top-k-frequent-elements/>

依然是堆

struct HeapNode{
    int val;
    int frequency;
};

struct Heap{
    struct HeapNode *heap_val;
    int len;
    int cap;
};

struct Heap * heap_create(int cap){
    struct Heap *heap = malloc(sizeof(struct Heap));
    heap->len = 0;
    heap->cap = cap;
    heap->heap_val = malloc(sizeof(struct HeapNode) * cap);
    return heap;
}

void heap_push(struct Heap *heap,struct HeapNode *heap_node){
    int child = heap->len,parent;

    parent = (child-1)/2;
    while(child != 0 && heap_node->frequency > heap->heap_val[parent].frequency){
        heap->heap_val[child] = heap->heap_val[parent];
        child = parent;

        parent = (child-1)/2;
    }
    heap->heap_val[child] = *heap_node;
    heap->len++;
}


void heap_pop(struct Heap *heap){
    struct HeapNode heap_node = heap->heap_val[heap->len-1];
    heap->len--;


    int parent = 0,child;
    child = parent*2+1;
    while(child<heap->len){//注意是判断child
        if(child+1 < heap->len && heap->heap_val[child+1].frequency > heap->heap_val[child].frequency){
            child++;
        }

        if(heap->heap_val[child].frequency > heap_node.frequency){
            heap->heap_val[parent] = heap->heap_val[child];
            parent = child;
            child = parent*2+1;
        }else{
            break;
        }
    }
    heap->heap_val[parent] = heap_node;
}

void heap_peek(struct Heap *heap,struct HeapNode *heap_node){
    *heap_node = heap->heap_val[0];
}

void heap_free(struct Heap *heap){
    free(heap->heap_val);
    free(heap);
}


void sort(int *nums,int numsSize){
    int left,right,mid,k;
    mid = 0;left=1,right=numsSize-1;
    if(left>right){
        return;
    }
    while(left<=right){
        while(left<=right&&nums[mid]<nums[right]) right--;
        if(left>right)  break;
        k = nums[mid];
        nums[mid] = nums[right];
        nums[right] = k;
        mid = right;
        right--;
 
        while(left<=right&&nums[mid]>nums[left]) left++;
        if(left>right)  break;
        k = nums[mid];
        nums[mid] = nums[left];
        nums[left] = k;
        mid = left;
        left++;
    }
 
    sort(nums,mid);
    sort(nums+mid+1,numsSize-mid-1);
}

int* topKFrequent(int* nums, int numsSize, int k, int* returnSize){
    sort(nums,numsSize);
    int i,j;

    struct Heap *heap =  heap_create(numsSize);
    struct HeapNode heap_node;
    for(i=0,j=0;i<numsSize;i++){
        if(nums[j] != nums[i]){
            heap_node.val = nums[j];
            heap_node.frequency = i-j;
            heap_push(heap,&heap_node);
            j = i;
        }
    }
    heap_node.val = nums[j];
    heap_node.frequency = i-j;
    heap_push(heap,&heap_node);


    int *returnNums = malloc(sizeof(int) * numsSize);
    int returnLen = 0;
    for(i=0;i<k;i++){
        heap_peek(heap,&heap_node);
        returnNums[returnLen++] = heap_node.val;
        heap_pop(heap);
    }

    heap_free(heap);

    *returnSize = returnLen;
    return returnNums;
}