graph island

Author: KellyHwong

algorithms/heapsort.py

@@ -26,7 +26,13 @@ def main():
 
     # 堆的构造方法就是树的遍历过程的逆过程
     # 左边，右边，下一层，左边，右边
-    # 数据结构，队列，
+    # 数据结构，队列
+    # 构造一个队列，初始头节点
+    # 进一个节点，后面加该节点的左右子节点
+    link_queue = LinkQueue()
+    for i in range(10):
+        link_queue.push(i)
+    link_queue.traverse()
 
 
 if __name__ == "__main__":

datastructure/LinkedList.py

@@ -1,53 +1,57 @@
-class Node:
-    def __init__(self, val=None, next=None):
-        self.val = val
+class SLinkedList:
+    """
+    单链表
+    本身即指针
+    既是节点，也是指针，Python风格
+    """
+
+    def __init__(self, data=None, next=None):
+        self.data = data
         self.next = next
 
-class SLinkedList:
-    def __init__(self):
-        self.head = None
     def traverse(self):
-        ptr = self.head
-        # print(ptr.val)
+        ptr = self
+        # print(ptr.data)
         while ptr:
-            print(ptr.val)
+            # print(ptr.data)
+            yield ptr.data
             ptr = ptr.next
 
     # 一种是非遍历的
     def reverse(self):
-        ptr = self.head
+        ptr = self
         while ptr:
             ptr = ptr.next
             ptr.next.next = ptr
 
     def recursiveReverse(self):
         pass
 
-li = SLinkedList()
-n1 = Node("Mon")
-n2 = Node("Tue")
-n3 = Node("Wed")
-n4 = Node("Thur")
-n5 = Node("Fri")
-n6 = Node("Sat")
-n7 = Node("Sun")
-
-# linking
-n6.next = n7
-n5.next = n6
-n4.next = n5
-n3.next = n4
-n2.next = n3
-n1.next = n2
-li.head = n1
-
-'''
-print(e2.next)
-#结果为e3内存地址<__main__.Node object at 0x0000001A0F9644BE0>
-print(e2.next.val)
-#结果为e3所代表的值Wed
-'''
-
-li.traverse()
-# 翻转链表
 
+if __name__ == "__main__":
+
+    n1 = SLinkedList("Mon")
+    n2 = SLinkedList("Tue")
+    n3 = SLinkedList("Wed")
+    n4 = SLinkedList("Thur")
+    n5 = SLinkedList("Fri")
+    n6 = SLinkedList("Sat")
+    n7 = SLinkedList("Sun")
+
+    # linking
+    n6.next = n7
+    n5.next = n6
+    n4.next = n5
+    n3.next = n4
+    n2.next = n3
+    n1.next = n2
+
+    '''
+    print(e2.next)
+    # 结果为e3内存地址<__main__.Node object at 0x0000001A0F9644BE0>
+    print(e2.next.data)
+    # 结果为e3所代表的值Wed
+    '''
+
+    n1.traverse()
+    # 翻转链表 TODO

datastructure/graph.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Date    : 2019-06-24 20:20:50
+# @Author  : Your Name ([email protected])
+# @Link    : https://zh.wikipedia.org/wiki/%E5%9B%BE_(%E6%95%B0%E5%AD%A6)
+# @Version : $Id$
+
+import os
+import itertools
+from linkedlist import SLinkedList
+
+
+class GraphNode(object):
+    """
+    图的节点，C风格写法
+    """
+
+    def __init__(self, data=None, adjacent: SLinkedList = None):
+        self.data = data
+        self.adjacent = adjacent
+        self.adjacent_set = None  # TODO 使用Python的set数据结构
+
+
+if __name__ == "__main__":
+    test = [[1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12]]
+    # 矩阵转化为图
+    l = []
+    h = len(test)
+    w = len(test[0])
+    coords = list(itertools.product(list(range(h)), list(range(w))))
+    for c in coords:
+        data = (c, test[c[0]][c[1]])  # 坐标元组 和 数据 # 这样数据存了两份，但好处是原来的矩阵不需要
+        # 双指针法构造邻接链表
+        adj = None  # SLinkedList()
+        ptr = None
+        # 邻接表存的是索引，不是指针，索引可以用hash
+        # 但这里用顺序表
+        # 上下左右，相邻
+        for c2 in [(c[0]+1, c[1]), (c[0]-1, c[1]), (c[0], c[1]+1), (c[0], c[1]-1)]:
+            if (0 <= c2[0] < h) and (0 <= c2[1] < w):
+                new = SLinkedList(data=c2, next=None)
+                if not ptr:
+                    ptr = new
+                    adj = ptr
+                else:
+                    ptr.next = new
+                    ptr = ptr.next
+
+        node = GraphNode(data=data, adjacent=adj)
+        l.append(node)  # l中存入元素
+
+    print(l[0].adjacent)
+    # traverse
+    for _ in l[7].adjacent.traverse():
+        print("travers coord:", _)
+        print("travers data:", test[_[0]][_[1]])

heapsort.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Date    : 2019-06-24 21:11:06
+# @Author  : Your Name ([email protected])
+# @Link    : http://example.org
+# @Version : $Id$
+
+import os
+import itertools
+from linkedlist import SLinkedList
+
+
+class GraphNode(object):
+    """
+    图的节点，C风格写法
+    """
+
+    def __init__(self, data=None, adjacent: SLinkedList = None):
+        self.data = data
+        self.adjacent = adjacent
+        self.adjacent_set = None  # TODO 使用Python的set数据结构
+
+
+if __name__ == "__main__":
+    island_grids = [["1", "1", "1", "1", "0"],
+                    ["1", "1", "0", "1", "0"],
+                    ["1", "1", "0", "0", "0"],
+                    ["0", "0", "0", "0", "0"]]
+    # 矩阵转化为图
+    l = []
+    h = len(test)
+    w = len(test[0])
+    coords = list(itertools.product(list(range(h)), list(range(w))))
+    for c in coords:
+        data = (c, test[c[0]][c[1]])  # 坐标元组 和 数据 # 这样数据存了两份，但好处是原来的矩阵不需要了
+        # 双指针法构造邻接链表
+        adj = None  # SLinkedList()
+        ptr = None
+        # 邻接表存的是索引，不是指针，索引可以用hash
+        # 但这里用顺序表
+        # 上下左右，相邻
+        for c2 in [(c[0]+1, c[1]), (c[0]-1, c[1]), (c[0], c[1]+1), (c[0], c[1]-1)]:
+            if (0 <= c2[0] < h) and (0 <= c2[1] < w):
+                new = SLinkedList(data=c2, next=None)
+                if not ptr:
+                    ptr = new
+                    adj = ptr
+                else:
+                    ptr.next = new
+                    ptr = ptr.next
+
+        node = GraphNode(data=data, adjacent=adj)
+        l.append(node)  # l中存入元素
+
+    print(l[0].adjacent)
+    # traverse
+    l[7].adjacent.traverse()

leetcode/num-of-island-graph.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Date    : 2019-06-24 20:24:23
+# @Author  : Your Name ([email protected])
+# @Link    : https://leetcode.com/problems/number-of-islands
+# @Version : $Id$
+
+import os
+import itertools
+
+
+def belongTo(c: tuple, island: list):
+    for _ in island:
+        if c in [(_[0]+1, _[1]), (_[0]-1, _[1]), (_[0], _[1]+1), (_[0], _[1]-1)]:
+            return True
+    return False
+
+
+class Solution:
+    def numIslands(self, grid: list) -> int:
+        if grid == []:
+            return 0
+        h = len(grid)
+        w = len(grid[0])
+        coords = list(itertools.product(list(range(h)), list(range(w))))
+        # print(coords)
+        one_coords = []
+        for c in coords:
+            if grid[c[0]][c[1]] == '1':
+                one_coords.append(c)
+        # print(one_coords)
+        islands = []
+        island = []
+        for c in one_coords:
+            if island == []:
+                island.append(c)
+            elif belongTo(c, island):
+                island.append(c)
+                # print(island)
+            else:
+                islands.append(island)
+                # print(islands)
+                island = []
+        if islands == []:
+            islands.append(island)
+        # print(len(islands))
+        return len(islands)
+
+
+def main():
+    test = [["1", "1", "1", "1", "0"],
+            ["1", "1", "0", "1", "0"],
+            ["1", "1", "0", "0", "0"],
+            ["0", "0", "0", "0", "0"]]
+    sol = Solution()
+    print(sol.numIslands(test))
+
+
+if __name__ == "__main__":
+    main()