单链表及其基本操作

　　链表是最基本的数据结构，很多高级的数据结构都离不开链表的身影，本文从最基本的链表实现开始，逐步实现对单链表的判空、求长度、遍历、添加、删除等操作。

1.定义链表节点

　　链表是由一个个数据节点连接而成，首先需要构建数据节点，包含数据元素elem和指向下一节点的next。

class Node(object): 
    """首先定义节点类"""
    def __init__(self, element):  # 构建数据节点时，需要传入数据元素element
        self.elem = element
        self.next = None  # 由于一开始next节点不知道指向什么地方，所以就设置为空

2.初始化单链表

　　初始化链表时，需要一个对象属性指向头结点。

class SingleLinkList(object):
    """定义单链表类"""
    def __init__(self, node = None):  # 构建链表时，需要传入数据节点node，node默认为None
        self. __head = node  # head是私有属性

3.单链表基本操作

3.1.链表判空

　　空链表的头一定是指向None的。

    def is_empty(self):
        """链表是否为空"""
        return self.__head is None

3.2.求链表长度

　　求链表长度就是统计链表节点的个数，可以使用一个游标cur遍历节点，使用一个计数器count记录节点个数。

    def length(self):
        """链表长度"""
        cur = self.__head
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

3.3.遍历链表

    def travel(self):
        """遍历链表"""
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=" ")  # end=" "关闭换行功能,print的原型默认是以end="
"结尾.
            cur = cur.next
        print(end="
")

3.4.往链表头部添加元素

　　往链表中添加元素就相当远添加数据节点，需要传入节点的数据。

　　Tips_1：增删链表时，A=B可以被理解为，使A指向B；

　　Tips_2：增删链表时，需要先保证不破坏原有链表的链接，以保证操作的顺序正确，如需要先node.next = self.__head，再self.__head = node。

    def add(self, item):
        """在链表头部添加元素"""
        node = Node(item)
        node.next = self.__head
        self.__head = node

3.5.往链表尾部添加元素

    def append(self, item):
        """链表尾部添加元素"""
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

3.6.往链表指定位置添加元素

　　需要考虑添加位置的边界条件：如果添加的位置是链表头部，可以直接调用add()函数。如果添加的位置是链表尾部，可以直接调用append()函数。

    def insert(self, pos, item):
        """在指定位置添加元素"""
        if pos <= 0:
            self.add(item)
        elif pos > self.length()-1:
            self.append(item)
        else:
            node = Node(item)
            prev = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

3.7.删除节点

　　链表被打断后，需要pre记录断点前的链表部分。

    def remove(self, item):
        """删除节点"""
        cur = self.__head
        pre = None  
        while cur is not None:
            if cur.elem == item:
                if cur == self.__head:  # 头节点特殊处理
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next

3.8.查找节点

    def search(self, item):
        """查找节点是否存在"""
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

3.9.测试与结果

# 测试
if __name__ == "__main__":
    li = SingleLinkList()
    print(li.is_empty())       # True
    print(li.length())         # 0

    li.append(1)
    print(li.is_empty())       # False
    print(li.length())         # 1

    li.append(2)
    li.add(8)
    li.append(3)
    li.append(4)
    li.append(5)
    li.append(6)
    li.insert(-1, 9)  
    li.insert(2, 100)  
    li.insert(10, 200) 
    li.travel()                # 9 8 100 1 2 3 4 5 6 200

    li.remove(100)
    li.travel()                # 9 8 1 2 3 4 5 6 200
    li.remove(9)  
    li.travel()                # 8 1 2 3 4 5 6 200 
    li.remove(200)  
    li.travel()                # 8 1 2 3 4 5 6