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

 

[qsort_test.go]

package qsort

import "testing"

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

 

[bubblesort.go]

package bubblesort

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

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

    for j:=0; j<len(values)-i-1; 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"

func TestBubbleSort1(t *testing.T) {
  values := []int{5,4,3,2,1}
  BubbleSort(values)
  if values[0]!=1 || values[1]!=2 || values[2]!=3 || values[3]!=4 || values[4]!=5 {
    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, 0)

  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

[完结]