七. Go学习：排序、结构体、链表和二叉树

本文介绍了结构体这一自定义数据类型，以及排序（冒泡、简单选择、插入和快爬）、链表和二叉树这三种简单的数据结构（通过代码）

目录

排序

一. 冒泡排序

二. 简单选择排序

三. 插入排序

四. 快速排序

结构体

链表

二叉树

---

排序

一. 冒泡排序

冒泡排序：从小往上两两比较相邻记录的关键字，反序则交换，直至有序。最小数像泡泡一样从小往上走.

package main

import (
	"fmt"
)
func sortBuble(a []int) {
	for i := 0; i < len(a); i++ {
		for j := len(a) - 1; j > i; j-- {
			if a[j] < a[j-1] {
				a[j], a[j-1] = a[j-1], a[j]
			}
		}
	}
}
func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	fmt.Println(b)
	sortBuble(b[:])
	fmt.Println(b)
}

二. 简单选择排序

简单排序通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。

package main

import (
	"fmt"
)

func sortSelect(a []int) {
	for i := 0; i < len(a); i++ {
		min := i
		for j := i + 1; j < len(a); j++ {
			if a[j] < a[min] {
				min = j
			}
		}
		if min != i {
			a[i], a[min] = a[min], a[i]
		}
	}
}
func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	fmt.Println(b)
	sortSelect(b[:])
	fmt.Println(b)
}

三. 插入排序

插入排序如同打牌时插扑克，其中未排好序的序列中的值一个个插入已有序的表中，从而得到一个有序表。

package main

import (
	"fmt"
)
func sortInsert(a []int) {
	for i := 1; i < len(a); i++ {
		for j := i; j > 0; j-- {
			if a[j] < a[j-1] {
				a[j-1], a[j] = a[j], a[j-1]
			}
		}
	}
}
func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	fmt.Println(b)
	sortInsert(b[:])
	fmt.Println(b)
}

四. 快速排序

快速排序将待排序序列分割成两个独立的两部分，其中一部分序列关键字均小于另一部分，然后再对这两部分用此方法进行排序，直至整个序列有序

package main

import (
	"fmt"
)

func sortQuick(a []int, left, right int) {
	if left < right {
		pivot := zhong(a[:], left, right)
		sortQuick(a[:], left, pivot-1)
		sortQuick(a[:], pivot+1, right)
	}
}
func zhong(a []int, left, right int) int {
	for left < right {
		piovt := a[left]
		for left < right && a[right] >= piovt {
			right--
		}
		a[left], a[right] = a[right], a[left]
		for left < right && a[left] <= piovt {
			left++
		}
		a[left], a[right] = a[right], a[left]
	}
	return left
}
func main() {
	b := [...]int{8, 7, 5, 4, 3, 10, 15}
	fmt.Println(b)
	sortQuick(b[:], 0, len(b)-1)
	fmt.Println(b)
}

结构体

package main

import (
	"fmt"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

func main() {
	var stu Student
	stu.Age = 18
	stu.Name = "hua"
	stu.Score = 80
	var stu1 *Student = &Student{
		Age:  20,              //初始化
		Name: "hua",
	}
	fmt.Println(stu1.Name)
	fmt.Printf("Name:%p\n", &stu.Name)
	fmt.Printf("Age:%p\n", &stu.Age)
	fmt.Printf("Scorce:%p\n", &stu.Score)
	fmt.Println(stu)
}

链表

链表的结构、建立（尾插和头插）、节点的删除、新增和遍历输出。

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}
func trans(p *Student) { //链表遍历输出
	for p != nil {
		fmt.Println(*p)
		p = p.next
	}
}
func insertTail(p *Student) { //尾插法插入新节点
	var tail = p
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		tail.next = &stu
		tail = &stu
		tail.next = nil
	}
}
func delNode(p *Student) {
	var prev *Student = p //prev为待删除节点的前一个节点
	for p != nil {        //遍历链表，找到节点
		if p.Name == "stu6" {
			prev.next = p.next //令待删除节点的next直接指向待删除节点的下一个节点
			p.next = nil
			break
		}
		prev = p
		p = p.next
	}
}

func addNode(p *Student, newNode *Student) { //插入节点
	for p != nil {
		if p.Name == "stu6" {
			newNode.next = p.next
			p.next = newNode
			break
		}
		p = p.next
	}
}
func main() {
	var head *Student = new(Student)
	head.Name = "hua"
	head.Age = 19
	head.Score = 100
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100, 
		}
		stu.next = head    //头插法
		head = &stu
	}
	delNode(head)
	trans(head)
}

二叉树

二叉树的结构、建立和遍历

package main
import (
	"fmt"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	left  *Student
	right *Student
}

func trans(root *Student) {            //递归遍历
	if root == nil {
		return    
	}                       
	fmt.Println(root)
	trans(root.left)
	trans(root.right)
}

func main() {
	var root *Student = new(Student)
	root.Name = "stu"
	root.Age = 18
	root.Score = 100

	var left1 *Student = new(Student)
	left1.Name = "stu01"
	left1.Age = 10
	left1.Score = 100
	root.left = left1

	var right1 *Student = new(Student)
	right1.Name = "stu02"
	right1.Age = 10
	right1.Score = 100
	root.right = right1

	var left2 *Student = new(Student)
	left2.Name = "stu03"
	left2.Age = 10
	left2.Score = 100
	left1.left = left2

	trans(root)
}