go 测试sort性能

package main

import "fmt"
import "os"
import "flag"
import "bufio"
import "io"

import "time"
import "strconv"
//import "algorithm/qsort"

import "algorithm/bubblesort"

var infile *string = flag.String("i","unsorted.dat","file container unsorted")
var outfile *string =flag.String("o","sorted.dat","file container sorted")
var algorithm *string =flag.String("a","bubblesort","sort algortihm")

func readValue (infile string)(values []int,err error){
        file,err := os.Open(infile)
        if err != nil{
                fmt.Println("open failed")
                return
        }
        defer file.Close()
        br := bufio.NewReader(file)

        values =make([]int ,)
        for{
                line,isprefix,err1 := br.ReadLine()
                if err1 !=nil{
                        if err1 !=io.EOF{
                                err=err1
                        }
                        fmt.Println("readline error")
                                                         //      return
                        break
                }
                if isprefix {
                        fmt.Println("too long")
                        return
                }
                str:= string(line)

                value ,err2 :=strconv.Atoi(str)

                if err2 !=nil{
                        err2=err
                        fmt.Println("conv failed")
                        return
                }
                values = append(values,value)
        }
        return          

}
func writeValue(values []int ,outfile string) error{
        file,err1 :=os.Create(outfile)
        if err1 !=nil {
                //err=err1
                fmt.Println("write is errr")
                return err1
        }
        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("inline =",*infile,"outfile =:",*outfile,"algorithm =: ",*algorithm)
        }
        values,err := readValue(*infile)

        if err ==nil{
                t1 :=time.Now()
        //      switch *algorithm {
        //              case "qsort":
        //                      qsort.Quick(values)
        //              case bubblesort:

                                bubblesort.BubbleSort(values)
        //              default:
        //                      fmt.Println("switch error")
        //      }
                t2:=time.Now()
                fmt.Println("sort time is %d",t2.Sub(t1))
//              fmt.Println(values)
                writeValue(values,*outfile)
        }else{
                fmt.Println("readLIne is ERROR")
        }
}

上面的是src中的主文件

algorithm中的主要是排序算法，我这里只有bubblesort，额外还可以有其他的，对于测试文件，我们只需要写_test.go就可以了，

我们可以在主程序中，使用swith进行选择，但是这里的swith遇到一个问题，就是当go build sorter的时候，总是报without selecor的错误，这个问题现在我还没有解决，所有我注释掉了，我们需要在简历一个unsortred.dat的文件，至于输出文件，通过os.Create

自己就创建了。

go build algorithm/bubblesort

go install algorithm/bubblesort

go build sorter生出二进制文件

./sorter -i unsorted -o sorted

package bubblesort

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

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

    }
}

package bubblesort

import "testing"

func TestBubbleSort1(t *testing.T){
    values :=[]int{,,,,}
    BubbleSort(values)
    if values[] != || values[]!= || values[] != || values[] != ||values[] !={
        t.Error("bubblesor is falied ",values)
    }
}