pusding das to codesee

data_struct/myexamples/algo/bfs.py

@@ -0,0 +1,47 @@
+def how_it_workd(data, start, end, visited=[]):
+    queue = [start]
+
+    while queue:
+        current_node = queue.pop(0)
+
+        visited.append(current_node)
+        print(visited)
+
+        for i in data[current_node] - set(visited):
+            print("for looped --> {}".format(i))
+            print()
+            queue.append(i)
+
+    print("wants the data being bf-searched")
+    print(data)
+
+
+def bfs(data, start, end, visited=[]):
+    queue = [start]
+
+    while queue:
+        current_node = queue.pop(0)
+        if current_node==end:
+            print("Path: " + "->".join(visited) + "->" + end)
+            return
+        visited.append(current_node)
+
+        for i in data[current_node] - set(visited):
+            print("for looping -->",i)
+            queue.append(i)
+    print("Path does not exist!")
+
+
+if __name__ == '__main__':
+  data = {
+    'A': {'B'},
+    'B': {'C', 'D'},
+    'C': {'E'},
+    'D': {'E'},
+    'E': {'F'},
+    'F': set()
+  }
+  print("how it works")
+  how_it_workd(data, "A", "D")
+  print("out come")
+  bfs(data, 'A', 'D')

data_struct/myexamples/algo/working_bfs_2nd.py

@@ -0,0 +1,48 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.l = None
+        self.r = None
+
+class bst:
+    def __init__(self):
+        self.head = None
+
+    def lvl_order(self):
+        """"
+        level order queue:
+            1.)give q the starting pos
+            2.)as long as the q is full
+
+            3.) take first thing in q mark as visited
+            4.) check if that popped items has children
+                if they do put then in the queue
+
+        """"
+        vis = []
+        q = []
+        q.append(self.head)
+
+        while len(q) > 0:
+            cur = q.pop(0)
+            vis.append(cur)
+
+            if cur.l:
+                q.append(cur.l)
+            if cur.r:
+                q.append(cur.r)
+
+        for x in vis:
+            print(x.val)
+
+t = bst()
+t.head = node(4)
+t.head.l = node(2)
+t.head.r = node(8)
+t.head.l.l =  node(1)
+t.head.l.r = node(3)
+t.head.r.l = node(5)
+t.head.r.r =  node(10)
+t.lvl_order()
+
+

data_struct/myexamples/bst.py

@@ -0,0 +1,77 @@
+class bst:
+    def __init__(self,val=None):
+        self.val = val
+        self.l = None
+        self.r = None
+
+
+    def inorder(self):
+
+        if self.l:
+            self.l.postorder()
+        print(self.val)
+        if self.r:
+            self.r.postorder()
+
+    def postorder(self):
+
+        print(self.val)
+        if self.l:
+            self.l.postorder()
+        if self.r:
+            self.r.postorder()
+
+    def insert(self,val):
+
+        if val < self.val:
+            if self.l == None:
+                self.l = bst(val)
+            else:
+                self.l.insert(val)
+        else:
+            if self.r == None:
+                self.r = bst(val)
+            else:
+                self.r.insert(val)
+
+    def prt2d(self,sp,h):
+        #dis between lv
+        sp += h
+
+        cur = self
+
+        if cur is None:
+            return
+
+        bst.prt2d(cur.r,sp,h)
+        print()
+        for i in range(h,sp):
+            print(" ",end="")
+        print(cur.val,end="")
+        print()
+        bst.prt2d(cur.l,sp,h)
+
+tree = [bst(50),bst(50)]
+
+tree[0].insert(20)
+tree[0].insert(16)
+tree[0].insert(10)
+tree[0].insert(18)
+tree[0].insert(60)
+tree[0].insert(70)
+tree[0].insert(65)
+tree[0].insert(100)
+
+tree[0].postorder()
+print()
+print("displaying 2d tree")
+tree[0].prt2d(0,5)
+
+print("##################")
+
+tree[1].insert(40)
+tree[1].insert(60)
+tree[1].inorder()
+print()
+print("displaying 2d tree")
+tree[1].prt2d(0,5)

data_struct/myexamples/circular-linked.py

@@ -0,0 +1,35 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class linked:
+    def __init__(self):
+        self.head = None
+
+    def insert(self,val):
+        cur = self.head
+        prev = None
+        nd = node(val)
+
+        if cur is None:
+            cur = nd
+        else:
+            while cur.next:
+                cur = cur.next
+            cur.next = nd
+            nd.next = cur
+
+
+
+l = linked()
+
+l.head = node("start")
+l.insert("a")
+
+
+print("test")
+print(l.head.val)
+print(l.head.next.val)
+print(l.head.next.next.val)

data_struct/myexamples/double-ll.py

@@ -0,0 +1,48 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class linked:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def insert(self,val):
+        cur = self.head
+        tail = self.head
+        nd = node(val)
+
+        if cur is None:
+             cur = nd
+
+        while cur.next:
+            cur = cur.next
+        cur.next = nd
+        nd.prev = cur
+
+    def display_next(self):
+        cur = self.head
+        while cur :
+            print(cur.val,"-->",end="")
+            cur = cur.next
+        print("None")
+
+    def display_prev(self):
+        cur = self.head
+        while cur :
+            print(cur.val,"<--",end="")
+            cur = cur.next
+        print("None")
+
+l = linked()
+l.head = node("a")
+l.insert("b")
+l.insert("c")
+l.insert("d")
+l.insert("e")
+l.insert("f")
+l.insert("g")
+l.display_next()
+l.display_prev()

data_struct/myexamples/example-hashmap.py

@@ -0,0 +1,52 @@
+#hashtable
+
+class hashmap:
+    def __init__(self):
+        self.size = 20
+        self.ht = [[] for _ in range(0, self.size)]
+
+    def set(self,key,data):
+        hashed_key = hash(key) % self.size
+        buckets = self.ht[hashed_key]
+
+        exist = False
+        for i , kv in enumerate(buckets):
+            k,v = kv
+            if key == k:
+                exist = True
+                break
+
+        if exist:
+            buckets[i] = ((key,data))
+        else:
+            buckets.append((key,data))
+
+    def get(self,key):
+
+        hashed_key = hash(key) % self.size
+        buckets = self.ht[hashed_key]
+
+        found = False
+        for i , kv in enumerate(buckets):
+            k,v = kv
+            if key == k:
+                found = True
+                break
+        if found:
+            return key
+        else:
+            print("not found")
+
+
+h = hashmap()
+
+
+h.set("big_house", "martell")
+h.set("med_house", "tony")
+h.set("small_house", "emma")
+
+print(h.ht)
+
+
+
+

data_struct/myexamples/full_linked-list.py

@@ -0,0 +1,297 @@
+"""
+
+display
+
+dsearch node
+
+insert
+insert_beg
+insert_end
+insert_at
+
+remove
+remove_beg
+remove_end
+remove_at
+
+try:
+
+delete linkedlist
+Nth node from end/beg
+count
+take a list
+print middle
+reverse
+
+"""
+
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class llinkedlist:
+    def __init__(self):
+        self.head = None
+        self.prev = None
+
+    def display(self):
+        cur = self.head
+
+        if cur is None:
+            print("no linked list")
+
+        while cur:
+            print(cur.val,"-->",end="")
+            cur = cur.next
+        print("None")
+
+    def search(self,trg):
+        cur = self.head
+
+        if cur is None:
+            print("no linked list")
+
+        found = False
+        while cur.next:
+            cur = cur.next
+            if cur.val == trg:
+                found = True
+                break
+        if found:
+            print("found it",cur.val)
+        else:
+            print("didnt find item")
+
+    def insert(self,val):
+        cur = self.head
+        new_node = node(val)
+
+        if cur is None:
+            cur = new_node
+
+        while cur.next:
+            cur = cur.next
+        cur.next = new_node
+
+    def insert_end(self,val):
+        cur = self.head
+        new_node = node(val)
+
+        if cur is None:
+            print("no linklist")
+
+        while cur.next:
+            cur = cur.next
+            if cur.next == None:
+                cur.next = new_node
+                break
+
+    def insert_at(self,trg,val):# wtf
+        cur = self.head
+        prev = None
+        new_node = node(val)
+
+        found = False
+        while cur.next:
+            cur = cur.next
+            prev = cur
+            if cur.next.val == trg:
+                found = True
+                break
+        if found:
+            tmp = cur.next
+            prev.next = new_node
+            new_node.next = tmp
+        else:
+            print("coukd find that node")
+
+    def remove(self,trg): # 1h:02m
+        cur = self.head
+        prev = cur
+
+        if cur is None:
+            print("no linkedlist")
+
+        found = False
+        while cur.next:
+            cur = cur.next
+            prev = cur
+            if cur.next.val == trg:
+                found = True
+                break
+        if found:
+                prev.next = cur.next.next
+        else:
+            print("didnt find it")
+
+    def remove_beg(self):
+        cur = self.head
+
+        cur = cur.next
+        self.head = cur
+
+    def remove_end(self):
+        cur = self.head
+        prev = None
+
+        while cur.next:
+            prev = cur
+            cur = cur.next
+            if cur.next == None:
+                prev.next = cur.next
+                break
+
+    def remove_at(self,trg):
+        cur = self.head
+        prev = None
+
+        found = False
+        while cur.next:
+            prev = cur
+            cur = cur.next
+            if prev.val == trg:
+                found = True
+                break
+        if found:
+            prev.next = cur.next
+        else:
+            print("no found")
+
+    def delete_list(self):
+        cur = self.head
+        prev = None
+
+        while cur.next:
+            cur = cur.next
+            prev = cur
+            prev.next = None
+            print(cur.val)
+            if cur.val == None:
+                break
+
+    def Nth_node_end(self,n):
+        cur = self.head
+        cnt = 1
+        end = 2
+        trg = n #3
+        while cur.next:
+            cnt += 1
+            end += 1
+            cur = cur.next
+            if end == n:
+                break
+
+        print(n,"nodes from end answer:",cur.val)
+
+    def Nth_node_beg(self,n):
+        cur = self.head
+        cnt = 1
+        trg = n
+        while cur.next:
+            cnt += 1
+            cur = cur.next
+            if cnt == n:
+                break
+        print(n,"nodes from begs answer:",cur.val)
+
+    def count(self):
+        cur = self.head
+
+        count = 1
+        while cur.next:
+            count += 1
+            cur = cur.next
+            if cur.val == None:
+                break
+        print("count: ",count)
+
+    def convert_to_list(self):
+        llist = []
+        cur = self.head
+
+        while cur:
+            llist.append(cur.val)
+            cur = cur.next
+        print("convert to list",llist)
+    def middle(self):
+        cur = self.head
+        cnt = 1
+        loc = -1
+        while cur.next:
+            cnt += 1
+            loc += 1
+            cur = cur.next
+
+            if cur.val == None:
+                break
+        if (loc == (cnt / 2)):
+            print("loc:",loc)
+            print("cnt:",cnt)
+            print("formula:",loc == (cnt / 2))
+            print("odd")
+        else:
+            print("loc is half of cnt")
+            cur = self.head
+            count = 1
+            print("loc is:",loc)
+            while cur.next:
+                count += 1
+                cur = cur.next
+                if count == loc:
+                    break
+            print("middle is:",cur.val)
+
+    def reverse(self):
+        pass
+
+ll = llinkedlist()
+ll.head = node("first")
+
+#add nodes
+ll.insert(1)
+ll.insert(2)
+ll.insert(3)
+ll.insert(4)
+ll.insert(5)
+ll.insert("x")
+ll.insert_end("martell")
+ll.insert_at("martell","dorsett")
+
+#remove nodes
+ll.remove(5)
+
+#search
+ll.search(5)
+
+#delete
+ll.remove_beg()
+ll.remove_end()
+ll.remove_at(2)
+
+
+#ll.delete_list()
+#ll.insert("martell")
+
+
+#Nth node from end
+ll.Nth_node_end(3)
+
+#Nth node from beg
+ll.Nth_node_beg(2)
+
+#count
+ll.count()
+
+#convert
+ll.convert_to_list()
+
+#get middle
+ll.middle()
+
+#reverse
+ll.reverse()
+
+#display
+ll.display()
+

data_struct/myexamples/leetcode/leetcode_linkedlist.py

@@ -0,0 +1,36 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class llinkedlist:
+    def __init__(self):
+        self.head = None
+        self.prev = None
+
+    def display(lst):
+        if lst is None:
+            print("no linked list")
+
+        for i in range(len(mynodes)):
+            print(lst[i].val,"-->",end="")
+            i += 1
+        print("None")
+
+    def insert_list(self,mynodes):
+        print("the list")
+        print(mynodes)
+        cur = self.head
+        lst = []
+        for x in mynodes:
+            new_nd = node(x)
+
+            lst.append(new_nd)
+        return llinkedlist.display(lst)
+
+
+ll = llinkedlist()
+
+mynodes = [1,2,3,4,5]
+
+ll.insert_list(mynodes)

data_struct/myexamples/list-linkedlist.py

@@ -0,0 +1,32 @@
+class node:
+    def __init__(self,val):
+        self.val = val
+        self.next = None
+
+class linked:
+    def __init__(self):
+        self.q = [ ]
+        self.head = None
+
+    def list_link(self,lst): #list to linkedlsit
+        for i in range(0, len(lst)):
+            nd = node(lst[i])
+            self.q.append(nd)
+
+    def insert(self,val): #value to node
+        self.q.append( node(val) )
+
+    def display(self): #print the q of nodes
+        for i in range(0,len(self.q)):
+            print(self.q[i].val,"-->",end="")
+        print("None")
+
+    def peek_head(self):
+        print(self.head.val)
+l = linked()
+
+arr = [1,2,3]
+
+l.list_link(arr)
+l.insert("x")
+l.display()

data_struct/myexamples/node-stack.py

@@ -0,0 +1,57 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class stack:
+    def __init__(self):
+        self.size = 1
+        self.top = None
+
+
+    def peek(self):
+        cur = self
+
+        if cur.top is None:
+            print("nothing in stack")
+        else:
+            print(cur.top.val)
+
+    def push(self,val):
+        cur = self
+        new_nd = node(val)
+
+        if cur.top is None:
+            cur.top = new_nd
+        else:
+            cur.size += 1
+            new_nd.next = cur.top
+            cur.top = new_nd
+        print(self.size)
+
+    def pop(self):
+        cur = self
+
+        if cur.size == 0:
+            print("stack empty")
+        else:
+            tmp = cur.top.val
+            cur.top = cur.top.next
+            cur.size -= 1
+            cur = cur.top
+            if cur is None:
+                print("empty")
+            else:
+                print("next top -> {} popped top --> {}" \
+                  .format(cur.val,tmp))
+
+t = stack()
+
+t.push("a")
+t.push("b")
+t.push("c")
+t.push("d")
+t.pop()
+t.pop()
+t.pop()
+t.pop()

data_struct/myexamples/simple_tree.py

@@ -0,0 +1,27 @@
+class TreeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+        self.parent = None
+
+    def add_child(self, child):
+        child.parent = self
+        self.children.append(child)
+
+def build_product_tree():
+    root = TreeNode("Electronics")
+
+    laptop = TreeNode("Laptop")
+    laptop.add_child(TreeNode("Thinkpad"))
+
+    cellphone = TreeNode("Cell Phone")
+    cellphone.add_child(TreeNode("Vivo"))
+
+    root.add_child(laptop)
+    root.add_child(cellphone)
+
+    print("root:",root.data)
+    print("laptops parent is -->",laptop.parent.data)
+
+if __name__ == '__main__':
+    build_product_tree()

data_struct/pracsept0722/bst.py

@@ -0,0 +1,47 @@
+class bst:
+    def __init__(self,val=None):
+        self.val = val
+        self.l = None
+        self.r = None
+
+    def insert(self,val):
+        nd = bst(val)
+        if val < self.val:
+            if self.l == None:
+                self.l = nd
+            else:
+                self.l.insert(val)
+        else:
+            if self.r == None:
+                self.r = nd
+            else:
+                self.r.insert(val)
+
+    def postorder(self):
+        if self.l:
+            self.l.postorder()
+        if self.r:
+            self.r.postorder()
+        print(self.val)
+
+tree = [bst(50),bst(50)]
+
+tree[0].insert(20)
+tree[0].insert(16)
+tree[0].insert(10)
+tree[0].insert(18)
+tree[0].insert(60)
+tree[0].insert(70)
+tree[0].insert(65)
+tree[0].insert(100)
+
+tree[0].postorder()
+print()
+print("displaying 2d tree")
+
+print("##################")
+
+tree[1].insert(40)
+tree[1].insert(60)
+print()
+print("displaying 2d tree")

data_struct/pracsept0722/circular-linked.py

@@ -0,0 +1,20 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class linked:
+    def __init__(self):
+        self.head = None
+
+l = linked()
+
+l.head = node("start")
+l.insert("a")
+
+
+print("test")
+print(l.head.val)
+print(l.head.next.val)
+print(l.head.next.next.val)

data_struct/pracsept0722/double-ll.py

@@ -0,0 +1,21 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class linked:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+l = linked()
+l.head = node("a")
+l.insert("b")
+l.insert("c")
+l.insert("d")
+l.insert("e")
+l.insert("f")
+l.insert("g")
+l.display_next()
+l.display_prev()

data_struct/pracsept0722/example-hashmap.py

@@ -0,0 +1,21 @@
+#hashtable
+
+class hashmap:
+    def __init__(self):
+        self.size = 20
+        self.ht = [[] for _ in range(0, self.size)]
+
+
+
+h = hashmap()
+
+
+h.set("big_house", "martell")
+h.set("med_house", "tony")
+h.set("small_house", "emma")
+
+print(h.ht)
+
+
+
+

data_struct/pracsept0722/full_linked-list.py

@@ -0,0 +1,88 @@
+"""
+
+display
+
+dsearch node
+
+insert
+insert_beg
+insert_end
+insert_at
+
+remove
+remove_beg
+remove_end
+remove_at
+
+try:
+
+delete linkedlist
+Nth node from end/beg
+count
+take a list
+print middle
+reverse
+
+"""
+
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class llinkedlist:
+    def __init__(self):
+        self.head = None
+        self.prev = None
+
+
+ll = llinkedlist()
+ll.head = node("first")
+
+#add nodes
+ll.insert(1)
+ll.insert(2)
+ll.insert(3)
+ll.insert(4)
+ll.insert(5)
+ll.insert("x")
+ll.insert_end("martell")
+ll.insert_at("martell","dorsett")
+
+#remove nodes
+ll.remove(5)
+
+#search
+ll.search(5)
+
+#delete
+ll.remove_beg()
+ll.remove_end()
+ll.remove_at(2)
+
+
+#ll.delete_list()
+#ll.insert("martell")
+
+
+#Nth node from end
+ll.Nth_node_end(3)
+
+#Nth node from beg
+ll.Nth_node_beg(2)
+
+#count
+ll.count()
+
+#convert
+ll.convert_to_list()
+
+#get middle
+ll.middle()
+
+#reverse
+ll.reverse()
+
+#display
+ll.display()
+

data_struct/pracsept0722/list-linkedlist.py

@@ -0,0 +1,17 @@
+class node:
+    def __init__(self,val):
+        self.val = val
+        self.next = None
+
+class linked:
+    def __init__(self):
+        self.q = [ ]
+        self.head = None
+
+l = linked()
+
+arr = [1,2,3]
+
+l.list_link(arr)
+l.insert("x")
+l.display()

data_struct/pracsept0722/node-queue.py

@@ -0,0 +1,57 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.n = None
+
+class queuend:
+    def __init__(self):
+        self.fr = None
+        self.r = None
+        self.count = 0
+
+    def get_inl(self,val):
+        frt = self.fr
+        r = self.r
+        nd = node(val)
+
+        if frt is None:
+            #frt = nd
+            r = nd
+        while r.n:
+            nd.n = frt 
+        print(r.val)
+        print("front",frt.val)
+
+
+    def get_otl(self):
+        frt = self.fr
+        r = self.r
+
+
+myq = queuend()
+
+myq.get_inl(1)
+myq.get_inl(3)
+myq.get_inl(5)
+myq.get_inl(6)
+myq.get_inl(8)
+myq.get_otl()
+
+"""
+same things as node-stack
+
+but for this one
+
+top will be head
+and tail will be the last
+
+
+head -- 1
+3
+5
+6
+tail -- 8
+
+every new node.next will be tail
+
+"""

data_struct/pracsept0722/node-stack.py

@@ -0,0 +1,22 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class stack:
+    def __init__(self):
+    self.size = 1
+        self.top = None
+
+
+
+t = stack()
+
+t.push("a")
+t.push("b")
+t.push("c")
+t.push("d")
+t.pop()
+t.pop()
+t.pop()
+t.pop()

data_struct/pracsept0722/random.py

@@ -0,0 +1,5 @@
+def count():
+    for x in range(1,10):
+        print(x)
+
+

data_struct/pracsept0722/simple_tree.py

@@ -0,0 +1,14 @@
+class TreeNode:
+    def __init__(self, data):
+        self.data = data
+        self.children = []
+        self.parent = None
+
+    def add_child(self, child):
+        child.parent = self
+        self.children.append(child)
+
+def build_product_tree():
+    pass
+if __name__ == '__main__':
+    build_product_tree()

data_struct/pracsept0722/sorted_linked-list.py

@@ -0,0 +1,44 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.next = None
+
+class linked:
+    def __init__(self):
+        self.q = [ ]
+        self.head = None
+
+    def list_link(self,lst):
+        cur = self.head
+
+        if cur is None:
+            cur = node(lst[0])
+            self.q.insert(0,cur)
+
+        for i in range(1,len(lst)):
+            nd = node(lst[i])
+            self.q.append(nd)
+
+    def display(self):
+        cur = self.q
+        ev,od = [],[]
+        for i in range(len(self.q)):
+            if i % 2:
+                ev.append(( cur[i].val,"-->"))
+        for i in range(len(self.q)):
+            if i % 1:
+                od.append(( cur[i].val,"-->"))
+
+        print("even",ev)
+        print("odd",od)
+
+
+l = linked()
+
+arr = []
+for i in range(1,35,3):
+    arr.append(i)
+
+l.list_link(arr)
+print("the head ",l.q[0].val)
+l.display()

data_struct/pracsept0722/working_bfs_2nd.py

@@ -0,0 +1,33 @@
+class node:
+    def __init__(self,val=None):
+        self.val = val
+        self.l = None
+        self.r = None
+
+class bst:
+    def __init__(self):
+        self.head = None
+
+    def lvl_order(self):
+        """"
+        level order queue:
+            1.)give q the starting pos
+            2.)as long as the q is full
+
+            3.) take first thing in q mark as visited
+            4.) check if that popped items has children
+                if they do put then in the queue
+
+        """"
+
+t = bst()
+t.head = node(4)
+t.head.l = node(2)
+t.head.r = node(8)
+t.head.l.l =  node(1)
+t.head.l.r = node(3)
+t.head.r.l = node(5)
+t.head.r.r =  node(10)
+t.lvl_order()
+
+