go结构体链表二叉树

链表就是一个元素通过指针连结另一个元素, 元素之间在内存中不是连续的

定义结构体:

type Student struct {
    Name string
    Age int32
    Score float32
    next *Student
}

如上这种结构体, 有一个属性是指针类型的

这种结构体的多个变量, 就可以构成链表

现有三个Student变量ABC, 如果: A中包含B的地址, B中包含C的地址, 则ABC构成链表

链表中的第一个变量称为表头

添加元素: 将新元素的地址赋值给上一个元素的指针属性, 如:

var first *Student = &Student {
    Name : "lisi",
    Age : 16,
    Score : 90.5,
}
head.next = first            // 地址赋值给上一个元素的next属性

向链表元素后循环抛入元素, 再遍历元素

package main
import (
    "fmt"
    "strconv"
    "math/rand"
)
/*链表结构体*/
type Student struct {
    Name string
    Age int32
    Score float32
    next *Student
}

/*遍历链表*/
func eachList(h *Student) {	        // 参数为一个链表的表头
    for h != nil {			// 如果为空, 则表示它是最后一个
        fmt.Println(*h)
        h = h.next
    }
}
/*向某链表元素后循环插入元素*/
func insertList(p *Student) {				// 参数为链表元素的指针
    var last = p
    for i := 0; i<10; i++ {
        var stu = &Student{				// 声明元素
            Name : "stu" + strconv.Itoa(i),
            Age : 20,
            Score : rand.Float32() * 100,
        }

        last.next = stu		// 将stu指向的元素添加上去
        last = stu		// 将stu指向的元素变成最后一个元素
    }
}

func main() {
    /*创建一个表头*/
    var head = Student{
        Name : "zhangsan",
        Age : 18,
        Score : 100.0,
    }

    /*在表头后面添加一个元素*/
    var first *Student = &Student {
        Name : "lisi",
        Age : 16,
        Score : 90.5,
    }
    head.next = first

    insertList(first)
    eachList(&head)
}

向链表元素前面插入元素

func insertBeforList(p **Student) {	       
    for i := 0; i<10; i++ {
        var stu = &Student{					
            Name : "stu" + strconv.Itoa(i),
            Age : 20,
            Score : rand.Float32() * 100,
        }
        stu.next = *p		
        *p = stu	                      	
    }
}

func main() {
    var head = &Student{
        Name : "zhangsan",
        Age : 18,
        Score : 100.0,
    }
	
    insertBeforList(&head)
    eachList(head)        // 遍历链表函数, 如上
}

删除链表元素

上一个元素指向下一个元素, 则中间元素就被删除 --> prev.nex = current.next

func deleteNode(p *Student) {        // 不考虑删除头节点的情况
    var prev = p		// 用于保存当前元素的前一个元素
    for p != nil {
        if p.Name == "stu4" {
            prev.next = p.next		// 改变前一个元素的next的值, 让其指向下一个元素
            break
        }
        prev = p		// 由于下一行p会跳到下一个元素, 所以prev=p, 表示的是前一个元素
        p = p.next
    }
}

在指定位置插入元素

func insertElement(list, e *Student) {
    for list != nil {
        if list.Name == "stu5" {    
            e.next = list.next		        // 新元素与后面元素连续
            list.next = e			// 新元素与前面元素连续
        }
        list = list.next
    }
}

二叉树

二叉树中有两个指针, 一个表示左, 一个表示右

package main
import (
	"fmt"
)

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

func main() {
	/*创建根节点*/
	var root = new(Student)
	root.Name = "s1"
	root.Age = 18
	root.Score = 99.9

	/*创建左边一个子节点*/
	var f1A = new(Student)
	f1A.Name = "s2"
	f1A.Age = 18
	f1A.Score = 99.9
	root.left = f1A

	/*创建右边一个子节点*/
	var f1B = new(Student)
	f1B.Name = "s3"
	f1B.Age = 18
	f1B.Score = 99.9
	root.right = f1B

	/*在f1A下边创建左子节点*/
	var f2A = new(Student)
	f2A.Name = "s4"
	f2A.Age = 18
	f2A.Score = 99.9
	f1A.left = f2A

	/*在f1A下边创右建子节点*/
	var f2B = new(Student)
	f2B.Name = "s5"
	f2B.Age = 18
	f2B.Score = 99.9
	f1A.right = f2B

	eachAll(root)
}

/*使用递归循环遍历二叉树*/
func eachAll(head *Student) {
	if(head == nil) {
		return
	}
	fmt.Println(*head)
	eachAll(head.left)
	eachAll(head.right)
}

go结构体链表二叉树

猜你喜欢