Go语言最简化的快速排序代码

Go语言入门

学习Go时，发现Go可以将代码写得极其简单，下面是我实现的一个快速排序代码：

// Start from here:
package qsort

func quickSort(values []int, left, right int) {
	i, j := left, right
	for i != j {
		for values[j] >= values[left] && i < j {
			j--
		}
		for values[i] <= values[left] && i < j {
			i++
		}
		if i < j {
			values[i], values[j] = values[j], values[i]
		}
	}
	values[left], values[i] = values[i], values[left]
	switch {
		case i - 1 > left:
			quickSort(values, left, i - 1)
		case right > i + 1:
			quickSort(values, i + 1, right)
	}
}
func QuickSort(values []int) {
	quickSort(values, 0, len(values) - 1)
}
// End here可以直接调用

# package build …

# package install

然后主程序如下，编译后可以用一个文件来放in and out file
命令行运行：

# sorter -i infile -o outfile -a qsort

就可以了。

package main

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

var infile *string = flag.String("i", "infile", "File contains values for sorting")
var outfile *string = flag.String("o", "outfile", "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, 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)
		value, err1 := strconv.Atoi(str)
		if err1 != nil {
			err = err1
			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 {
		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 complete.")
		writeValues(values, *outfile)
	} else {
		fmt.Println(err)
	}
}