Merge pull request #163 from MGLEE-RUSH/master

upload from origin

Author: wangzheng0822

python/06_linkedlist/singlyLinkedList.py

@@ -0,0 +1,284 @@
+# 1.单链表的插入、删除、查找操作；
+# 2.链表中存储的数据类型是Int
+#
+# Author:Lee
+
+class Node():
+    '''链表结构的Node节点'''
+
+    def __init__(self, data, next=None):
+        '''Node节点的初始化方法.
+        参数:
+            data:存储的数据
+            next:下一个Node节点的引用地址
+        '''
+        self.__data = data
+        self.__next = next
+
+    @property
+    def data(self):
+        '''Node节点存储数据的获取.
+        返回:
+            当前Node节点存储的数据
+        '''
+        return self.__data
+
+    @data.setter
+    def data(self, data):
+        '''Node节点存储数据的设置方法.
+        参数:
+            data:新的存储数据
+        '''
+        self.__data = data
+
+    @property
+    def next(self):
+        '''获取Node节点的next指针值.
+        返回:
+            next指针数据
+        '''
+        return self.__next
+
+    @next.setter
+    def next(self, next):
+        '''Node节点next指针的修改方法.
+        参数:
+            next:新的下一个Node节点的引用
+        '''
+        self.__next = next
+
+
+class SinglyLinkedList():
+    '''单向链表'''
+
+    def __init__(self):
+        '''单向列表的初始化方法.'''
+        self.__head = None
+
+    def find_by_value(self, value):
+        '''按照数据值在单向列表中查找.
+        参数:
+            value:查找的数据
+        返回:
+            Node
+        '''
+        node = self.__head
+        if node != None and node.data != value:
+            node = node.next
+        else:
+            return node
+
+    def find_by_index(self, index):
+        '''按照索引值在列表中查找.
+        参数:
+            index:索引值
+        返回:
+            Node
+        '''
+        node = self.__head
+        pos = 0
+        while node != None and pos != index:
+            node = node.next
+            pos += 1
+        return node
+
+    def insert_to_head(self, value):
+        '''在链表的头部插入一个存储value数值的Node节点.
+        参数:
+            value:将要存储的数据
+        '''
+        node = Node(value)
+        node.next = self.__head
+        self.__head = node
+
+    def insert_after(self, node, value):
+        '''在链表的某个指定Node节点之后插入一个存储value数据的Node节点.
+        参数:
+            node:指定的一个Node节点
+            value:将要存储在新Node节点中的数据
+        '''
+        if node == None:  # 如果指定在一个空节点之后插入数据节点，则什么都不做
+            return
+
+        new_node = Node(value)
+        new_node.next = node.next
+        node.next = new_node
+
+    def insert_before(self, node, value):
+        '''在链表的某个指定Node节点之前插入一个存储value数据的Node节点.
+        参数:
+            node:指定的一个Node节点
+            value:将要存储在新的Node节点中的数据
+        '''
+        if node == None or self.__head == None:  # 如果指定在一个空节点之前或者空链表之前插入数据节点，则什么都不做
+            return
+
+        if node == self.__head:  # 如果是在链表头之前插入数据节点，则直接插入
+            self.insert_to_head(value)
+            return
+
+        new_node = Node(value)
+        pro = self.__head
+        not_found = False  # 如果在整个链表中都没有找到指定插入的Node节点，则该标记量设置为True
+        while pro.next != node:  # 寻找指定Node之前的一个Node
+            if pro.next == None:  # 如果已经到了链表的最后一个节点，则表明该链表中没有找到指定插入的Node节点
+                not_found = True
+                break
+            else:
+                pro = pro.next
+        if not_found == False:
+            pro.next = new_node
+            new_node.next = node
+
+    def delete_by_node(self, node):
+        '''在链表中删除指定Node的节点.
+        参数:
+            node:指定的Node节点
+        '''
+        if self.__head == None:  # 如果链表是空的，则什么都不做
+            return
+
+        if node == self.__head:  # 如果指定删除的Node节点是链表的头节点
+            self.__head = node.next
+            return
+
+        pro = self.__head
+        not_found = False  # 如果在整个链表中都没有找到指定删除的Node节点，则该标记量设置为True
+        while pro.next != node:
+            if pro.next == None:  # 如果已经到链表的最后一个节点，则表明该链表中没有找到指定删除的Node节点
+                not_found == True
+                break
+            else:
+                pro = pro.next
+        if not_found == False:
+            pro.next = node.next
+
+    def delete_by_value(self, value):
+        '''在链表中删除指定存储数据的Node节点.
+        参数:
+            value:指定的存储数据
+        '''
+        if self.__head == None:  # 如果链表是空的，则什么都不做
+            return
+
+        if self.__head.data == value:  # 如果链表的头Node节点就是指定删除的Node节点
+            self.__head = self.__head.next
+
+        pro = self.__head
+        node = self.__head.next
+        not_found = False
+        while node.data != value:
+            if node.next == None:  # 如果已经到链表的最后一个节点，则表明该链表中没有找到执行Value值的Node节点
+                not_found == True
+                break
+            else:
+                pro = node
+                node = node.next
+        if not_found == False:
+            pro.next = node.next
+
+    def delete_last_N_node(self, n):
+        '''删除链表中倒数第N个节点.
+        主体思路：
+            设置快、慢两个指针，快指针先行，慢指针不动；当快指针跨了N步以后，快、慢指针同时往链表尾部移动，
+            当快指针到达链表尾部的时候，慢指针所指向的就是链表的倒数第N个节点
+        参数:
+            n:需要删除的倒数第N个序数
+        '''
+        fast = self.__head
+        slow = self.__head
+        step = 0
+
+        while step <= n:
+            fast = fast.next
+            step += 1
+
+        while fast.next != None:
+            tmp = slow
+            fast = fast.next
+            slow = slow.next
+
+        tmp.next = slow.next
+
+    def find_mid_node(self):
+        '''查找链表中的中间节点.
+        主体思想:
+            设置快、慢两种指针，快指针每次跨两步，慢指针每次跨一步，则当快指针到达链表尾部的时候，慢指针指向链表的中间节点
+        返回:
+            node:链表的中间节点
+        '''
+        fast = self.__head
+        slow = self.__head
+
+        while fast.next != None:
+            fast = fast.next.next
+            slow = slow.next
+
+        return slow
+
+    def create_node(self, value):
+        '''创建一个存储value值的Node节点.
+        参数:
+            value:将要存储在Node节点中的数据
+        返回:
+            一个新的Node节点
+        '''
+        return Node(value)
+
+    def print_all(self):
+        '''打印当前链表所有节点数据.'''
+        pos = self.__head
+        if pos == None:
+            print('当前链表还没有数据')
+            return
+        while pos.next != None:
+            print(str(pos.data) + ' --> ', end='')
+            pos = pos.next
+        print(str(pos.data))
+
+    def reversed_self(self):
+        '''翻转链表自身.'''
+        if self.__head == None or self.__head.next == None:  # 如果链表为空，或者链表只有一个节点
+            return
+
+        pre = self.__head
+        node = self.__head.next
+        while node != None:
+            pre, node = self.__reversed_with_two_node(pre, node)
+
+        self.__head.next = None
+        self.__head = pre
+
+    def __reversed_with_two_node(self, pre, node):
+        '''翻转相邻两个节点.
+        参数:
+            pre:前一个节点
+            node:当前节点
+        返回:
+            (pre,node):下一个相邻节点的元组
+        '''
+        tmp = node.next
+        node.next = pre
+        pre = node  # 这样写有点啰嗦，但是能让人更能看明白
+        node = tmp
+        return (pre, node)
+
+    def has_ring(self):
+        '''检查链表中是否有环.
+        主体思想：
+            设置快、慢两种指针，快指针每次跨两步，慢指针每次跨一步，如果快指针没有与慢指针相遇而是顺利到达链表尾部
+            说明没有环；否则，存在环
+        返回:
+            True:有环
+            False:没有环
+        '''
+        fast = self.__head
+        slow = self.__head
+
+        while fast.next != None and fast != None:
+            fast = fast.next
+            slow = slow.next
+            if fast == slow:
+                return True
+
+        return False