Go语言数据结构和算法(二十一)快速排序

快速排序是一种基于分治算法的排序算法.快速排序通过选择一个元素为枢轴.并围绕所选枢轴对给定数组进行分区.

1.使用场景:

大型数据集:

快速排序算法对于大型数据集很有效.因为其他算法的开销对性能的影响相对显著.

中等程度无序的数据集:

快速排序算法可以快速划分列表并对子列表进行递归排序.

随机排序:

快速排序算法可以是随机的.这意味这它从列表中随机选择一个枢轴元素.

2.实现:

2.1方法:

func QuickSort(array []int) []int {
	low, high := 0, len(array)-1
	if low >= high {
		return nil
	}
	part := partition(array, low, high)
	QuickSort(array[:part])
	QuickSort(array[part+1:])
	return array
}

func partition(array []int, low int, high int) int {
	pivot := array[high]
	i := low - 1
	for j := low; j < high; j++ {
		if array[j] < pivot {
			i++
			array[i], array[j] = array[j], array[i]
		}
	}
	array[i+1], array[high] = array[high], array[i+1]
	return i + 1
}

2.2main函数:

	array := []int{33, 23, 56, 7, 8, 18, 99, 28}
	data.QuickSort(array)
	fmt.Println(array)
}

3.实战:

3.1方法:

	low, high := 0, len(array)-1
	if low >= high {
		return nil
	}
	part := quickSortDesc(array, low, high)
	ArraySort(array[:part])
	ArraySort(array[part+1:])
	return array
}

func quickSortDesc(array []int, low, high int) int {
	pivot := array[high]
	i := low - 1
	for j := low; j < high; j++ {
		if array[j] > pivot {
			i++
			array[i], array[j] = array[j], array[i]
		}
	}
	array[i+1], array[high] = array[high], array[i+1]
	return i + 1
}

3.2main方法:

	array := []int{33, 23, 56, 7, 8, 18, 99, 28}
	data.ArraySort(array)
	fmt.Println(array)
}

4.实战:

4.1方法:

	quickSortIndex(array, 0, len(array)-1)
	hIndex := 0
	for i := len(array) - 1; i >= 0; i-- {
		if array[i] > len(array)-i {
			hIndex++
		} else {
			break
		}
	}
	return hIndex
}

func quickSortIndex(array []int, low int, high int) {
	if low >= high {
		return
	}
	p := partitionIndex(array, low, high)
	quickSortIndex(array, low, p-1)
	quickSortIndex(array, p+1, high)
}

func partitionIndex(array []int, low int, high int) int {
	pivot := array[high]
	i := low - 1
	for j := low; j < high; j++ {
		if array[j] < pivot {
			i++
			array[j], array[i] = array[i], array[j]
		}
	}
	array[i+1], array[high] = array[high], array[i+1]
	return i + 1
}

4.2mian函数:

	array := []int{33, 23, 56, 7, 8, 18, 99, 28}
	res := data.HIndex(array)
	fmt.Println(res)
	fmt.Println(array)
}

5.实战:

5.1方法:

	var res []int
	var tmp []int
	m := make(map[int]int)
	for _, v := range array2 {
		m[v] = 0
	}

	for _, v := range array1 {
		_, ok := m[v]
		if ok {
			m[v]++
		} else {
			tmp = append(tmp, v)
		}
	}

	for _, v := range array2 {
		for m[v] > 0 {
			res = append(res, v)
			m[v]--
		}
	}
	quickSortDesc(tmp, 0, len(tmp)-1)
	res = append(res, tmp...)
	return res
}

5.2main方法:

	array1 := []int{2, 3, 1, 3, 2, 4, 6, 7, 9, 2, 19}
	array2 := []int{2, 1, 4, 3, 9, 6}
	res := data.QuickSortFunc(array1, array2)
	fmt.Println(res)
}

一如既往的原地踏步.

---

---

如果大家喜欢我的分享的话.可以关注我的微信公众号

念何架构之路