go实现冒泡排序和快速排序

项目结构

冒泡排序算法，源文件bubblesort.go

package bubblesort

// 冒泡排序
func BubbleSort(values []int)  {
    for i := 0; i < len(values) - 1; i ++ {
        flag := true
        for j := 0; j < len(values) - i - 1; i ++ {
            if values[j] > values[j + 1] {
                values[j], values[j + 1] = values[j + 1], values[j]
                flag = false
            }

            if flag == true {
                break
            }
        }
    }
}

快速排序算法，源文件qsort.go

package qsort

// 快速排序
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
        }
        if 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)  {
    quickSort(values, 0 , len(values) - 1)
}

主文件main.go

package main

import (
    "flag"
    "os"
    "bufio"
    "io"
    "strconv"
    "time"
    "sorter/algorithms/qsort"
    "sorter/algorithms/bubblesort"
    "fmt"
)

var infile *string = flag.String("i","unsorted.dat","File  contains values of sorting")
var outfile *string = flag.String("o","sorted.dat","File to receive sorted values")
var algorithm *string = flag.String("a","qsort","Sort algorithm")

// 从文件读取值
func readValues(infile string) (values []int, err error){
    file, err := os.Open(infile)
    if err != nil {
        println("Failed to open the input file ", infile)
        return
    }
    defer file.Close()
    br := bufio.NewReader(file)
    values = make([]int, 0)
    for {
        line, isPrefix, err1 := br.ReadLine()
        if err1 != nil {
            if err1 != io.EOF {
                err = err1
            }
            break
        }
        if isPrefix {
            println("A too long line, seems unexpected.")
            return
        }
        str := string(line)//转换字符数组为字符串
        value, err1 := strconv.Atoi(str)
        if err1 != nil {
            err = err1
            return
        }
        values = append(values, value)
    }
    return
}

// 将值写入到文件中
func writeValues(values []int, outfile string) error {
    file, err := os.Create(outfile)
    if err != nil {
        println("Failed to create the ouput file ", outfile)
        return err
    }
    defer file.Close()

    for _, value := range values {
        str := strconv.Itoa(value)
        file.WriteString(str + "\n")
    }
    return nil
}

func main()  {
    flag.Parse()
    if infile != nil {
        println("infile =", *infile,"outfile=", *outfile, "algorithm =", *algorithm)
    }
    values, err := readValues(*infile)
    if err == nil {
        fmt.Println("Read values:%v", values)
        if err == nil {
            t1 := time.Now()
            switch *algorithm {
            case "qsort":
                qsort.QuickSort(values)
            case "bubblesort":
                bubblesort.BubbleSort(values)
            default:
                println("Sorting algorithm", *algorithm, "is either unknown or unsupported.")
            }
            t2 := time.Now()
            println("The sorting process conts", t2.Sub(t1), "to complete.")

            writeValues(values, *outfile)
        }
    }else{
        println(err)
    }
}

排序结果