单链表，双向链表，单向循环链表的功能实现

单链表的功能实现

# 定义链表的单个结点
class Node():
    # 构造方法初始化结点
    def __init__(self, elem):
        # 初始化数据区
        self.elem = elem
        # 初始化链接区
        self.next = None

# 定义单链表
class single_linked_list():
    # 构造链表，若结点没值指向None
    def __init__(self,node=None):
        # __head代表头结点
        self.__head = node

# 判断链表是否为空
def is_empty(self):
    # head指向None则为空
    return self.__head is None

# 查长度
def length(self):
    # 判断空
    if self.is_empty():
        return 0
    else:
        # 定义游标
        cur = self.__head
        # 计数
        count = 0
        # 循环
        while cur != None:
            # 让游标移动
            cur = cur.next
            count += 1
        return count

def travel(self):

# 遍历，注意进循环后先打印，再移动游标if self.is_empty():
        return
    else:
        # 游标
        cur = self.__head
        while cur != None:
            # 先打印
            print(cur.elem,end= ' ')
            cur = cur.next
        print('')

def append(self,item):
　　#链表尾部添加元素
    # 定义新结点
    node = Node(item)
    if self.is_empty():
        self.__head = node
    else:
        cur = self.__head
        # cur到最后一个结点停下
        while cur.next != None:
            # cur移动
            cur = cur.next
        # 此时，cur到达了最后一个结点
        cur.next = node

def add(self,item):
　　#链表头部添加元素
    # 新结点
    node = Node(item)
    if self.is_empty():
        self.__head = node
    else:
        # 这里顺序不能变
        node.next = self.__head
        self.__head = node

# pos从0开始
def insert(self,pos,item):
    # 特殊判断，友好一点
    if pos < 0:
        self.add(item)
    elif pos > (self.length()-1):
        self.append(item)
    else:
        # 新结点
        node = Node(item)
        pre = self.__head
        count = 0
        while count < (pos -1):
            # 移动游标
            pre = pre.next
            count += 1
        # 此时，pre游标指向插入位置的前一个结点
        # 下面操作顺序不能变
        node.next = pre.next
        pre.next = node

def search(self,item):
　　#查找结点是否存在
    if self.is_empty():
        return False
    else:
        # 定义游标
        cur = self.__head
        while cur != None:
            # 判断cur的数据是否为查找的数据item
            if cur.elem == item:
                return True
            else:
                # 游标移动
                cur = cur.next
        # 遍历完成，cur指向None
        return False

def remove(self,item):
　　#删除元素，这里需要2个游标if self.is_empty():
        return
    else:
        # 定义cur游标
        cur = self.__head
        # 定义pre游标
        pre = None
        # 查找所有的位置有没有要删除的，若有则删
        while cur != None:
            # 判断cur指向的数据，是否为要删的数据
            if cur.elem == item:
                # 考虑特殊情况，恰好要删的是第一个元素
                if cur == self.__head:
                    # 头结点指向后一个结点
                    self.__head = cur.next
                else:
                    # 删除
                    pre.next = cur.next
                return
            else:
                # 移动游标，先移动pre，再移动cur
                pre = cur
                cur = cur.next

#测试

if __name__ == '__main__':
    sll = single_linked_list()
    print(sll.is_empty())
    print(sll.length())
    print('--------------------------')
    sll.travel()
    print('--------------------------')
    sll.append(2)
    sll.add(3)
    sll.append(5)
    sll.travel()
    print('--------------------------')
    print(sll.is_empty())
    print(sll.length())
    print('--------------------------')
    sll.insert(1,'abc')
    sll.travel()
    print(sll.search(5))
    print('--------------------------')
    sll.remove('abc')
    sll.travel()

双向链表的实现

# 实现双链表
class double_linked_list:
    # 构造链表，若结点没值指向None
    def __init__(self,node=None):
        # __head代表头结点
        self.__head = node
    # 判断链表是否为空
    def is_empty(self):
        # head指向None则为空
        return self.__head is None
    # 查长度
    def length(self):
        # 判断空
        if self.is_empty():
            return 0
        else:
            # 定义游标
            cur = self.__head
            # 计数
            count = 0
            # 循环
            while cur != None:
                # 让游标移动
                cur = cur.next
                count += 1
            return count
    def travel(self):
        if self.is_empty():
            return
        else:
            # 游标
            cur = self.__head
            while cur != None:
                # 先打印
                print(cur.elem,end= ' ')
                cur = cur.next
            print('')
#尾插，要处理前驱
def append(self,item):
    node = Node(item)
    if self.is_empty():
        self.__head = node
    else:
        # 移动游标
        cur = self.__head
        while cur.next != None:
            cur = cur.next
        # 此时，cur指向最后一个结点
        cur.next = node
        # 处理前驱结点
        node.prev = cur
#头插

def add(self,item):
    node = Node(item)
    if self.is_empty():
        self.__head = node
    else:
        # 新结点指向原第一个结点
        node.next = self.__head
        self.__head = node
        # 处理原第一个结点的前驱
        node.next.prev = node
#指定位置插入

def insert(self,pos,item):
    if pos < 0:
        self.add(item)
    elif pos > (self.length() -1):
        self.append(item)
    else:
        # 创建结点
        node = Node(item)
        # 游标
        cur = self.__head
        count = 0
        # 因为cur停在后一个位置，所以看图吧
        while count < pos:
            cur = cur.next
            count += 1
        # 此时，cur停在后一个结点
        node.next = cur
        node.prev = cur.prev
        cur.prev.next = node
        cur.prev = node
#删除元素

def remove(self,item):
    if self.is_empty():
        return
    else:
        cur = self.__head
        while cur != None:
            # 对比是否为要删的元素
            if cur.elem == item:
                # 考虑特殊情况，若找到的结点，恰好为第一个结点
                if cur == self.__head:
                    # 头直接指向后一个结点
                    self.__head = cur.next
                    # 考虑链表只有一个结点的情况下，None.prev会出问题
                    if cur.next:
                        cur.next.prev = None
                else:
                    # 当前结点的前一个指向后一个
                    cur.prev.next = cur.next
                    # 考虑后面没有结点的情况
                    if cur.next:
                        cur.next.prev = cur.prev
                return
            else:
                cur = cur.next

#测试

if __name__ == '__main__':
    sll = single_linked_list()
    print(sll.is_empty())
    print(sll.length())
    print('--------------------------')
    sll.travel()
    print('--------------------------')
    sll.append(2)
    sll.add(3)
    sll.append(5)
    sll.travel()
    print('--------------------------')
    print(sll.is_empty())
    print(sll.length())
    print('--------------------------')
    sll.insert(1,'abc')
    sll.travel()
    print(sll.search(5))
    print('--------------------------')
    sll.remove('abc')
    sll.travel()

单向循环链表

# 定义单向循环链表
class single_loop_list:
    def __init__(self,node=None):
        self.__head = node
        # 特殊处理回环
        if node:
            node.next = node
# 求长度

def length(self):
    if self.is_empty():
        return 0
    else:
        cur = self.__head
        # count从1开始
        count = 1
        while cur.next != self.__head:
            # 移动
            cur = cur.next
            count += 1
        return count
# 遍历，注意不要把最后一个漏掉了
def travel(self):
    if self.is_empty():
        return
    else:
        cur = self.__head
        while cur.next != self.__head:
            # 先打印再移动游标
            print(cur.elem,end=' ')
            cur = cur.next
        # 退出循环，cur指向了尾结点
        print(cur.elem,end=' ')
        print('')
# 尾插法，处理回环
def append(self,item):
    node = Node(item)
    if self.is_empty():
        self.__head = node
        # 处理回环
        node.next = node
    else:
        # 游标走到最后
        cur = self.__head
        while cur.next != self.__head:
            cur = cur.next
        # cur此时在最后一个位置
        # 新结点指向头
        node.next = self.__head
        # 原最后结点，指向新结点
        cur.next = node
# 头插，要处理回环

def add(self,item):
    # 结点
    node = Node(item)
    if self.is_empty():
        self.__head = node
        node.next = node
    else:
        cur =self.__head
        # 移动游标
        while cur.next != self.__head:
            cur = cur.next
        # cur停留在最后的位置
        node.next = self.__head
        self.__head = node
        # 形成回环
        cur.next = node
# 指定位置插入，与单向链表一样
# 查找元素，注意别丢下最后一个
def search(self,item):
    if self.is_empty():
        return False
    else:
        # 定义游标
        cur = self.__head
        while cur.next != self.__head:
            # 判断cur的数据是否为查找的数据item
            if cur.elem == item:
                return True
            else:
                # 游标移动
                cur = cur.next
        # 处理最后一个结点
        if cur.elem == item:
            return True
        # 遍历完成，cur指向None
        return False
# 删除元素
def remove(self, item):
    if self.is_empty():
        return
    else:
        cur = self.__head
        pre = None
        # 循环条件
        while cur.next != self.__head:
            # 判断cur的数据是否为要删的数据
            if cur.elem == item:
                if cur == self.__head:
                    # 考虑删的恰好是第一个结点
                    # 考虑回环，还需要一个游标拿到尾结点位置
                    # 这里直接将rear移动到最后即可
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    # 此时rear指向最后一个结点
                    self.__head = cur.next
                    # 回环
                    rear.next = self.__head
                else:
                    # 其他结点
                    pre.next = cur.next
                return
            else:
                # 移动游标
                pre = cur
                cur = cur.next
        # 退出循环时，cur指向最后一个结点
        if cur.elem == item:
            # 考虑只有一个结点
            if cur == self.__head:
                self.__head = None
            else:
                pre.next = cur.next

1. 链表扩展

l 例如下图中P指向一个单独结点，由该结点指向后续元素，实际上这个结点可以保存类似于顺序表的表头，也就是容量和长度，可以继续扩展