go用連結清單實作線性表

```

package main

import "fmt"

type LinkedListstruct {

l *slist

length uint32

}

// 單向清單

type sliststruct {

valinterface{}

next *slist

/* 初始化一個空線性表*/

func (L *LinkedList) InitList(vinterface{}, length uint32) {

L.l = new(slist)

L.l.val = v

var n*slist = L.l

L.length = length

for i := uint32(1);i < L.length; i +=1 {

n.next = new(slist)

n.next.val = v

n = n.next

// 最末尾的一個節點指向空

  n.next = nil

/* 銷毀線性表*/

func (L *LinkedList) DeleteList() {

L.length =0

  L.l = nil

/* 将線性表置為空表*/

func (L *LinkedList) ClearList() {

L.DeleteList()

/* 傳回線性表的長度*/

func (L *LinkedList) ListLength() uint32 {

return uint32(L.length)

/* 傳回第i個資料元素*/

func (L *LinkedList) GetElem(e uint32)interface{} {

if e > L.length {

e = L.length

p := L.l

for i := uint32(1);i < e;i +=1 {

p = p.next

return p.val

/* 傳回L中第1個與e滿足compare函數的資料元素的位序.若這樣的資料元素不存在,則傳回0 */

func (L *LinkedList) LocateElem(vinterface{}, ffunc(a ...interface{}) bool) uint32 {

w := uint32(0)

var p*slist= L.l

for i := uint32(0);i < L.length;i +=1 {

if f(p.val, v) ==true {

w = i

break

      }

return w

/* 傳回要查找值的前驅,如果沒有前驅,則傳回空*/

func (L *LinkedList) PriorElem(vinterface{})interface{} {

var p*slist = L.l

var front*slist = L.l

if v == p.val {

w = i +1

        break

front = p

if w ==0 || w ==1 {

return nil

}else {

return front.val

/* 傳回要查找值的後驅,如果沒有後驅,則傳回空*/

func (L *LinkedList) NextElem(vinterface{})interface{} {

var next*slist = L.l.next

for next != nil {

p = next

next = p.next

if next == nil {

return next.val

/* 線上性表中的第i個位置插入一個資料*/

func (L *LinkedList) ListInsert(i uint32, vinterface{})  {

// 線性為空

  if L.length ==0 {

L.l.next = nil

L.length =1

      return

  }

p := &slist{val: v}

var next*slist = L.l

if i <=1 {

p.next = L.l

L.l = p

}else if i > L.length {

for front.next != nil {

front = front.next

front.next = p

p.next = nil

for j := uint32(2);j < i;j +=1 {

next = front.next

p.next = next

L.length +=1

  p = L.l

for p.next != nil {

fmt.Print(p.next," ")

/* 删除第i個值,線性表長度減一,并用e傳回其值*/

func (L *LinkedList) ListDelete(i uint32)interface{} {

if L.length ==0 {

var resinterface{}

if i > L.length {

i = L.length

res = L.l.val

L.l = L.l.next

var front *slist

var next *slist

front, next = L.l, L.l.next

front = next

next = next.next

res = next.val

front.next = next.next

L.length -=1

  return res

/* 修改第i個值*/

func (L *LinkedList) ListChange(i uint32, vinterface{}) {

return

for j := uint32(1);j < i;j +=1 {

p.val = v

/* 對線性表的每一個函數都調用visit()函數*/

func (L *LinkedList) ListTraverse(ffunc(a ...interface{})) {

for p != nil {

f(p)

func (L *LinkedList) Printf() {

fmt.Print(p," ")

fmt.Println()

func Print(v ...interface{}) {

fmt.Print(v[0].(*slist).val," ")

func main()  {

var l = LinkedList{}

var i int

var c1, c2, v string

for true {

fmt.Println("---------------------------------------------------")

fmt.Println("1) 管理線性表")

fmt.Println("2) 增删改")

fmt.Println("3) 查找")

fmt.Println("4) 列印")

fmt.Scan(&c1)

if c1 !="1" && c1 !="2" && c1 !="3" && c1 !="4" {

switch c1 {

case "1":

fmt.Println("-------------------------------------")

fmt.Println("1) 初始化線性表")

fmt.Println("2) 清空線性表")

fmt.Println("3) 銷毀線性表")

fmt.Println("其他-退出")

fmt.Scan(&c2)

if c2 !="1" && c2 !="2" && c2 !="3" {

            }

switch c2 {

var length uint32

fmt.Print("輸入線性表的長度: ");fmt.Scan(&length)

l.InitList("1", length);

case "2":l.ClearList();

case "3":l.DeleteList();

case "2":

fmt.Println("-------------------------------------------")

fmt.Println("1) 添加一個資料")

fmt.Println("2) 删除一個資料")

fmt.Println("3) 修改資料")

fmt.Print("輸入位置, 值: ")

fmt.Scan(&i, &v)

l.ListInsert(uint32(i), v)

fmt.Print("輸入位置: ")

fmt.Scan(&i)

l.ListDelete(uint32(i))

case "3":

l.ListChange(uint32(i), v)

;

fmt.Println("----------------------------")

fmt.Println("1) 擷取第i個值")

fmt.Println("2) 擷取值第一次出現的位置")

fmt.Println("3) 擷取值第一次出現的位置的前繼值")

fmt.Println("4) 擷取值第一次出現的位置的後繼值")

if c2 !="1" && c2 !="2" && c2 !="3" && c2 !="4" {

case "1":;

fmt.Scanf("%d", &i)

val := l.GetElem(uint32(i))

fmt.Println("第", i,"個值為: ", val)

fmt.Scan(&v)

fmt.Println("值", v,"出現的位置: ", l.LocateElem(v,func(a ...interface{}) bool {

if a[0] == a[1] {

return true

                  }else {

return false

                  }

}))

fmt.Println("值", v,"出現的字首值: ", l.PriorElem(v))

case "4":

fmt.Println("值", v,"出現的字尾值: ", l.NextElem(v))

//l.ListTraverse(Print)

        l.Printf()