1.氣泡排序

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func bubble_sort(arr []int){
	var flag bool
	for i:=0;i<len(arr)-1;i++{
		flag = true
		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]
				flag = false
			}
		}
		if flag{
			break
		}
	}
}

func main(){
	arr := make([]int, 10)
	rand.Seed(time.Now().UnixNano())
	for i:=0;i<len(arr);i++{
		arr[i] = rand.Intn(100)
	}
	fmt.Println("排序前", arr)
	bubble_sort(arr)
	fmt.Println("排序後", arr)
}

2.選擇排序

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func select_sort(arr []int){
	//先假設第一個元素為最小，讓後面的元素和第一個進行比較，如果大了就進行交換
	//然後假設第二個元素為第二小，依次類推
	for i:=0;i<len(arr)-1;i++{
		for j:=i+1;j<len(arr);j++{
			if arr[j] < arr[i]{
				arr[i],arr[j] = arr[j],arr[i]
			}
		}
	}
}


func main(){
	arr := make([]int, 10)
	rand.Seed(time.Now().UnixNano())
	for i:=0;i<len(arr);i++{
		arr[i] = rand.Intn(100)
	}
	fmt.Println("排序前", arr)
	select_sort(arr)
	fmt.Println("排序後", arr)
}

3.插入排序

package main

import (
	"fmt"
	"math/rand"
	"time"
)

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

func main(){
	arr := make([]int, 10)
	rand.Seed(time.Now().UnixNano())
	for i:=0;i<len(arr);i++{
		arr[i] = rand.Intn(100)
	}
	fmt.Println("排序前", arr)
	insert_sort(arr)
	fmt.Println("排序後", arr)
}

4.選擇排序

package main

import (
	"fmt"
	"math/rand"
	"time"
)

/*
快速排序原理：
先選擇一個數，進行排序，使得左邊的數比它小，右邊的數比它大
如何實現：想象兩個指標，一個從左往右走，另一個從右往左走
先從最右邊開始走，如果大的話就繼續向左走，當比選擇的數小的話，就讓右指標等於左指標此時所指的數，此時兩個數一樣
然後從左往右開始走，如果小的話就繼續往右走，當比選擇的數大的話，就讓左指標等於右指標此時所指的數，此時兩個數右一樣，但是之前相等的數字換回來了
然後再從右邊開始找，滿足條件繼續交換，然後從左邊開始找
直到使得左邊的數比選擇的數字小，右邊比選擇的數字大，但是這樣肯定會多出來一個重複的指，所以最後再交換回來。
然後以選擇的數字為基準，相當於左右又分成了兩個陣列。看到這，應該想到了，使用遞迴，不斷分割，直至無法分割的時候，那麼陣列的順序便排好了。
 */

func partition(arr []int, left, right int)int{
	//我們選擇數字就從左往右選擇，先找個變數把值存起來
	tmp := arr[left]
	for left < right{
		//先從右指標開始，當left小於right並且右邊的數字比選擇的數字大的時候，繼續往左走
		for left < right && arr[right] > tmp{
			right -= 1
		}
		//如果右邊的數字比選擇的數字小，那麼就讓左指標指的數等於右指標所指的數
		arr[left] = arr[right]

		//然後輪到左指標，當left小於right並且左邊的數字比選擇的數字小的時候，繼續右左走
		for left < right && arr[left] < tmp{
			left += 1
		}
		//如果左邊的數字比選擇的數字大，那麼就讓右指標指的數等於左指標指的數
		arr[right] = arr[left]
	}
	//以上不斷迴圈，便會交換完畢，但是會多出來一個重複的指，所以再交換回去
	arr[left] = tmp
	return left
}

func quick_sort(arr []int,left,right int){
	if left < right{
		mid := partition(arr, left, right)
		//找到了mid，也就是那個最終選擇的數字的索引，然後遞迴
		quick_sort(arr, left, mid-1)
		quick_sort(arr, mid+1, right)
	}
}

func main(){
	arr := make([]int, 10)
	rand.Seed(time.Now().UnixNano())
	for i:=0;i<len(arr);i++{
		arr[i] = rand.Intn(100)
	}
	fmt.Println("排序前", arr)
	quick_sort(arr, 0 , len(arr)-1)
	fmt.Println("排序後", arr)
}