golang_快速排序(TDD实践）_服务计算_作业二

完成迭代章节的练习

1.1修改测试代码，以便调用者可以指定字符重复的次数，然后修复代码

1：先修改测试代码；为迭代函数添加一个int 类型的参数：

package iteration

import "testing"
import  "fmt"
func TestReapeat(t *testing.T){
	repeated := Repeat("a",5)
	expected := "aaaaa"

	if repeated != expected{
		t.Errorf("expected '%q' but got '%q'",expected,repeated)
	}
}

尝试运行修改后的测试文件：编译器会报错，显示调用的函数Repeat（）参数过多。

对函数Repeat()进行修改，使得它可以指明迭代的次数。

package iteration

func Repeat(character string,count int) string {
   var repeated string
   for  i := 0; i < count; i++{
	   repeated += character
   }
   return repeated
}

修改好代码后，再次运行测试：测试通过：

1.2：写一个 ExampleRepeat 来完善你的函数文档。

书写示例有点类似于测试；在测试文件下面添加如下函数，下面的注释//Output： aaaaa 不能省略，否则，实例函数不会执行；

func ExampleRepeate( ){
	exam_text := Repeat("a", 5)
	fmt.Println(exam_text)
	//Output:  aaaaa
}

运行测试；可以看到示例的结果：

2：模仿教程内容结构，写一个Go语言某算法实现TDD实践报告。

2.1先写测试代码：

在文件quick_sort_test.go下编写测试代码如下：

package quick_sort

import "testing"
//判断两个数组是否一样：返回一个整型  1：一样  0：不一样
func is_same(arr1[] int ,arr2 [] int) int{
	if(len(arr1)!=len(arr2)){   //长度不一样，数组不一样
		return 0
	}

	for i:= 0 ; i < len(arr1) ;  i ++ {   //逐个判断数组的值
		if arr1[i] != arr2 [i] {
			return 0
		}
	}

	return 1
}


func TestQ_sort(t *testing.T){
    //测试数组一：
	var test_arr1 = [] int {2,34,22,78,45,65,89,23,44,33}  
	//排列好的数组一；期望输出数组
	var expected1 = [] int {2,22,23,33,34,44,45,65,78,89}
	//测试数组二：
	var test_arr2 = [] int {35,75,81,25,95,47,74,21,44}
	//数组二的输出数组：
	var expected2 = [] int {21,25,35,44,47,74,75,81,95}
    //比较函数的输出与期望输出是否一致
	var sort_res1 = Q_sort(test_arr1, 0, len(test_arr1)-1)
	var sort_res2 = Q_sort(test_arr2, 0, len(test_arr2)-1)

    if  is_same(sort_res1, expected1) == 0{
		t.Errorf("expected '%v' but got '%v'",expected1,sort_res1)
	}
    if  is_same(sort_res2, expected2) == 0{
		t.Errorf("expected '%v' but got '%v'",expected2,sort_res2)
	}
}

2.2尝试运行测试

$ go test -v

运行失败，无法加载快排函数：

2.3 先使用最少的代码来让失败的测试先跑起来；

编写如下简单的代码，尽管它运行的测试是错误的，但是测试代码可以成功编译了。

func Q_sort(arr [] int ,begin int , rear int) [] int {
      return arr
}

运行结果：

2.4 编写完整的代码，使得它能够通过测试：

编写完整的快排代码：

package quick_sort

func Q_sort_part(arr [] int ,begin int ,rear int) int{
	key :=arr[begin]  //取出数组开头的一个值为中间值
	at_arr := begin +1  //当前处理的数值位置
	sm_rear := begin+1  //比键值小的队列的下一个位置

	for ;at_arr <= rear ; at_arr++ {  //按序扫描数组块，
		    //如果当前位置的数值小于键值，则与大数数列的首个数字交换位置
		if  arr[at_arr]  < key     {
		  temp := arr[at_arr]      //arr[at_arr]与arr[sm_rear]交换位置
		  arr[at_arr] = arr[sm_rear]
		  arr[sm_rear] = temp
		  sm_rear++;
		}
	}
//将键值放到中间位置
	temp1 := arr[sm_rear-1]
	arr[sm_rear-1] = arr[begin]
	arr[begin] = temp1;
	 
	return sm_rear-1;  //返回中间值的位置
	
}


func Q_sort(arr [] int ,begin int ,rear int) [] int{
	if begin < rear{
		mid_posi := Q_sort_part(arr ,begin ,rear)
	
		Q_sort(arr, begin ,mid_posi-1)
		Q_sort(arr ,mid_posi + 1, rear)
	}
	
	return arr
}

再次运行测试：运行通过：

2.5 进行基准测试：

在测试代码下面加上如下基准测试函数：基准测试运行时，代码会运行 b.N 次，并测量需要多长时间。用 go test -bench=. 来运行基准测试。

func BenchmarkQ_sort(b * testing.B) {
	for i := 0; i < b.N;  i++ {
		var arr_t= [ ] int { 34, 56,23,71,29,53}
		Q_sort(arr_t , 0 , 5)
	}
}

用 go test -bench=. 来运行基准测试，运行结果：

$ go test -bench=.

运行了代码5000000次，每次运行的时间为251ns；