一、线性表的存储结构

1）顺序表

var maxSize int = 10
type SqList struct {
    data [maxSize]int
    length int
}
func NewArrayList() *SqList {
    list := new(SqList)                      //初始化结构体
    list.data = make([]interface{}, 0, maxSize) // 开辟空间10个
    list.TheSize = 0
    return list
}

顺序表就是把线性表的所有元素按照其逻辑顺序，一次存储到从指定的存储位置开始的一块连续的存储空间。

• 特点:
  1.随机访问特性
  2.占用连续的存储空间
  3.做插入操作需要移动多个元素
• 操作

# 查找元素 x在递增顺序表的的可插入位置(不打乱书序)
func findElem(L SqList, x int) int {
    var i int
    for i=0;i<L.TheSize;i++{
        if x < L.data[i].(int) {
            return i
        }
    }
    return i
}
# 插入元素
func insertElem(L *SqList, x int) {
    var p, i int
    p = findElem(*L, x) // 调用函数findElem()来找到插入位置p
    for i = L.TheSize - 1; i >= p; i-- {
        L.data[i+1] = L.data[i] //从右往左,逐个将元素右移一个位置
    }
    L.data[p] = x // 将x放入插入位置p上
    L.TheSize++ // 表内元素多了一个,因此表长自增1
}

• 按照元素查找
  思路:在顺序表中查找第一个值等于e的元素,并返回其下标

# 按元素值的查找算法
func findElem (l SqList, e int) int {
    var i int
    for i=0;i<l.TheSize;i++{
        if e==l.data[i].(int) {
            return i
        }
    }
    return -1
}

插入数据元素的算法
思路:在顺序表L的p位置插入新元素e.如果p的输入不正确,则返回0,代表插入失败:如果p的输入正确,则将顺序表第p个元素及以后的元素右移一个位置,腾出一个空位置插入新元素,顺序表长度增加1,插入操作成功,返回1.

# 插入数据元素的算法
func insertElem(L *SqList, p, e int) int {
    var i int
    if p<0 || p>L.TheSize || L.TheSize == maxSize {
        return 0
    }
    for i=L.TheSize-1;i>=p;i-- {
        L.data[i+1] = L.data[i]
    }
    L.data[p] = e
    L.TheSize++
    return 1
}

2）链表

每个节点不仅包含所有元素的信息，还包含元素之间逻辑关系的信息。

• 特点:
  1.不支持随机访问
  2.节点的存储空间利用率较顺序表稍低一些(每一个节点需要划分一部分空间来存储指向下一个节点位置的指针)
  3.支持存储空间的动态分配
  4.插入操作无须移动元素
• 五种形式
  1.单链表

type LinkList struct {
    Data map[string]interface{}
    NextNode *LinkList
}

2.双链表

type LinkList struct {
    Data map[string]interface{}
    LNode *LinkList // 指向前驱结点的指针
    NextNode *LinkList // 指向后继结点的指针
}

3.循环单链表
4.循环双链表
5.静态链表
待更新……………