GO语言（五）项目搭建

<sorter>

|------<src>（手动添加，代码存放处）

　　　　　　　|------sorter.go

　　　　        |------<algorithm>

　　　　　　　　　　　　　　|--------<qsort>

　　　　　　　　　　　　　　　　　　　　　　|-------qsort.go

　　　　　　　　　　　　　　　　　　　　　　|-------qsort_test.go

　　　　　　　　　　　　　　|--------<bubblesort>

　　　　　　　　　　　　　　　　　　　　　   |-------bubblesort.go

　　　　　　　　　　　　　　　　　　　　　　|-------bubblesort_test.go

|------<pkg> (自动生成，保存静态编译文件)

　　|------<bin>(自动生成，保存可执行文件)

[注]

　　<>是目录，*.go是文件;

　　写5个文件，如下：

------------------------------------------------------------------------------------------

[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
     }   

     for i <= p && values[i] <= temp {
       i++
     }
     if i <= p {
       values[p] = values[i]
       p = i
     }
   }
   values[p] = temp
   if p - left >  {
     quickSort(values, left, p-)
   }
   if right - p >  {
     quickSort(values, p+, right)
   }
 }

 func QuickSort(values []int) {
   quickSort(values, , len(values)-)
 }

[qsort_test.go]

 package qsort

 import "testing"

 func TestQuickSort1(t *testing.T) {
   values := []int{,,,,}
   QuickSort(values)
   if values[] !=  || values[] !=  || values[] !=  || values[] !=  || values[] !=  {
     t.Error("QuickSort() failed. Got", values, "Expected 1 2 3 4 5")
   }
 }

[bubblesort.go]

 package bubblesort

 func BubbleSort(values []int) {
   flag := true

   for i:=; i<len(values); i++ {
     flag = true

     for j:=; j<len(values)-i-; j++{
       if values[j] > values[j+] {
         values[j],values[j+] = values[j+],values[j]
         flag = false
       }
     }   

     if(flag == true) {
       break
     }
   }
 }

[bubblesort_test.go]

 package bubblesort

 import "testing"

 func TestBubbleSort1(t *testing.T) {
   values := []int{,,,,}
   BubbleSort(values)
   if values[]!= || values[]!= || values[]!= || values[]!= || values[]!= {
     t.Error("BubbleSort() failed.Got", values, "Expected 1 2 3 4 5.")
   }
 }

[sorter.go]

 package main

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

 var infile *string = flag.String("i", "unsorted.dat", "File contains values for 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 {
     fmt.Println("Failed to open the input file ", infile)
     return
   }

   defer file.Close()

   br := bufio.NewReader(file)
   values = make([]int, )

   for  {
     line, isPrefix, errl := br.ReadLine()

     if errl != nil {
       if errl != io.EOF {
         err = errl
       }
       break
     }

     if isPrefix {
       fmt.Println("A too long line, seems unexpected.")
       return
     }

     str := string(line)
     value, errl := strconv.Atoi(str)
     if errl != nil {
       err = errl
       return
     }
     values = append(values, value)
   }
   return
 }

 func writeValues(values []int, outfile string) error {
   file, err := os.Create(outfile)
   if err != nil {
     fmt.Println("Failed to create the output 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 {
     fmt.Println("infile=", *infile, "outfile=", *outfile, "algorithm=", *algorithm)
   }

   values, err := readValues(*infile)
   if err == nil {
     fmt.Println("Read values: ", values)
     t1 := time.Now()
     switch *algorithm {
       case "qsort" :
         qsort.QuickSort(values)
       case "bubblesort":
         bubblesort.BubbleSort(values)
       default:
         fmt.Println("Sorting algorithm", *algorithm, "is either unknown or unsupported.")
     }
     t2 := time.Now()

     fmt.Println("The sorting process costs", t2.Sub(t1), "to cpmplete")

     writeValues(values, *outfile)
   }else {
     fmt.Println(err)
   }
 }

之后，返回到sorter目录节点，依次执行如下命令：（GOPATH:必须加入sorter的目录）

go build sorter/algorithm/qsort

go build sorter/algorithm/bubblesort

go test sorter/algorithm/qsort

go test sorter/algorithm/bubblesort

go install sorter/algorithm/qsort

go install sorter/algorithm/bubblesort

go build sorter

go install sorter

；bin目录下会有sorter的可执行文件生成；

----------------------------------------------------------------------------------------

bin目录下放入一个unsorted.bat文件，文件内容为

23

10

234

89

190

；执行命令：./sorter，会生成一个sorted.bat文件，内容为：

10

23

89

190

234

[完结]