数据结构与算法笔记(4) - 循环单链表

循环单链表是单向链表的一个变体，其中最后一个节点指向链表的第一个节点。

节点类:

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

循环链表:

class LCList(object):
    def __init__(self):
        self._rear = None
        
    def is_empty(self):
        return self._rear is None
        
    def length(self):
        """长度"""
        if self.is_empty():
            return 0
        cur = self._rear.next
        count = 1
        while cur is not self._rear:
            count += 1
            cur = cur.next
        return count
        
    def add(self, elem):
        """首端插入"""
        node = Node(elem)
        if self.is_empty():
            self._rear = node
            node.next = self._rear
        else:
            node.next = self._rear.next
            self.rear.next = node
        
    def append(self, elem):
        """尾端加入"""
        node = Node(elem)
        self.add(elem)
        self._rear = self._rear.next
        
    def insert(self, pos, elem):
        """插入"""
        if pos <= 0:
            self.add(elem)
        elif pos > self.length():
            self.append(elem)
        else:
            idx = 0
            cur = self._rear.next
            while idx <= pos-1:
                idx += 1
                cur = cur.next
            node = Node(elem)
            node.next = cur.next
            cur.next = node
        
    def pop(self):
        """弹出尾部元素"""
        if self.is_empty():
            return -1
        h = self._rear.next
        if h is self._rear:
            self._rear = None
            return h.elem
        while h.next is not self._rear:
            h = h.next
        h.next = self._rear.next
        rear = self._rear
        self._rear = h
        return rear.elem
        
    def delete(self, pos):
        """删除"""   
        if pos < 0 or pos >= self.length():
            return -1
        h = self._rear.next
        if h is self._rear:
            self._rear = None
            return h.elem
        pre = self._rear
        idx = 0
        while idx < pos:
            pre = h
            h = h.next
            idx += 1
        e = h.elem
        pre.next = h.next
        return e
        
    def travel(self):
        """遍历"""
        if self.is_empty():
            return
        h = self._rear
        while h is not self._rear:
            print(h.elem)
            h = h.next
        print(self._rear.elem)
        
    def reverse(self):
        """反转"""
        if self.empty():
            return
        pre = self._rear
        cur = self._rear.next
        if cur is self._rear:
            return
        while cur is not self.rear_:
            n = cur.next
            cur.next = pre
            pre = cur
            cur = n
        _rear = self._rear.next
        self._rear.next = pre
        self._rear = _rear
        
    def sort(self):
        """排序
        
        采用经典排序算法: 插入排序
        排序过程中采用替换指针的方式让链表变的有序

        在当前链表中记录了尾节点，对于排序并不关心尾节点，一次定义了局部变量首节点head，并且定义了临时的尾节点rear, 让rear指向head
        在排序的过程中，从乱序一侧取出的节点如果是最大的，则让rear指向它。
        排序结束后，使链表的 self._rear 指向局部变量 rear, next指向head
        """
        if self.is_empty():
            return
        head = self._rear.next
        cur = head.next
        head.next = None
        rear = head
        while cur is not head:
            h = head
            p = None
            while h and h.elem <= cur.elem:
                p = h
                h = h.next
            if h is None:
                rear = cur
            temp = cur.next
            if p is None:
                head = cur
            else:
                p.next = cur
            cur.next = h
            cur = cur.next
        self._rear = rear
        self._rear.next = head