Go & Python 归并排序

归并排序

分别使用go & python 语言进行 归并排序

1、分治法

分治模式 是将原问题分解成几个规模较小的但类似于原问题的子问题， 递归求解这些子问题，然后在合并这些子问题的解来建立原问题的解

通常分为3个步骤:
分解：原问题分解为若干子问题
解决：递归求解各个子问题
合并：合并子问题成为原问题的解决

2、归并排序

归并排序在在结构上是递归，通过多次递归的调用自身解决排序问题。完全遵循分治模式

分解：分解n个元素的序列为各具n/2个元素的子序列
解决：使用归并排序递归的排序两个子序列
合并：合并两个已排序的子序列，形成新的序列

3、Code实现

1) Go

package main

import "fmt"

// count count
var count int

func main() {
	fmt.Println("< === merge sort === >")
	slice := []int{3, 7, 2, 4, 1, 6, 32, 5, 7, 17, 9, 8, 13, 21, 4}
	fmt.Println("test: ", slice[0:0], slice[0:1])
	fmt.Printf("BaseSlice: %v\n", slice)
	// BaseMerge(&slice, slice, 0, int(len(slice)/2), len(slice))
	MergeSort(slice, 0, len(slice)-1)
	fmt.Println("MergeSort: ", slice)
	fmt.Println("Count: ", count)
}

// MergeSort MergeSort
func MergeSort(slice []int, p int, r int) {
	q := int((p + r) / 2)
	if p < r {
		baseSlice := make([]int, r+1)
		if p < q && q < r {

			MergeSort(slice, p, q)
			MergeSort(slice, q, r)
		}
		copy(baseSlice, slice)
		BaseMerge(slice, baseSlice, p, q, r)
		count += 1
	}
}

// BaseMerge base func for merge
func BaseMerge(slice []int, baseSlice []int, p int, q int, r int) {
	n1 := q - p
	n2 := r - q

	sliceA := baseSlice[p : q]
	sliceB := baseSlice[q : r]
	i := 0
	j := 0

	fmt.Printf("PQR: %d %d %d\n", p, q, r)
	fmt.Printf("BaseSlice: %v\n", baseSlice)
	fmt.Printf("SliceA: %v \t SliceB: %v\n", sliceA, sliceB)
	for k := p; k < r; k++ {
		if i >= n1 {
			slice[k] = sliceB[j]
			j++
			continue
		}
		if j >= n2 {
			slice[k] = sliceA[i]
			i++
			continue
		}
		if sliceA[i] >= sliceB[j] {
			slice[k] = sliceB[j]
			j++
		} else {
			slice[k] = sliceA[i]
			i++
		}
	}

	fmt.Println("Slice: ", slice)

}

1) Pyhton

# -*- coding: utf-8 -*-

import math
import random


class MergeSort():

    def __init__(self, base_data):
        assert isinstance(base_data, list)
        self.base_data = base_data

    def merge_sort(self):
        self.merge_list(0, len(base_data))
        return self.base_data

    def merge_list(self, p, r):
        # 分组
        if r>p:
            q = int((p+r)/2)
            if p<q<r:
                self.merge_list(p, q)
                self.merge_list(q, r)
            # 合并
            self._base_merge(p, q, r)

    def _base_merge(self, p, q, r):
        base_data_1 = self.base_data[p:q]
        base_data_2 = self.base_data[q:r]
        j = 0
        k = 0
        for i in range(p, r):
            if len(base_data_1) <= j:
                self.base_data[i] = base_data_2[k]
                k+=1
            elif len(base_data_2) <= k:
                self.base_data[i]=base_data_1[j]
                j+=1
            elif base_data_1[j] > base_data_2[k]:
                self.base_data[i] = base_data_2[k]
                k += 1
            else:
                self.base_data[i]=base_data_1[j]
                j += 1


if __name__ == "__main__":
    # 生成随机序列
    base_data = [random.randint(0, 99) for _ in range(32)]
    print("BaseDate: ", base_data)
    # 开始排序
    sort_data = MergeSort(base_data).merge_sort()
    print("SortDate: ", sort_data)