数据结构03-循环单链表和双链表的python实现

东阳的学习记录

循环单链表

循环单链表的特点

• 在任何一个位置上的插入和删除操作都是等价的
• 对单链表唱作的操作是在表头和表尾进行的，此时对单链表不设头指针而设尾指针，操作效率高

循环单链表的实现

我在这里是同时设置了头尾指针。可以去掉头指针。

class Node(object):
    """节点"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SinCycLinkedlist(object):
    """单向循环链表"""
    def __init__(self):
        self._head = None
        self._tail = self._head

    def __str__(self):
        cur = self._head
        li = []
        while cur.next != self._head:
            li.append(cur.item)
            cur = cur.next
        li.append(cur.item)
        return str(li)
        
    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """返回链表的长度"""
        # 如果链表为空，返回长度0
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        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.item)
        while cur.next != self._head:
            cur = cur.next
            print(cur.item)
        print("")


    def add(self, item):
        """头部添加节点"""
        node = Node(item)
        if self.is_empty():
            print("empty")
            self._head = node
            self._tail = self._head
            self._head = self._tail
            self._tail.next = self._head
        else:
            #添加的节点指向_head
            print("not empty")
            node.next = self._head
            #_head指向添加node的
            self._head = node
            self._tail.next = self._head

    def append(self, item):
        """尾部添加节点"""
        node = Node(item)
        self._tail.next = node
        self._tail = node
        self._tail.next = self._head
        
    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
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """删除一个节点"""
        # 若链表为空，则直接返回
        if self.is_empty():
            return
        # 将cur指向头节点
        cur = self._head
        pre = None
        # 若头节点的元素就是要查找的元素item
        if cur.item == item:
            # 如果链表不止一个节点
            if cur.next != self._head:
                # 先找到尾节点，将尾节点的next指向第二个节点
                while cur.next != self._head:
                    cur = cur.next
                # cur指向了尾节点
                cur.next = self._head.next
                self._head = self._head.next
            else:
                # 链表只有一个节点
                self._head = None
        else:
            pre = self._head
            # 第一个节点不是要删除的
            while cur.next != self._head:
                # 找到了要删除的元素
                if cur.item == item:
                    # 删除
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # cur 指向尾节点
            if cur.item == item:
                # 尾部删除
                pre.next = cur.next

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            return True
        while cur.next != self._head:
            cur = cur.next
            if cur.item == item:
                return True
        return False

双链表

双链表的特点

1. 在双链表中执行按行按值查找的操作和单链表相同。
2. 但是，在双链表的插入和删除上，与单链表有较大的不同。双链表可以更方便的找到结点的前驱结点，因此，插入删除指定结点的时间复杂度仅为O(1).（在下面代码中未表现出来）

双链表的实现

class DoubleLinkList():
  """双链表"""
  def __init__(self, node=None):
      self._head = node
  
  def __str__(self):
      li, cur = [], self._head
      while cur is not None:
          li.append(cur.item)
          cur = cur.next
      return str(li)
  
  def is_empty(self):
      """判断链表是否为空"""
      return self._head == None

  def length(self):
      """返回链表的长度"""
      cur = self._head
      count = 0
      while cur != None:
          count += 1
          cur = cur.next
      return count

  def travel(self):
      """遍历链表"""
      cur = self._head
      while cur != None:
          print(cur.item),
          cur = cur.next
      print("")

  def add(self, item):
      """头部插入元素"""
      node = Node(item)
      if self.is_empty():
          # 如果是空链表，将_head指向node
          self._head = node
      else:
          # 将node的next指向_head的头节点
          node.next = self._head
          # 将_head的头节点的prev指向node
          self._head.prev = node
          # 将_head 指向node
          self._head = node

  def append(self, item):
      """尾部插入元素"""
      node = Node(item)
      if self.is_empty():
          # 如果是空链表，将_head指向node
          self._head = node
      else:
          # 移动到链表尾部
          cur = self._head
          while cur.next != None:
              cur = cur.next
          # 将尾节点cur的next指向node
          cur.next = node
          # 将node的prev指向cur
          node.prev = cur

  def search(self, item):
      """查找元素是否存在"""
      cur = self._head
      while cur != None:
          if cur.item == item:
              return True
          cur = cur.next
      return False
  
  def insert(self, pos, item):
      """插入元素"""
      node = Node(item)
      if pos < 0:
          return
      elif pos == 0:
          self.add(item)
      elif pos == self.length() - 1:
          self.append(item)
      else:
          node = Node(item)
          cur = self._head
          count = 0
          while count < pos - 1:
              cur = cur.next
              cout += 1
          node.prev = cur
          node.next = cur.next
          cur.next.prev = node
          cur.next = node
          
  def remove(self, item):
      """删除出现的第一个指定元素"""
      cur = self._head
      while cur is not None:
          if item == cur.item:
              cur.prev.next = cur.next
              cur.next.prev = cur.prev
              return
          cur = cur.next