11.7.md 6.6 KB

11.7 ��һ�����ӣ�ʹ��Sorter�ӿ�����

һ���ܺõ����������Ա�׼��� sort ����Ҫ��һ�����ֻ��ַ�������ֻ��Ҫʵ��������������ӳԪ�ظ����� Len()�������Ƚϵ� i �� j ��Ԫ�ص� Less(i, j) �����Լ������� i �� j ��Ԫ�ص� Swap(i, j) ������

���������㷨ֻ��ʹ�õ�����������������ʹ���κ������㷨��ʵ�֣��˴�����ʹ��ð�����򣩣�

func Sort(data Sorter) {
    for pass := 1; pass < data.Len(); pass++ {
        for i := 0;i < data.Len() - pass; i++ {
            if data.Less(i+1, i) {
                data.Swap(i, i + 1)
            }
        }
    }
}

Sort ��������һ���ӿ����Ͳ����� Sorter ������������Щ������

type Sorter interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

�����е� int ����˵Ҫ����Ķ���һ��Ҫ��һ�� int��i �� j ��ʾԪ�ص���������������Ҳ�����͵ġ�

��������������һ�� int ��������������б�������������ǣ�Ϊ���鶨һ�����Ͳ���������ʵ�� Sorter �ӿڵķ�����

type IntArray []int
func (p IntArray) Len() int           { return len(p) }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

�����ǵ�����������һ���������ӣ�

data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
a := sort.IntArray(data) //conversion to type IntArray from package sort
sort.Sort(a)

�����ġ������еĴ�������� sort.go �� sortmain.go ���ҵ���

ͬ����ԭ������������������һ�����������飬һ���ַ������飬����һ����ʾÿ�ܸ���Ľṹ�� dayArray.

ʾ�� 11.6 sort.go��

package sort

type Sorter interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

func Sort(data Sorter) {
	for pass := 1; pass < data.Len(); pass++ {
		for i := 0; i < data.Len()-pass; i++ {
			if data.Less(i+1, i) {
				data.Swap(i, i+1)
			}
		}
	}
}

func IsSorted(data Sorter) bool {
	n := data.Len()
	for i := n - 1; i > 0; i-- {
		if data.Less(i, i-1) {
			return false
		}
	}
	return true
}

// Convenience types for common cases
type IntArray []int

func (p IntArray) Len() int           { return len(p) }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
func (p IntArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

type StringArray []string

func (p StringArray) Len() int           { return len(p) }
func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
func (p StringArray) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

// Convenience wrappers for common cases
func SortInts(a []int)       { Sort(IntArray(a)) }
func SortStrings(a []string) { Sort(StringArray(a)) }

func IntsAreSorted(a []int) bool       { return IsSorted(IntArray(a)) }
func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }

ʾ�� 11.7 sortmain.go��

package main

import (
	"./sort"
	"fmt"
)

func ints() {
	data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
	a := sort.IntArray(data) //conversion to type IntArray
	sort.Sort(a)
	if !sort.IsSorted(a) {
		panic("fails")
	}
	fmt.Printf("The sorted array is: %v\n", a)
}

func strings() {
	data := []string{"monday", "friday", "tuesday", "wednesday", "sunday", "thursday", "", "saturday"}
	a := sort.StringArray(data)
	sort.Sort(a)
	if !sort.IsSorted(a) {
		panic("fail")
	}
	fmt.Printf("The sorted array is: %v\n", a)
}

type day struct {
	num       int
	shortName string
	longName  string
}

type dayArray struct {
	data []*day
}

func (p *dayArray) Len() int           { return len(p.data) }
func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num }
func (p *dayArray) Swap(i, j int)      { p.data[i], p.data[j] = p.data[j], p.data[i] }

func days() {
	Sunday    := day{0, "SUN", "Sunday"}
	Monday    := day{1, "MON", "Monday"}
	Tuesday   := day{2, "TUE", "Tuesday"}
	Wednesday := day{3, "WED", "Wednesday"}
	Thursday  := day{4, "THU", "Thursday"}
	Friday    := day{5, "FRI", "Friday"}
	Saturday  := day{6, "SAT", "Saturday"}
	data := []*day{&Tuesday, &Thursday, &Wednesday, &Sunday, &Monday, &Friday, &Saturday}
	a := dayArray{data}
	sort.Sort(&a)
	if !sort.IsSorted(&a) {
		panic("fail")
	}
	for _, d := range data {
		fmt.Printf("%s ", d.longName)
	}
	fmt.Printf("\n")
}

func main() {
	ints()
	strings()
	days()
}

�����

The sorted array is: [-5467984 -784 0 0 42 59 74 238 905 959 7586 7586 9845]
The sorted array is: [ friday monday saturday sunday thursday tuesday wednesday]
Sunday Monday Tuesday Wednesday Thursday Friday Saturday 

��ע��

panic("fail") ����ֹͣ�����ڷ���������µij�����ϸ��ο� ��13�£�����ȻҲ�����ȴ�ӡһ����Ϣ��Ȼ����� os.Exit(1) ��ֹͣ����

��������Ӱ������ǽ�һ���˽��˽ӿڵ������ʹ�÷�ʽ�����ڻ������͵����򣬱�׼���Ѿ��ṩ����ص������������Բ���Ҫ�������ظ��������ˡ�����һ���Ե�����sort ��������һ���ӿڣ�

type Interface interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

����ӿ��ܽ�����Ҫ��������ij��󷽷������� Sort(data Interface) �����Դ������������򣬿�����������ʵ�ֶ��������ݣ��ǻ������ͣ���������������������У�����Ҳ����ô���ģ��������Զ� int �� string ���н�������Ҳ���Զ��û��Զ������� dayArray ��������

��ϰ 11.5 interfaces_ext.go��

a). ������չ���򣬶������� Triangle������ʵ�� AreaInterface �ӿڡ�ͨ������һ���ض������ε���������в��ԣ����������=0.5 * (�� * ��)��

b). ����һ���½ӿ� PeriInterface������һ�� Perimeter �ӿڡ��� Square ʵ������ӿڣ���ͨ��һ�� Square ʾ������������

��ϰ 11.6 point_interfaces.go��

���� 10.3 �е���ϰ point_methods.go������ӿ� Magnitude������һ������ Abs()���� Point��Point3 ��Polar ʵ�ִ˽ӿڡ�ͨ���ӿ����ͱ���ʹ�÷�����point.go��ͬ�������顣

��ϰ 11.7 float_sort.go / float_sortmain.go��

����11.7��ʾ��11.3/4������һ���� float64�����ڰ��ﶨ������ Float64Array��Ȼ������ʵ�� Sorter �ӿ������� float64 �����������

�����ṩ���·�����

  • NewFloat64Array()������һ������25��Ԫ�ص�����������ο�10.2��
  • List()�����������ʽ������ַ��������� String() �����е������������Ͳ�����ʽ�ص��� List() ����ӡ���飨�ο�10.7��
  • Fill()������һ������10����������������飨�ο�4.5.2.6��

�����������½�һ�������͵ı�����Ȼ��������򲢽��в��ԡ�

��ϰ 11.8 sort.go/sort_persons.go��

����һ���ṹ�� Person�����������ֶΣ�firstName �� lastName��Ϊ []Person �������� Persons ���� Persons ʵ�� Sorter �ӿڲ����в��ԡ�

����