ICODING--数组合并

题目描述：

数组合并

假设有 n 个长度为 k 的已排好序（升序）的数组，请设计数据结构和算法，将这 n 个数组合并到一个数组，且各元素按升序排列。即实现函数：

 void merge_arrays(const int* arr, int n, int k, int* output);

其中 arr 为按行优先保存的 n 个长度都为 k 的数组，output 为合并后的按升序排列的数组，大小为 n×k。

时间要求(评分规则)，当 n > k 时：

• 满分：时间复杂度不超过 O(n×k×log(n))
• 75分：时间复杂度不超过 O(n×k×log(n)×k)
• 59分：其它，如：时间复杂度为 O(n2×k2) 时。

这道题调了好久，分享出来供大家交流。

主要思路是利用小根堆来实现：

1.将每个小的有序数组的第一个元素放入堆内进行堆排

2.将堆顶的最小元素M放入输出数组中

3.若该元素M不是该小数组的最后一个元素，则把该小数组的下一个元素加入堆内；反之，则将该元素M与堆内最后一个元素互换，然后将堆的大小减一（除去该元素）

4.对2和3进行n*k次实现便完成了对该局部有序数组的排序，时间复杂度是O(n×k×log(n))

代码部分：

/*
 * 完成人　：HZR
 * 完成时间：2021-06-27, Sun, 19:33:01
 * 系统评分：100
 */

#include<stdio.h>
#include<stdlib.h>

typedef struct _minHeapNode
{
    int value;
    int a;//第a个数组 
	int b; //第a个数组中第b个元素 
}MinHeapNode, *PMinHeapNode;

typedef struct _minPQ {
    PMinHeapNode heap_array; // 指向堆元素数组 
    int heap_size; // 当前堆中的元素个数
    int capacity;  //堆数组的大小
}MinHeap, *PMinHeap;

int parent(int i){
	if(i%2==0){
		return i/2-1;
	}
	else{
		return i/2;
	}
}
int left(int i){
	return 2*i+1;
}
int right(int i){
	return 2*i+2;
}
void swap_node(MinHeapNode *x, MinHeapNode *y){
	int t;
	t=x->value;//交换value 
	x->value=y->value;
	y->value=t;
	t=x->a;//交换a 
	x->a=y->a;
	y->a=t;
	t=x->b;//交换b 
	x->b=y->b;
	y->b=t;
	return;
}

void init_min_heap(PMinHeap pq, int capacity){
    //初始化一个堆 
	pq->capacity=capacity;
	pq->heap_size=0;
	pq->heap_array=(PMinHeapNode)malloc(sizeof(MinHeapNode)*capacity);
	return;
}

bool heap_insert_value(PMinHeap pq, int value,int a,int b){    //插入一个新元素 
	int i=pq->heap_size,t; 
	if(i>=pq->capacity)
	return false;
	t=parent(i); 
	pq->heap_array[i].value=value;
	pq->heap_array[i].a=a;
	pq->heap_array[i].b=b;
	while(1){
		if(value<pq->heap_array[t].value){
			swap_node(&(pq->heap_array[t]),&(pq->heap_array[i]));
			i=t;
			t=parent(t); 
		}
		else {
			pq->heap_size++;
			break;
		}
	}
	return true;
}

int min(int l,int r){
	if(l<r) return l;
	else return r;
}

void min_heapify(PMinHeap pq, int i){  //将只有第i个不符合要求的堆重新堆化 
	int minode;  //minode为有叶节点的最大非叶节点的序号 
	if((pq->heap_size-1)%2==0){   //定义的树的标号不是从1开始，而是从0，所以求其父节点的方法有所差别 
		minode=(pq->heap_size-1)/2-1;
	}
	else{
		minode=(pq->heap_size-1)/2;
	}
	while(i<=minode){
		int l=left(i),r=right(i),minx;
		int lv=pq->heap_array[l].value;
		if(r==pq->heap_size){
			if(pq->heap_array[i].value>lv){
			swap_node(&(pq->heap_array[i]),&(pq->heap_array[l]));
			}
			break;
		} 
		int rv=pq->heap_array[r].value;
		minx=min(lv,rv);
		if(pq->heap_array[i].value>minx){
			if(lv<rv){
				swap_node(&(pq->heap_array[i]),&(pq->heap_array[l]));
				i=l;
			}
			else{
				swap_node(&(pq->heap_array[i]),&(pq->heap_array[r]));
				i=r;
			}
		}
		else{
			break;
		}
	}
	return;
}

void merge_arrays(const int* arr, int n, int k, int* output){
	PMinHeap pq;
	pq=(PMinHeap)malloc(sizeof(MinHeap));
	init_min_heap(pq,n*k);//这里申请的空间大小按理来说n就够，但是时间过不了，非常迷
	int sum=0;
	for(int i=1;i<=n;i++){
		heap_insert_value(pq,arr[sum],i,1);
		sum+=k;
	}
	for(int i=0;i<n*k;i++){
		output[i]=pq->heap_array[0].value;
		int a,b;
		a=pq->heap_array[0].a;
		b=pq->heap_array[0].b;
		if(b<k){
		pq->heap_array[0].value=arr[(a-1)*k+b];
		pq->heap_array[0].a=a;
		pq->heap_array[0].b=b+1;
		min_heapify(pq,0);
		}
		else{
		    pq->heap_size--;
		    swap_node(&(pq->heap_array[0]),&(pq->heap_array[pq->heap_size]));
		    min_heapify(pq,0);
		}		
	}
	return;	
}