第十三章:Go语言基础排序程序

golang-gopher.png

程序需要实现的基础功能

• 程序能从命令行读取命令,输入的数据文件,排序之后的输出文件,使用的排序算法
• 读取文件中的数据
• 调用指定的排序算法
• 将排序之后的数据写入到输出文件中
• 计算排序耗时

目录结构

|
|__sorter

|__bubbleSort

|____bubbleSort.go

|____bubbleSort_test.go

|__quickSort

|____quickSort.go

|____quickSort_test.go

|__main.go

bubbleSort.go

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

bubbleSort_test.go

package bubbleSort

import "testing"

// 单元测试1 冒泡排序
func TestBubbleSort1(t *testing.T) {
    values := []int{9, 8, 7, 6}
    BubbleSort(values)
    if values[0] != 6 || values[1] != 7 || values[2] != 8 || values[3] != 9 {
        t.Error("BubbleSort() failed", values)
    }
}
// 单元测试3
func TestBubbleSort2(t *testing.T) {
    values := []int{9, 7, 7, 6}
    BubbleSort(values)
    if values[0] != 6 || values[1] != 7 || values[2] != 7 || values[3] != 9 {
        t.Error("BubbleSort() failed", values)
    }
}
// 单元测试3
func TestBubbleSort3(t *testing.T) {
    values := []int{9}
    BubbleSort(values)
    if values[0] != 9 {
        t.Error("BubbleSort() failed", values)
    }
}

quickSort.go

package quickSort
// 快速排序
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 i <= p && values[i] <= temp {
            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)
}

quickSort_test.go

package quickSort

import "testing"
// 单元测试 快速排序
func TestQuickSort1(t *testing.T) {
    values := []int{9, 8, 7, 6}
    QuickSort(values)
    if values[0] != 6 || values[1] != 7 || values[2] != 8 || values[3] != 9 {
        t.Error("BubbleSort() failed", values)
    }
}
func TestQuickSort2(t *testing.T) {
    values := []int{9, 8, 8, 6}
    QuickSort(values)
    if values[0] != 6 || values[1] != 8 || values[2] != 8 || values[3] != 9 {
        t.Error("BubbleSort() failed", values)
    }
}
func TestQuickSort3(t *testing.T) {
    values := []int{6}
    QuickSort(values)
    if values[0] != 6 {
        t.Error("BubbleSort() failed", values)
    }
}

sorter.go

package main

import (
    "GoNote/chapter6/sorter/bubbleSort"
    "GoNote/chapter6/sorter/quickSort"
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
    "strconv"
    "time"
)

// 使用flag包接收命令行参数
var infile *string = flag.String("i", "infile", "file contents values for sorting")
var outfile *string = flag.String("o", "outfile", "file to receive values sorted values")
var algorithm *string = flag.String("a", "quick or bubble", "sort algorithm")

// 从文件中读取需要排序的内容,转为整型,添加到一个切片中
func readValues(infile string) (values []int, err error) {
    file, err := os.Open(infile)
    if err != nil {
        fmt.Println(err, 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 {
            fmt.Println("A too long line, seems unexpected")
            return
        }
        str := string(line)
        if str == "" {
            continue
        }
        value, err2 := strconv.Atoi(str)
        if err2 != nil {
            err = err2
            return
        }
        values = append(values, value)
    }
    return
}

// 将排序之后的数据写入文件中
func writeValue(values []int, outfile string) error {
    file, err := os.Create(outfile)
    if err != nil {
        return err
    }
    defer file.Close()
    for _, v := range values {
        str := strconv.Itoa(v)
        file.WriteString(str + "\n")
    }
    return nil
}

func main() {
    flag.Parse()
    if infile != nil {
        fmt.Println(*infile, *outfile, *algorithm)
    }
    values, err := readValues(*infile)
    if err == nil {
        start := time.Now()
        switch *algorithm {
        case "quick":
            quickSort.QuickSort(values)
        case "bubble":
            bubbleSort.BubbleSort(values)
        default:
            fmt.Println("sorting algorithm", *algorithm, "is unknow")
        }
        end := time.Now()
        fmt.Println("the program is cost : ", end.Sub(start), " to complete")
        writeValue(values, *outfile)
    } else {
        fmt.Println(err)
    }
}

通过如下命令执行程序

$ go run sorter.go -i in.txt -o out.txt -a bubble