Go Example 1: file read and write and sort (fast bubbling)

Package main import ("Algorithm/bubblesort" "Algorithm/qsort" "Bufio" "Flag" "FMT" "IO" "OS" "StrConv" "Time") 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, 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) fmt. Print (str, "") 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 {fmt. PRINTLN (Err)} else {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)}}

Package Bubblesort

func bubblesort (values []int) {for
	I: = 0, I < len (values)-1; i++ {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]}
	}}

Package Qsort

func quickSort (values []int, left, right int) {
	Temp: = Values[left]
	p: = left
	I, j: = Le FT, right-

	I <= J {for
		J >= P && values[j] >= temp {
			j--
		}
		if J >= p {
  VALUES[P] = values[j]
			p = J
		}
		if values[i] <= temp && i <= p {
			i++
		}

		if I & lt;= p {
			values[p] = values[i]
			p = i
		}
	}

	values[p] = temp  //provkey
	if p-left > 1 { C32/>quicksort (values, left, p-1)
	}
	if right-p > 1 {
		quickSort (values, p+1, right)
	}
}

func QuickSort (values []int) {
	QuickSort (values, 0, Len (values)-1)
}