Go語言入門教程-小案例-基礎排序程序

程序需要實現的基礎功能

• 程序能從命令行讀取命令,輸入的數據文件,排序之後的輸出文件,使用的排序算法
• 讀取文件中的數據
• 調用指定的排序算法
• 將排序之後的數據寫入到輸出文件中
• 計算排序耗時

目錄結構

|
|__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