GO语言练习:第一个Go语言工程--排序

1、代码

2、编译

3、运行



1、代码框架 /home/fengbo/sorter

$ tree
.
├── bin
├── pkg
├── readme.txt
└── src
    ├── algorithms
    │   ├── bubblesort
    │   │   ├── bubblesort.go
    │   │   └── bubblesort_test.go
    │   └── qsort
    │       ├── qsort.go
    │       └── qsort_test.go
    └── sorter
        └── sorter.go

  1.1、src/algorithms/bubblesort/bubblesort.go

//bubblesort.go
package bubblesort

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

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

  1.2、src/algorithms/bubblesort/bubblesort_test.go

//bubble_test.ho
package bubblesort

import "testing"

func TestBubbleSort1(t * testing.T) {
        values := []int {5, 4, 3, 2, 1}
        BubbleSort(values)
        for i := 0; i < len(values) - 1; i++ {
                if values[i] > values[i + 1] {
                        t.Error("ubbleSort() faild. Got at ", values[i], values[i + 1])
                        break
                }
        }
}

func TestBubbleSort2(t * testing.T) {
        values := []int{5}
        BubbleSort(values)
        if(values[0] != 5) {
                t.Error("BubbleSort() faild. Got ", values, "Excepted 5")
        }
}

  1.3、src/algorithms/qsort/qsort.go

//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
                }
                if values[i] <= temp && i <= p {
                        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)
}

  1.4、src/algorithms/qsort/qsort_test.go

//qsort_test.go
package qsort

import "testing"

func TestQuickSort1(t * testing.T) {
        values := []int {5, 4, 3, 2, 1}
        QuickSort(values)
        var i int;
        var j int = len(values) - 1
        for i = 0; i < j; i++ {
                if values[i] > values[i + 1] {
                        t.Error("QuickSort() faild")
                        break;
                }
        }
}

func TestQuickSort2(t * testing.T) {
        values := []int {5}
        QuickSort(values)
        if values[0] != 5 {
                t.Error("QuickSort() faild. Got", values);
        }
}

  1.5、src/sorter/sorter.go

package main

import "bufio"
import "flag"
import "fmt"
import "io"
import "os"
import "strconv"
import "time"

import "algorithms/bubblesort"
import "algorithms/qsort"

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)

                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("Faild to create the outfile ", 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 ensupported.")
                }
                t2 := time.Now()

                fmt.Println("The sorting process costs", t2.Sub(t1), "to complete.")
                writeValues(values, * outfile)
        }else {
                fmt.Println(err)
        }
}


2、编译

  2.1、设置环境变量

[[email protected]]$ pwd
/home/fengbo/sorter
[[email protected]]$ export GOPATH="/home/fengbo/sorter"

  2.1编译级安装

$ go build algorithms/bubblesort
$ go build algorithms/qsort
$ go install algorithms/bubblesort
$ go install algorithms/qsort
$ go build sorter

  2.2、编译及安装后的目录结构

$ tree
.
├── bin
├── pkg
│   └── linux_386
│       └── algorithms
│           ├── bubblesort.a
│           └── qsort.a
├── readme.txt
├── sorter
└── src
    ├── algorithms
    │   ├── bubblesort
    │   │   ├── bubblesort.go
    │   │   └── bubblesort_test.go
    │   └── qsort
    │       ├── qsort.go
    │       └── qsort_test.go
    └── sorter
        └── sorter.go


3、运行

  3.1、未排序的文本文件

$ cat unsorted.dat
6
345
76564
5
66
443654
757
2365
565

  3.2、运行排序程序

$ ./sorter -i unsorted.dat -o sorted.dat -a qsort
infile = unsorted.dat outfile =  sorted.dat algorithm =  qsort
The sorting process costs 2.22us to complete.

  3.3、排序后的结果文件

$ ls
sorted.dat  sorter unsorted.dat
$ cat sorted.dat
5
6
66
345
565
757
2365
76564
443654


4、注释

  代码来源于《Go语言编程》一书的第二章,目录结构与原书有些差异。

时间: 2024-11-05 22:00:02

GO语言练习:第一个Go语言工程--排序的相关文章

李洪强iOS开发之【零基础学习iOS开发】【02-C语言】02-第一个C语言程序

前言 前面已经唠叨了这么多理论知识,从这讲开始,就要通过接触代码来学习C语言的语法.学习任何一门语言,首先要掌握的肯定是语法.学习C语言语法的目的:就是能够利用C语言编写程序,然后运行程序跟硬件(计算机.手机等硬件设备)进行交互.由于我们的最终目的是学习iOS开发,学习iOS开发的话必须在Mac系统下,因此我就在Mac系统环境下开发C语言程序,而不是在Windows环境下. 接下来,就在Mac系统环境下编写第一个C语言程序,最后把程序运行起来,跟计算机做一个小小的互动 一.编写第一个C语言程序-

【零基础学习iOS开发】【02-C语言】02-第一个C语言程序

本文目录 前言 一.编写第一个C语言程序-Hello World 二.编译程序 三.链接程序 四.运行程序 五.总结 六.学习建议 七.clang指令汇总 回到顶部 前言 前面已经唠叨了这么多理论知识,从这讲开始,就要通过接触代码来学习C语言的语法.学习任何一门语言,首先要掌握的肯定是语法.学习C语言语法的目的:就是能够利用C语言编写程序,然后运行程序跟硬件(计算机.手机等硬件设备)进行交互.由于我们的最终目的是学习iOS开发,学习iOS开发的话必须在Mac系统下,因此我就在Mac系统环境下开发

【C语言】第一个C语言小程序 —— 日期算法和万年历

1. 写了个万年历的功能练练手.还没有写交互的代码,只是把方法写完了.先给出头部和方法签名 #include<stdio.h> #define DAYS_PER_WEEK 7 #define MONTHS 12 #define DATE_HEADER " Sun Mon Tues Wed Thur Fri Sat" int get_days(int, int, int); //返回从公元元年算起,某年某月某日是第几天, 用这个数字算星期几 int days_of_year(

D、GO、Rust 谁会在未来取代 C?为什么?——Go语言的定位非常好,Rust语言非常优秀,D语言也不错

不要管我的地位和 D 语言创造者之一的身份.我会坦诚的回答这个问题.我熟悉 Go 和 Rust,并且知道 D 的缺点在哪里.我鼓励人们在 Rust 和 Go 社区相似身份的人,也可以提出他们诚恳的观点.接着,我们开始吧. 首先,C++ 在这个问题中也应该被提及.不管它是否取代 C,或是成为取代 C 的候选人之一,C++ 是这个等式的一个关键部分.它是最接近 C 的,同时也是从 C 中来的.在下面几个问题中我会假设 C++ 是把取代 C 作为目标的. 每一个语言都有一些基础优势(我称之为“十倍优势

ios-(2)第一个C语言程序(理解编译、连接、运行)

一.开发工具的选择 1. 可以用来写代码的工具:记事本.ULtraEdit.Vim.Xcode等. 2. 选择XCode的原因:苹果公司官方提供的开发利器.简化开发的工程.有高亮显示功能. 3. 使用XCode新建一个C程序的源代码文件(扩展名为.c或者.C) # 开发XCode # 新建文件 # 选择文件类型 .c 二.代码编写 1.程序结构 * C程序的结构:由函数组成 # 任何一个C语言程序都市有一个或者多个程序段(小程序)构成的,每个程序段都有自己的功能,我们一般称这些程序段为"函数&q

【Objective-C】02.第一个OC语言类

02.第一个OC语言类 在java语言中,创建一个类只需要一个文件,而在oc语言中,创建一个类需要两个文件.m文件和.h文件. .h文件是声明类,用来声明成员变量和方法.用关键词@interface来修饰,以@end结尾. .m文件是实现类,用来实现成员变量和方法,用关键词@implementation来修饰,以@end结尾. 方法:在oc语言中方法都需要用+或-来表明方法的类型. +表示的是静态方法. -表示的是动态方法. .h文件中的所有方法都是public,不能更改. 成员变量:成员变量按

ubuntukylin基础 使用gcc编译一个C语言 helloworld程序 预编译 汇编 编译 链接

镇场文:       学儒家经世致用,行佛家普度众生,修道家全生保真,悟易理象数通变.以科技光耀善法,成就一良心博客.______________________________________________________________________________________________________ 我的系统:UbuntuKylin 16.04 LTS 64bit step0: 查看当前的文件夹 step1: 用vim编辑器 创建一个C语言源代码文件 step2: 写出 可

C语言的很吊的printf-----来自一个C语言竞赛题目

一个C语言竞赛题目: 1 #include <stdio.h> 2 int main() 3 { 4 const int unix=1; 5 printf(&unix["\021%six\012\0"], (unix)["have"] + "fun" - 0x60); 6 return 0; 7 } 输出: unix 知识点 :1. \012 是一个字节对应 回车2. printf("%c",2["

《Go语言入门》第一个Go语言Web程序——简单的Web服务器

概述 上一篇讲了 <Go语言入门>第一个Go语言程序--HelloWorld,接下来讲一下Go语言Web开发入门必修课:第一个Go语言Web程序--简单的Web服务器. 与其它Web后端语言不同,Go语言需要自己编写Web服务器. 有关本地环境的搭建与基础学习,请参考: <Go语言入门>如何在Windows下安装Go语言编程环境 Go语言Web应用:IBM的云平台Bluemix使用初体验--创建Go语言 Web 应用程序,添加并使用语言翻译服务 Web服务器代码 Google在ht

第一个C语言编译器是怎样编写的?

首先向C语言之父Dennis MacAlistair Ritchie致敬! 当今几乎所有的实用的编译器/解释器(以下统称编译器)都是用C语言编写的,有一些语言比如Clojure,Jython等是基于JVM或者说是用Java实现的,IronPython等是基于.NET实现的,但是Java和C#等本身也要依靠C/C++来实现,等于是间接调用了调用了C.所以衡量某种高级语言的可移植性其实就是在讨论ANSI/ISO C的移植性. C语言是很低级的语言,很多方面都近似于汇编语言,在<Intel32位汇编语