2.python实现数据结构-队列

数组实现简单队列

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

    def __str__(self) -> str:
        return '(data=%d)' % self.data


class SimpleQueue(object):
    def __init__(self, max_size):
        self.max_size = max_size
        self.head = None

    def size(self):
        if self.head is None:
            return 0
        size = 0
        temp = self.head
        while temp is not None:
            size += 1
            temp = temp.next
        return size

    def add(self, node: Node):
        if self.head is None:
            self.head = node
            return
        if self.size() < self.max_size:
            temp = self.head
            while temp.next is not None:
                temp = temp.next
            temp.next = node
        else:
            raise Exception("size is full")

    def remove(self, index):
        if self.head is None:
            return
        if self.head.data == index:
            self.head = None
        is_find = False
        temp = self.head
        while temp.next is not None:
            if temp.next is not None:
                if temp.next.data == index:
                    is_find = True
                    break
        if is_find:
            temp.next = temp.next.next
        else:
            raise Exception("no suck element")

    def print(self):
        if self.head is None:
            print("queue is empty")
        temp = self.head
        while temp is not None:
            print(temp, end="->")
            temp = temp.next

    def find(self, data: int) -> int:
        if self.head is None:
            print("queue is empty")
        temp = self.head
        while temp is not None:
            if temp.data == data:
                return temp
            temp = temp.next
        return None

    def update(self, index, data):
        if self.head is None:
            print("queue is empty")
        temp = self.head
        while temp is not None:
            if temp.data == index:
                temp.data = data
            temp = temp.next

    def reverse(self):
        if self.head is None:
            return
        pre = None
        temp = self.head
        while temp is not None:
            next = temp.next
            temp.next = pre
            pre = temp
            temp = next
        self.head = pre


if __name__ == '__main__':
    queue = SimpleQueue(5)
    queue.add(Node(1))
    queue.add(Node(2))
    queue.add(Node(3))
    queue.add(Node(4))
    queue.add(Node(5))
    queue.print()
    print()
    print(queue.find(2))
    queue.update(3, 66)
    print()
    queue.print()
    queue.reverse()
    print()
    queue.print()

双向链表

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

    def __str__(self) -> str:
        return '(data=%d)' % self.data


class DoubleLinkedList(object):
    def __init__(self, max_size):
        self.max_size = max_size
        self.root = None

    def size(self):
        if self.head is None:
            return 0
        size = 0
        temp = self.head
        while temp is not None:
            size += 1
            temp = temp.next
        return size

    def add(self, node):
        if self.root is None:
            self.root = node
        else:
            temp = self.root
            while temp.next is not None:
                temp = temp.next
            temp.next = node
            node.pre = temp

    def del_node(self, index):
        if self.root is None:
            raise Exception("list is empty!")
        else:
            temp = self.root
            while temp is not None:
                if temp.data == index:
                    break
                temp = temp.next
            # find
            if temp is not None:
                if temp.next is not None:
                    temp.pre.next = temp.next
                    temp.next.pre = temp.pre

    def update(self, data, new_data):
        if self.root is None:
            raise Exception("list is empty!")
        else:
            temp = self.root
            while temp is not None:
                if temp.data == data:
                    temp.data = new_data
                    break
                temp = temp.next

    def find(self, data):
        if self.root is None:
            raise Exception("list is empty!")
        else:
            temp = self.root
            while temp is not None:
                if temp.data == data:
                    return temp
                temp = temp.next

    def reverse(self):
        if self.root is None:
            raise Exception("list is empty!")
        else:
            pre = None
            temp = self.root
            while temp is not None:
                next = temp.next
                if next is None:
                    temp.next = pre
                    temp.pre = None
                    self.root = temp
                temp.next = pre
                temp.pre = next
                pre = temp
                temp = next

    def print(self):
        if self.root is None:
            print("queue is empty")
        temp = self.root
        while temp is not None:
            print(temp, end="->")
            temp = temp.next
        print()


if __name__ == '__main__':
    queue = DoubleLinkedList(5)
    queue.add(Node(1))
    queue.add(Node(2))
    queue.add(Node(3))
    queue.add(Node(4))
    queue.add(Node(5))
    queue.print()
    print("find")
    print(queue.find(2))
    queue.update(3, 66)
    print("update")
    queue.print()
    queue.reverse()
    print("reverse")
    queue.print()

环形链表和约瑟夫问题

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

   def __str__(self) -> str:
       return '(data=%d)' % self.data


class CircleLinkedList(object):
   """
       1. 需要注意的是新增的最后一个节点需要连接到first头节点
       2. 如果只有一个头节点 next指向自己
   """

   def __init__(self, max_size):
       self.max_size = max_size
       self.first = None

   def size(self):
       if self.first is None:
           return 0
       else:
           size = 1
           temp = self.first
           while temp.next is not self.first:
               size += 1
               temp = temp.next
           return size

   def add(self, node):
       """
           1. 需要注意的是新增的最后一个节点需要连接到first头节点
       :param node:
       :return:
       """
       if self.first is None:
           self.first = node
           node.next = self.first
       else:
           temp = self.first
           while temp.next is not self.first:
               temp = temp.next
           temp.next = node
           node.next = self.first

   def update(self, data, new_data):
       if self.first is None:
           raise Exception('list is empty!')
       else:
           temp = self.first
           while temp.next != self.first:
               if temp.data == data:
                   temp.data = new_data
                   break
               temp = temp.next

   def del_node(self, data):
       if self.first is None:
           raise Exception('list is empty!')
       else:
           temp = self.first
           is_find = False
           while temp.next != self.first:
               if temp.next.data == data:
                   is_find = True
                   break
               temp = temp.next
           if is_find:
               if temp == self.first:
                   self.first = temp.next
               else:
                   temp.next = temp.next.next

   def reverse(self):
       if self.first is None or self.first.next is None:
           return
       temp = self.first
       while temp.next is not self.first:
           temp = temp.next

       pre = temp
       temp = self.first
       while temp.next is not self.first:
           next = temp.next
           temp.next = pre
           pre = temp
           temp = next
       temp.next = pre
       self.first.next = temp
       self.first = temp

   def print(self):
       if self.first is None:
           print('list is empty!')
       else:
           temp = self.first
           while temp.next is not self.first:
               print(temp, end='->')
               temp = temp.next
           print(temp)

   def find(self, data):
       if self.first is None:
           return None
       temp = self.first
       if temp.data == data:
           return temp
       while temp.next is not self.first:
           if temp.data == data:
               return temp
           temp = temp.next

   def update(self, data, new_data):
       self.find(data).data = new_data

   def josepfu(self, start, count):
       """
       约瑟夫问题实现
       :param start: 起始位置
       :param count: 数几下
       :return:
       """
       if self.first is None:
           return None
       temp = self.first
       while temp.next is not self.first:
           temp = temp.next
       pre = temp
       temp = self.first
       # 移动到开始位置
       for i in range(start):
           temp = temp.next
           pre = pre.next
       # 不重合
       while pre is not temp:
           for i in range(count - 1):
               temp = temp.next
               pre = pre.next
           print(temp)
           temp = temp.next
           pre.next = temp
       print(temp)


if __name__ == '__main__':
   queue = CircleLinkedList(5)
   # queue.add(Node(1))
   # queue.add(Node(2))
   # queue.add(Node(3))
   # queue.add(Node(4))
   # queue.add(Node(5))
   for i in range(41):
       queue.add(Node(i))
   queue.print()
   # print("find")
   # print(queue.find(2))
   # queue.update(3, 66)
   # print("update")
   # queue.print()
   # queue.reverse()
   # print("reverse")
   # queue.print()
   queue.josepfu(1, 3)