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 ,0)
        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+"
")
        }
        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 :=0 ;i<len(values)-1 ;i++{
        flag =false
        for j:=0 ;j<len(values)-i-1 ;j++{
            if values[j+1] <values[j]{
                values[j+1],values[j] =values[j],values[j+1]
                flag=true
            }
        }
        if flag==false{
            break
        }
            
    }
}

package bubblesort

import "testing"

func TestBubbleSort1(t *testing.T){
    values :=[]int{5,3,6,2,4}
    BubbleSort(values)
    if values[0] !=2 || values[1]!=3 || values[2] !=4 || values[3] !=5 ||values[4] !=6{
        t.Error("bubblesor is falied ",values)
    }
}