【面试题】合并二维数组里的每一行（有序的）为一个新的有序数组。

合并多个升序数组

方法1：归并排序

package main

import "fmt"

func main() {
	arrs := [][]int{
		{1, 2},
		{5, 6, 7},
		{3, 4},
	}

	res := mergeArrays(arrs)
	fmt.Println(res)
}

func mergeArrays(arrs [][]int) []int {
	n := len(arrs)
	if n == 0 {
		return nil
	}

	if n == 1 {
		return arrs[0]
	}

	mid := n / 2
	left := mergeArrays(arrs[:mid])
	right := mergeArrays(arrs[mid:])
	return merge(left, right)
}

func merge(arr1, arr2 []int) []int {
	m, n := len(arr1), len(arr2)
	i, j, k := 0, 0, 0
	res := make([]int, m+n)

	for i < m && j < n {
		if arr1[i] < arr2[j] {
			res[k] = arr1[i]
			i++
		} else {
			res[k] = arr2[j]
			j++
		}
		k++
	}

	for i < m {
		res[k] = arr1[i]
		i++
		k++
	}
	for j < n {
		res[k] = arr2[j]
		j++
		k++
	}

	return res

}

方法2：最小堆

// node的结构体，表示一个值为val，属于第row个数组，第col个位置的元素。
type node struct {
	val int
	row int
	col int
}

func mergeArrays(arrs [][]int) []int {
	var res []int

	// 定义一个小根堆
	var heap []node
	for i := 0; i < len(arrs); i++ {
		// 遍历每个输入数组，将每个数组的第一个元素加入到heap中。
		head := arrs[i]
		heap = append(heap, node{head[0], i, 0})
	}

	//fmt.Println(heap)
	/*
		重复以下步骤，直到heap为空：
			将heap的第一个元素（即最小元素）加入到res中
			如果该元素的所属数组还有剩余元素，则将其下一个元素加入到heap中
			维护heap的性质，使其始终是一个小根堆。
	*/
	for len(heap) > 0 {
		temp := heap[0]
		res = append(res, temp.val)
		heap = heap[1:]

		if temp.col < len(arrs[temp.row])-1 {
			heap = append(heap, node{arrs[temp.row][temp.col+1], temp.row, temp.col + 1})
		}

		// 每次都维护堆的性质
		for i := len(heap)/2 - 1; i >= 0; i-- {
			heapify(heap, i)
		}
	}

	return res
}

func heapify(heap []node, i int) {
	minIndex := i
	left := 2*i + 1
	right := 2*i + 2

	if left < len(heap) && heap[left].val < heap[minIndex].val {
		minIndex = left
	}
	if right < len(heap) && heap[right].val < heap[minIndex].val {
		minIndex = right
	}
	if i != minIndex {
		heap[i], heap[minIndex] = heap[minIndex], heap[i]
		heapify(heap, minIndex)
	}
}

func main() {
	arrs := [][]int{
		{1, 2, 7, 9},
		{5, 6},
		{3},
		{4, 8},
	}
	res := mergeArrays(arrs)
	fmt.Println(res)
}