线性结构-链表 Linked List

1.链表的定义

        类似于之前的栈与队列,链表也是一种线性的数据结构,但是又不同于他们,因为列表是真正的动态数据结构,如图:

                           

        在class中,分别定义了e和next,e可以理解为存储我们真正的数据,而next的类型则为Node,所以next是当前node节点的下一个节点,所以说链表好比一个火车,除了我们一节一节的车厢存储数据(e的作用)以外,还要通过next把车厢一节节的连在一起,以使得我们的数据是连接在一起的.

2.链表添加数据

     2.1 在链表头部添加数据:

                    

     2.2 在链表中间添加数据:

                   

     2.3 在链表中删除数据:

                     

     2.3 在golang中的实现

          因为go中支持双向链表的数据结构,所以我们直接调用go的list包即可; 

package main

import (
	"container/list"
	"fmt"
)

func main() {
	/**
     * 例子1
	 */
	//创建新的链表
	l := list.New()
	//把元素插入链表最后
	l.PushBack(1)
	l.PushBack(2)
	l.PushBack(3)
	l.PushBack(4)
	l.PushBack(5)
	//把元素插入链表的最前面
	l.PushFront("开始")
	l.PushBack("结束")
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value) //输出结果:开始12345结束
	}
	//获取链表第一个元素
	fmt.Println(l.Front().Value) //输出结果是:开始

	//获取链表最后一个元素
	fmt.Println(l.Back().Value) //输出结果是:结束

	/**
     * 例子2
	 */
	ll := list.New()
	b := ll.PushBack("一")
	ll.PushBack("二")
	a := ll.PushBack("三")
	ll.PushBack("四")

	//把链表l放在ll的后面,同理还有 PushFrontList
	ll.PushBackList(l)

	//把元素插入到链表指定元素之前,同理还有 InsertAfter
	ll.InsertBefore(333, a)

	//把元素移动到链表的第一位置,同理还有 MoveToBack
	ll.MoveToFront(a)

	//把元素a移动到元素b之前,同理还有 MoveAfter
	ll.MoveBefore(a, b)

	//删除指定的元素
	ll.Remove(ll.Back())
	for e := ll.Front(); e != nil; e = e.Next() {
		fmt.Print(e.Value) //输出结果:三一二333四开始12345
	}

}

3.链表其他实现

     3.1利用链表实现栈

         栈包封装

package arr

import (
	"container/list"
	"fmt"
)

var l = list.New()

/**
 * push向栈中添加数据
 * @value 泛型
 */
func List_push(value interface{}) {
	l.PushBack(value)
}

/**
 * Top从栈中取出栈顶
 */

func List_top() interface{} {
	top := l.Back()
	l.Remove(l.Back())
	return top
}

/**
 * info查看栈的结构 
 */
func List_info() {
	for e := l.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}
}

        栈包利用

package main

import "./arr"

func main() {
	arr.List_push(1)
	arr.List_push(2)
	arr.List_push(3)
	arr.List_top() //去除栈顶
	arr.List_info() //结果输出: 12
}

     3.2 leetcode 203号问题

                  

        用go的解法

               

package main

import (
	"fmt"
)

type ListNode struct {
	Val  int
	Next *ListNode
}

func removeElements(head *ListNode, val int) *ListNode {
	//第一个数等于val
	for head != nil && head.Val == val {
		head = head.Next
	}
	if head == nil {
		return head
	}

	//中间数等于val
	prev := head
	for prev.Next != nil {
		if prev.Next.Val == val {
			//跳过本身,后移一位
			prev.Next = prev.Next.Next
		} else {
			//向后移一位即可
			prev = prev.Next
		}
	}
	return head
}

func main() {
	var l ListNode
	l.Val = 1
	l.Next = new(ListNode)

	l.Next.Val = 2
	l.Next.Next = new(ListNode)

	l.Next.Next.Val = 3
	l.Next.Next.Next = new(ListNode)

	l.Next.Next.Next.Val = 4
	l.Next.Next.Next.Next = nil

	ll := removeElements(&l, 3)

	fmt.Println(ll)
	fmt.Println(ll.Next)
	fmt.Println(ll.Next.Next)
}