311-golang排序算法

主要的排序算法有:
1.冒泡
2.选择
3.插入
4.快速排序
5.希尔排序
6.堆排序
7.归并排序
8.计数排序等等




1.
先来看下冒泡排序

	arr := []int{3, 5, 4, 1, 2}

	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
	}

	fmt.Println(arr)







2.
然后看下选择排序

	arr := []int{3, 5, 4, 1, 2}

	for i := 0; i < len(arr); i++ {

		temp := i

		for j := i; j < len(arr); j++ {
			if arr[temp] > arr[j] {
				temp = j
			}
		}

		arr[i], arr[temp] = arr[temp], arr[i]
	}

	fmt.Println(arr)










3.
然后看下插入法

	arr := []int{3, 5, 4, 1, 2}

	for i := 1; i < len(arr); i++ {
		for j := i; j >= 1; j-- {
			if arr[j-1] > arr[j] {
				arr[j-1], arr[j] = arr[j], arr[j-1]
			}
		}

	}

	fmt.Println(arr)









4.
快速排序

// 第一种写法
func quickSort(values []int, left, right int) {
    temp := values[left]
    p := left
    i, j := left, right
 
    for i <= j {
        for j >= p && values[j] >= temp {
            j--
        }
        if j >= p {
            values[p] = values[j]
            p = j
        }
 
        for values[i] <= temp && i <= p {
            i++
        }
        if i <= p {
            values[p] = values[i]
            p = i
        }
    }
    values[p] = temp
    if p-left > 1 {
        quickSort(values, left, p-1)
    }
    if right-p > 1 {
        quickSort(values, p+1, right)
    }
}
 
func QuickSort(values []int) {
    if len(values) <= 1 {
        return
    }
    quickSort(values, 0, len(values)-1)
}
 
// 第二种写法
func Quick2Sort(values []int) {
    if len(values) <= 1 {
        return
    }
    mid, i := values[0], 1
    head, tail := 0, len(values)-1
    for head < tail {
        fmt.Println(values)
        if values[i] > mid {
            values[i], values[tail] = values[tail], values[i]
            tail--
        } else {
            values[i], values[head] = values[head], values[i]
            head++
            i++
        }
    }
    values[head] = mid
    Quick2Sort(values[:head])
    Quick2Sort(values[head+1:])
}
 
// 第三种写法
func Quick3Sort(a []int,left int, right int)  {
 
    if left >= right {
        return
    }
 
    explodeIndex := left
 
    for i := left + 1; i <= right ; i++ {
 
        if a[left] >= a[i]{
 
            //分割位定位++
            explodeIndex ++;
            a[i],a[explodeIndex] = a[explodeIndex],a[i]
 
 
        }
 
    }
 
    //起始位和分割位
    a[left], a[explodeIndex] = a[explodeIndex],a[left]
 
    Quick3Sort(a,left,explodeIndex - 1)
    Quick3Sort(a,explodeIndex + 1,right)
 
}








5.
希尔排序

	arr := []int{3, 5, 4, 1, 2}

	//希尔排序
	d := len(arr)
	for ; ; {
		d = d / 2
		for x := 0; x < d; x++ {
			for i := x + d; i < len(arr); i = i + d {
				temp := arr[i]
				j := 0
				for j = i - d; j >= 0 && arr[j] > temp; j = j - d {
					arr[j+d] = arr[j]
				}
				arr[j+d] = temp
			}
		}
		if d == 1 {
			break;
		}
	}

	fmt.Println(arr)