python进阶笔记（1）——单向链表、单向循环链表、双向链表

链表

链表（Linked list） 是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。

链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

单向链表

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。
对单链表进行操作需要先设置节点。
我们知道一个节点分两个区域，前一个区域存放数据，后一个区域存放下一个节点的位置信息（该位置信息默认为None，因为最后一个节点指向一个空地址）。
所以，代码如下：

class SingleNode:
    def __init__(self,item):
        # item存放数据
        self.item = item
        # next存放地址，初始默认为空
        self.next = None

单链表的操作

对于单链表，常用的操作有如下几个：

• is_empty()：判断链表是否为空。
• length()：l链表长度。
• travel()：遍历整个链表。
• add(item)：链表头部添加元素。
• append(item)：链表尾部添加元素。
• insert(pos,item)：链表指定位置添加元素。
• remove(item)：删除节点。
• search(item)：查找节点。
  这几个常用方法也是剩下两个链表的常用方法。

is_empty()

判断链表是否为空是进行增删改查之前的必要操作，因为没有该判断，控制台会报错——'NoneType' object has no attribute 'item'。

class SingleNode:
    def __init__(self,item):
        # item存放数据
        self.item = item
        # next存放地址，初始默认为空
        self.next = None

class SingleLinkList:
    def __init__(self):
    	# 设置头节点（第一个节点）为空
        self.__head = None

    def empty(self):
        """判断链表是否为空"""
        return self.__head == None # 这里是一个判断语句，返回一个布尔值True或False，是if...else...语句的简写

if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.empty())

length()

读取链表长度对insert()等操作有极大帮助。
代码如下：

在原代码的基础上加上：
	...
    def length(self):
        if self.is_empty():
            return 0
        count = 1
        cur = self.__head # 设置临时节点
        while cur != None: # 当临时节点的next不是指向头节点时进行循环
            count += 1
            cur = cur.next # 向下一个节点遍历
        return count
     
     ...
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    print(list1.length())

travel()

在原代码的基础上加上：
	...
    def travel(self):
        """遍历链表"""
        cur = self.__head # 设置临时节点在头节点位置
        while cur != None:
        	print(cur.item) # item对应SingleNode类中的item
            cur = cur.next # 遍历，让临时节点不断指向下一个节点
            
    ...
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    print(list1.length())
    list1.travel()

add(item)

在原代码的基础上加上：
	...
    def add(self,item):
        """头部添加"""
        node = SingleNode(item) # 生成节点，存储需要添加的数据
        # 将生成节点的next指向头节点
        node.next = self.__head
        # 将node放入头节点
        self.__head = node
     ...
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    print(list1.length())

    list1.add('a')
    list1.travel()

append(item)

在原代码的基础上加上：
	...
    def append(self,item):
        """尾部添加"""
        node = SingleNode(item)
        cur = self.__head
        while cur.next != None: # 只要临时指针的下一个节点不为空，就继续往下遍历，直到最后一个
            cur = cur.next # 这里cur已经是最后一个节点了
        cur.next = node # cur.next是个空节点，所以将node放入该节点即为尾部添加
        
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    print(list1.length())

    list1.add('a')

    list1.append(1)
    list1.travel()

insert(pos,item)

在原代码的基础上加上：
	...
        def insert(self,pos,item):
        """指定位置插入"""
        if pos <= 0:
            # 头部插入
            self.add(item)
        elif pos > self.length()-1:
            # 尾部插入
            self.append(item)
        else:
            # 插入节点node
            node = SingleNode(item)
            # 遍历节点数初始值为0
            count = 0
            # 建立临时节点
            cur = self.__head
            # 开始遍历
            while count < pos-1:
                count += 1
                cur = cur.next
            # 注意点
            # 先将插入节点的next指向临时节点的下一位节点位置
            node.next = cur.next
            # 再将临时节点的next指向node
            cur.next = node
        
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    print(list1.length())

    list1.add('a')

    list1.append(1)
    list1.insert(1,'n')
    list1.travel()

注意点：当遍历结束后，节点插入的两句代码顺序不能弄错，因为=符号是赋值符号，程序中代码说是指向，实际上是赋值，如果两句话反过来，cur.next就会被node占用，这个时候node.next指向就不是cur的下个节点位置而是node了，也就是cur.next被node替代了。

remove(item)

在原代码的基础上加上：
...
    def remove(self,item):
    	"""删除节点"""
        cur  = self.__head # 设置临时节点cur位于头节点
        # 设置临时节点的前一个节点pre
        pre = None
        # 遍历
        while cur != None:
            # 当找到要删除的节点
            if cur.item == item:
                # 如果刚好是第一个，pre是None
                if not pre:
                    # 这里cur位于头节点位置，意思是将头节点指向cur的下一个节点位置
                    self.__head = cur.next
                else:
                    # 如果不是第一个，前一个节点pre的next指向当前（临时）节点的下一个节点
                    pre.next = cur.next
                break
            else:
                # 同样的顺序不能出错
                # 遍历，前一个节点向cur节点位置遍历
                pre = cur
                # cur向下一个节点位置遍历
                cur = cur.next

search(item)

    def search(self,item):
        """索引节点"""
        # 设置临时节点位于头节点
        cur = self.__head
        # 遍历
        while cur != None:
            # cur所处节点与指定节点相符返回True，不符合继续向下遍历
            if cur.item == item:
                print('------')
                return True
            else:
                cur = cur.next
        else:
            # 遍历完所有节点后，还没找到指定节点返回False
            return False

单向循环链表

单向循环链表和单向链表的区别在于链表中最后一个节点的next域不再为None，而是指向链表的头节点。
即 cur.next = self.__head

下面是各个常用方法的实现，具体解释都在代码行里。

class SingleNode:
    def __init__(self,item):
        """初始化单向循环链表"""
        self.item = item
        self.next = None

class SingleLinkList:
    def __init__(self):
        """初始化头节点"""
        self.__head = None

    def is_empty(self):
        return self.__head == None

    def length(self):
        """链表长度"""
        # 当链表为空
        if self.is_empty():
            return 0
        # 当链表不为空，设置长度计数初始值为1，设置临时节点位于头节点
        # 如果只有头节点，链表长度为1
        count = 1
        cur = self.__head
        # 遍历，当临时节点的next不是指向头节点时
        while cur.next != self.__head:
            # 长度计数加1，cur开始向下移动
            count += 1
            cur = cur.next
        # 遍历完成后，返回计数长度count
        return count

    def travel(self):
        """遍历"""
        if self.is_empty():
            return 0
        # 建立临时节点cur
        cur = self.__head
        print(cur.item)
        while cur.next != self.__head:
            cur = cur.next
            print(cur.item)

    def add(self,item):
        """头部添加"""
        # 建立节点node存储参数item
        node = SingleNode(item)
        # 当链表为空
        if self.is_empty():
            # 头节点存放指定节点元素
            self.__head = node
            # 由于单向循环链表的性质，其尾节点的next是指向头节点的，所以这里node的next也是指向头节点
            node.next = self.__head
        else:
            # 如果不是空链表
            # node的next指向头节点
            node.next = self.__head
            # 建立临时节点位于原头节点的位置
            cur = self.__head
            # 遍历，直到cur指向尾节点
            while cur.next != self.__head:
                cur = cur.next
            # 此时cur的next指向node，也就是现在的头节点
            cur.next = node
            # 头节点指向node，此时头节点已经被node取代
            self.__head = node

    def append(self,item):
        """尾部添加"""
        # 建立节点node存储参数item
        node = SingleNode(item)
        # 当链表为空
        if self.is_empty():
            # 和头部添加一样，直接将node放入头节点位置
            self.__head = node
            # node的next指向头节点
            node.next = self.__head
        else:
            # 如果不是空链表
            # 建立临时节点位于头节点位置
            cur = self.__head
            # 遍历到尾部节点
            while cur.next != self.__head:
                cur = cur.next
            # 此时cur位于尾部节点，cur的next指向node
            cur.next = node
            # node的next指向头节点，形成单向循环链表
            node.next = self.__head

    def insert(self,pos,item):
        """插入节点"""
        # pos表示节点位置，超出链表范围的情况有两个
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            # 未超出链表范围
            # 建立节点node存储参数item
            node = SingleNode(item)
            # 建立临时节点位于头节点位置
            cur = self.__head
            # 设置循环用参数
            count = 0
            # 遍历到pos所指位置，这里(pos-1)是因为计数从0开始
            while count < (pos - 1):
                count += 1
                cur = cur.next
            # node的next指向cur的下一个节点
            node.next = cur.next
            # cur的next指向node
            cur.next = node

    def remove(self,item):
        """删除节点"""
        # 空链表返回0
        if self.is_empty():
            return 0
        # 设置临时节点位于头节点
        cur = self.__head
        # 设置cur的前一个节点pre
        pre = None
        # 遍历
        while cur.next != self.__head:
            # 找到item
            if cur.item == item:
                # 如果刚好是第一个
                if cur == self.__head:
                    # 设置临时节点tail
                    tail = self.__head
                    # tail节点遍历到尾节点
                    while tail.next != self.__head:
                        tail = tail.next
                    # 头节点指向cur的下一个节点
                    self.__head = cur.next
                    # 尾节点的next指向头节点
                    tail.next = self.__head
                else:
                    # 如果不是第一个，pre的next直接指向cur（即将被删除的节点）的下一个节点
                    pre.next = cur.next
                # 返回退出内循环
                return
            else:
                # 没找到则继续往下遍历，pre指向cur的位置，
                pre = cur
                # cur指向cur的下一个位置
                cur = cur.next
        # cur在最后，要删除最后一个节点
        if cur.item == item:
            # 如果只有一个节点
            if cur.next == self.__head:
                # 头节点为None
                self.__head = None
            else:
                # 否则pre的next指向头节点
                pre.next = self.__head

    def search(self,item):
        """查询链表元素"""
        # 空链表返回0
        if self.is_empty():
            return 0
        # 设置临时节点cur位于头节点
        cur = self.__head
        # 当查询的元素刚好位于头节点时
        if cur.item == item:
            return True
        # 当查询的元素位于除头节点外的节点时，开始遍历
        while cur.next != self.__head:
            # 找到元素
            if cur.item == item:
                return True
            # 没找到继续遍历
            cur = cur.next
            # 遍历完还没找到直接返回False
        return False

# 测试代码
if __name__ == '__main__':
    list1 = SingleLinkList()
    print(list1.is_empty())
    list1.add('a')
    list1.add('b')
    list1.add('c')
    list1.add('d')
    list1.travel()
    print(list1.search('d'))

双向链表

双向链表是一种更为复杂的链表。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

常用操作（常用方法）

和上面两个链表没什么区别。还是那几个方法：判断空表、计算长度、表头（表中、表尾）插入、删除、遍历、检索。

# 双向链表
class DoubleNode:
    """双向链表的节点"""
    """
    和单向（循环）链表不同的地方在于，
    由于双向链表的每个链接都有两个链接，
    所以需要存储两个节点，prev和next，
    分别代表指向前一个节点和指向后一个节点。
    """
    def __init__(self,item):
        """初始化节点"""
        self.item = item
        self.prev = None
        self.next = None

class DoubleLinkList:
    """双向链表"""

    def __init__(self):
        # 初始化头节点
        self.__head = None

    def is_empty(self):
        # 判断空表
        return self.__head == None

    def length(self):
        # 计算长度
        # 如果是空链表，调用判断空表的方法
        if self.is_empty():
            return 0
        cur = self.__head  # 设置临时节点
        count = 0  # 设置计数值
        # 当临时节点位于非空节点上时，计数+1，cur向下移动
        while cur != None:
            count += 1
            cur = cur.next
        # 返回计数
        return count

    def travel(self):
        """遍历"""
        # 判断为空在遍历里可要可不要，无影响
        # if self.is_empty():
        #     return 0
        # 建立临时节点
        cur = self.__head
        # 遍历，输出，cur往下移动
        while cur != None:
            print(cur.item)
            cur = cur.next

    def search(self,item):
        """搜索"""
        # 判断空表
        if self.is_empty():
            return 0
        # 建立临时节点
        cur = self.__head
        # 临时节点所在位置的item区域正好是用户输入的item参数时
        if cur.item == item:
            return True
        # 如果不是，开始遍历
        while cur != None:
            # 同上
            if cur.item == item:
                return True
            # 没找到就cur向下移动
            cur = cur.next
        # 遍历结束还没找到就返回False
        return False

    def add(self,item):
        # 生成一个节点
        node = DoubleNode(item)
        # 链表为空的情况
        if self.is_empty():
            # 直接将node插入头节点位置
            self.__head = node
        else:
            # 将node的next指向原来的头节点
            node.next = self.__head
            # 将原来头节点的前一个节点设置为当前的node
            self.__head.prev = node
            # 头节点指向node
            self.__head = node

    def append(self,item):
        """尾部添加"""
        node = DoubleNode(item)
        if self.is_empty():
            # 链表为空的情况
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            # 原来尾节点的next 指向了新节点
            cur.next = node
            # 新节点的prev指向cur
            node.prev = cur

    def insert(self,pos,item):
        """指定位置添加"""
        # 指定的位置小于等于0时调用add方法
        if pos <= 0:
            self.add(item)
        # 指定的位置大于最大长度-1，这是因为链表也遵守从0开始计数的原则
        if pos > self.length() - 1:
            # 此时pos指向最后一个节点，调用append方法
            self.append(item)
        else:
            # 准备参数item
            node = DoubleNode(item)
            # count计数
            count = 0
            # 临时节点cur
            cur = self.__head
            # 遍历到(pos-1)位置
            while count < pos - 1:
                count += 1
                cur = cur.next
            # node的prev指向cur
            node.prev = cur
            # node的next指向cur的下一个节点
            node.next = cur.next
            # cur的下一个节点的prev指向node
            cur.next.prev = node
            # cur的next指向node
            cur.next = node

    def remove(self,item):
        """删除元素"""
        # 临时节点
        cur = self.__head
        # 遍历节点
        while cur != None:
            # 找到节点
            if cur.item == item:
                # 临时节点在头部
                if cur == self.__head:
                    # 头节点向下移动，原头节点消失
                    self.__head = cur.next
                    # 如果不止一个节点
                    if cur.next:
                        # 临时节点的下一个节点的prev指向None
                        cur.next.prev = None
                # 如果不是在头节点
                else:
                    # cur前一个节点的next指向cur的下一个节点，即cur指向的节点消失
                    cur.prev.next = cur.next
                    # 如果cur的下一个节点存在
                    if cur.next:
                        # cur的下一个节点的prev指向cur的前一个节点
                        cur.next.prev = cur.prev
                # 记得要退出循环
                break
            # 如果while循环没有找到节点
            else:
                # 向下遍历
                cur = cur.next

if __name__ == '__main__':
    L2 = DoubleLinkList()
    L2.travel()
    L2.add("haha")
    L2.add(5)
    L2.add(4)
    L2.append(2)
    L2.travel()
    print(L2.length())
    print(L2.search('haha'))
    L2.insert(1,"heihei")
    print('---------------------')
    L2.travel()
    print('---------------------')
    L2.remove(3)
    L2.travel()