Python数据结构与算法之单项循环链表

单项循环链表

      单链表的变形是单项循环链表，链表中的最后一个节点的next域不再为None，而是指向链表的头节点。

操作

• is_empty()：判断链表是否为空
• length()：返回链表的长度
• travel()：遍历
• add(item)：在头部添加一个节点
• append(item)：在尾部添加一个节点
• insert(pos,item)：在指定位置pos添加节点
• remove(item)：删除一个节点
• search(item)：查找结点是否存在

单项循环链表的实现

节点的实现

class Node(object):
    def __init__(self,elem):
        self.elem = elem
        self.next = None

操作实现

class SingleCycleLinkList(object):
    def __init__(self,node=None):
        """单项循环链表"""
        self.__head = None
        if node:
            node.next = node

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

    def length(self):
        """链表的长度"""
        if self.is_empty():
            return 0
        else:
            cur = self.__head
            count = 1
            while cur.next != self.__head:
                count += 1
                cur = cur.next
            return count

    def travel(self):
        """遍历链表"""
        if self.is_empty():
            return
        cur = self.__head
        print(cur.elem,end=" ")
        while cur.next != self.__head:
            cur = cur.next
            print(cur.elem,end=" ")
        print(" ")

头部添加元素：

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
        node.next = self.__head
        self.__head = node
        cur.next = node

尾部添加元素

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
        # 另一种写法
        # node.next = self.__head
        # cur.next = node
        cur.next = node
        node.next = self.__head

指定位置添加元素

def insert(self,pos,item):
    """向链表中的任意位置插入元素，和单链表相同"""
    if pos <= 0:
        self.add(item)
    elif pos > (self.length() - 1):
        self.append(item)
    else:
        pre = self.__head
        count = 0
        node = Node(item)
        while count < (pos-1):
            count += 1
            pre = pre.next
        node.next = pre.next
        pre.next = node

删除节点

def remove(self,item):

    cur = self.__head
    pre = None

    # 判断当前链表是否为空
    if self.is_empty():
        return None
    # 链表不为空
    while cur.next != self.__head:
        if cur.elem == item:
            # 删除首节点
            if cur == self.__head:
                rear = self.__head
                while rear.next != self.__head:
                    rear = rear.next
                self.__head = cur.next
                rear.next = self.__head
            # 中间节点
            else:
                pre.next = cur.next
            return
        # cur.elem != item
        else:
            pre = cur
            cur = cur.next
    # 退出循环，cur指向尾节点
    if cur.elem == item:
        # 只有一个节点
        if cur == self.__head:
            self.__head = None
        # 尾节点
        else:
            pre.next = cur.next
            # 或者是pre.next = self.__head

查找节点是否存在

def search(self,item):
    cur = self.__head
    if self.is_empty():
        return None
    while cur.next != self.__head:
        if cur.elem == item:
            return True
        else:
            cur = cur.next
    if cur.elem == item:
        return True
    return False

测试

if __name__ =="__main__":
    scll = SingleCycleLinkList()
    print(scll.is_empty())
    print(scll.length())
    scll.append(1)
    print(scll.is_empty())
    print(scll.length())
    scll.append(2)
    scll.append(3)
    scll.append(4)
    scll.travel()
    scll.insert(2,100)# 1 2 100 3 4
    scll.travel()
    scll.add(0)
    scll.travel()
    scll.insert(0, 0)  # 0 0 1 2 100 3 4
    scll.travel()
    scll.remove(100)
    scll.travel()
    print(scll.search(100))
    print(scll.search(4))

结果