多线程/多协程快速排序

多线程/多协程快速排序

快速排序

原理略，百度很多

代码实现

package main

import (
	"fmt"
	"sync"
	"time"
)
//分割算法1
func partition1(arr []int, low, high int) int {
	t := arr[low]
	for low < high {
		for low < high && arr[high] > t {
			high--
		}
		arr[low] = arr[high] //将小的往前覆盖，第一个覆盖的是枢纽数据
		for low < high && arr[low] <= t {
			low++
		}
		arr[high] = arr[low] //将大的往后覆盖
	}
	arr[high] = t //将枢纽数据覆盖回去
	return low
}
//分割算法2
func partition2(arr []int, low, high int) int {
	t := arr[low]
	y := low //指向最后一个比t小的数，y++就是第一个比t大的数
	for i := low + 1; i <= high; i++ {
		if arr[i] < t {
			y++
			arr[i], arr[y] = arr[y], arr[i]
		}
	}
	arr[y], arr[low] = arr[low], arr[y]
	fmt.Println(arr, y)
	return y
}
//多协程版本
func SyncQuitSort(arr []int, low, high int) {
	if low >= high {
		return
	}
	mid := partition2(arr, low, high)
	var w sync.WaitGroup
	w.Add(2)
	go func() {
		SyncQuitSort(arr, low, mid-1)
		w.Done()
	}()
	go func() {
		SyncQuitSort(arr, mid+1, high)
		w.Done()
	}()
	w.Wait()
}
//单进程实现版本
func quitSort(arr []int, low, high int) {
	if low >= high {
		return
	}
	mid := partition2(arr, low, high)
	quitSort(arr, low, mid-1)
	quitSort(arr, mid+1, high)
}
func main() {

	arr := []int{10, 7, 54, 2, 35, 76, 0, 41, 121, 3, 4, 3, 3, 21, 11, 1}
	star := time.Now()
	SyncQuitSort(arr, 0, len(arr)-1)
	end := time.Since(star)
	fmt.Printf("Sync st:%v\n", end)
	fmt.Println("sort:", arr)
}

优化建议

这里是一个协程不停的派生出新的协程，这里协程数量没有限制。优化的一个点可以对协程数量限制，当协程数量超过CPU*2个就采用同步的方式。