数据结构：单链表

链表与顺序表统称为线性表。

单项链表

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

• 表元素域elem用来存放具体的数据。
• 链接域next用来存放下一个节点的位置（python中的标识）
• 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

节点实现

# 节点实现
class SingleNode(object):
    """单链表的节点"""
    def __init__(self,item):
        self.item = item
        # 一开始不知道下一个节点对象是谁
        # 这里注意，微观上self.next存储的是下一个节点的地址，而通过地址找到了另一节点，可以参考之前Python基础中的对象概念!
        # 但在宏观上，self.next还是当作节点来处理。
        self.next = None

单链表实现

# 单链表实现
class SingleLinkList(object):
    """单链表"""
    def __init__(self,node = None):
        # 创建的新链表为空，所以node为None，头节点
        # self._head是头节点，没有数据，只有链接域，其中含有第一个节点的地址，此时的游标cur在第一个节点上！
        self._head = node


    def is_empty(self):
        """是否为空"""
        return self._head == None


    def length(self):
        """链表长度"""
        # cur游标遍历结点
        cur = self._head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            # 等距移动游标
            cur = cur.next
        return count


    def travel(self):
        """遍历整个列表"""
        cur = self._head
        while cur != None:
            print(cur.item,end=' ')
            cur = cur.next
        print()

    def add(self,item):
        """链表头部添加元素，头插法"""
        node = SingleNode(item)
        node.next = self._head
        self._head = node


    def append(self,item):
        """链表尾部添加元素，尾插法"""
        node = SingleNode(item)
        if self.is_empty():
            self._head = node
        else:
            cur = self._head
            while cur.next != None:
                cur = cur.next
            cur.next = node


    def insert(self,pos,item):
        """指定位置添加元素
        :param pos 从0开始索引
        """
        node = SingleNode(item)
        cur = self._head
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            i = 0
            while i != (pos-1):
                i += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node


    def remove(self,item):
        """删除结点"""
        cur = self._head
        if cur.item == item:
            self._head = cur.next
        else:
            while cur.next.item != item:
                cur = cur.next
            cur.next = cur.next.next


    def search(self,item):
        """查找结点是否存在"""
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            else:
                cur = cur.next
        return False

测试

if __name__ == '__main__':
    l = SingleLinkList()
    print(l.is_empty())
    print(l.length())

    l.append(55)
    print(l.is_empty())
    print(l.length())

    l.append(7)
    l.append(8)
    l.add(99)
    l.insert(0,666)
    l.add(9999)
    l.remove(99)
    l.travel()
    print(l.search(666))

将三份代码粘贴在同一文件内运行即可得到结果：

True
0
False
1
9999 666 55 7 8 
True

代码解析

代码中的self._head也就是图中的Head，创建的新列表为空，因此SingleLinkList类中初始化的self._head = None，没有数据，由于没有下一节点，所以下一节点的地址也为None。

其次，来看节点类，也就是SingleNode()，这里可以明确看出一个节点需要两个要素，一个是数据，也就是我们上面提到的元素域，一个是下一个节点的地址，也就是链接域。在这里需要注意的一点是：本质上self.next存储的是下一个节点的地址，而通过地址找到了另一节点，但使用时，self.next还是当作一个完整的节点来处理，例如：self.next.item表示下一个节点的数据，可以参考之前文章Python基础中的对象概念!!!

清晰这一点以后就可以很清楚地得到：

cur = self._head

这一语句其实就是将图中Head的内容赋值给cur，也就是游标，但实际上Head中，也就是self._head没有数据，只有链接域，链接域中含有第一个节点的地址，所以cur实际上所在位置是第一节点的位置！cur.next指的是头节点self._head的next属性，其实也就是第一节点的地址，实际使用时就是第一节点。

总的来说， 就是self._head与self.next的链接域中存储的都是下一节点的地址，但实际使用时，是在用它们指向的节点（也可以理解为对象）

经验总结

写代码时，在中间插入某个节点时，先将插入节点与下一节点相连接，再将插入节点与上一节点相连接，这样不会在最开始打乱原链表，会方便一些！

链表与顺序表的区别

链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。

链表与顺序表的各种操作复杂度如下所示：

操作	链表	顺序表
访问元素	O(n)	O(1)
在头部插入/删除	O(1)	O(n)
在尾部插入/删除	O(n)	O(1)
在中间插入/删除	O(n)	O(n)

注意：在中间插入/删除时，虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找，删除和插入操作本身的复杂度是O(1)。顺序表查找很快，主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况，顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作，只能通过拷贝和覆盖的方法进行。