Content-Length: 29732 | pFad | http://github.com/codebasics/data-structures-algorithms-python/pull/80.patch

thub.com From daf47e7124e8ecb5b30fa36aa341ffa5ac7949cd Mon Sep 17 00:00:00 2001 From: sy-md Date: Sun, 11 Sep 2022 15:29:20 +0900 Subject: [PATCH] my dsa work recorded --- data_struct/myexamples/algo/bfs.py | 47 +++ .../myexamples/algo/working_bfs_2nd.py | 48 +++ data_struct/myexamples/bst.py | 77 +++++ data_struct/myexamples/circular-linked.py | 35 +++ data_struct/myexamples/double-ll.py | 48 +++ data_struct/myexamples/example-hashmap.py | 52 +++ data_struct/myexamples/full_linked-list.py | 297 ++++++++++++++++++ .../leetcode/leetcode_linkedlist.py | 36 +++ data_struct/myexamples/list-linkedlist.py | 32 ++ data_struct/myexamples/node-stack.py | 57 ++++ data_struct/myexamples/simple_tree.py | 27 ++ data_struct/pracsept0722/bst.py | 47 +++ data_struct/pracsept0722/circular-linked.py | 20 ++ data_struct/pracsept0722/double-ll.py | 21 ++ data_struct/pracsept0722/example-hashmap.py | 21 ++ data_struct/pracsept0722/full_linked-list.py | 88 ++++++ data_struct/pracsept0722/list-linkedlist.py | 17 + data_struct/pracsept0722/node-queue.py | 57 ++++ data_struct/pracsept0722/node-stack.py | 22 ++ data_struct/pracsept0722/random.py | 5 + data_struct/pracsept0722/simple_tree.py | 14 + .../pracsept0722/sorted_linked-list.py | 44 +++ data_struct/pracsept0722/working_bfs_2nd.py | 33 ++ 23 files changed, 1145 insertions(+) create mode 100644 data_struct/myexamples/algo/bfs.py create mode 100644 data_struct/myexamples/algo/working_bfs_2nd.py create mode 100644 data_struct/myexamples/bst.py create mode 100644 data_struct/myexamples/circular-linked.py create mode 100644 data_struct/myexamples/double-ll.py create mode 100644 data_struct/myexamples/example-hashmap.py create mode 100644 data_struct/myexamples/full_linked-list.py create mode 100644 data_struct/myexamples/leetcode/leetcode_linkedlist.py create mode 100644 data_struct/myexamples/list-linkedlist.py create mode 100644 data_struct/myexamples/node-stack.py create mode 100644 data_struct/myexamples/simple_tree.py create mode 100644 data_struct/pracsept0722/bst.py create mode 100644 data_struct/pracsept0722/circular-linked.py create mode 100644 data_struct/pracsept0722/double-ll.py create mode 100644 data_struct/pracsept0722/example-hashmap.py create mode 100644 data_struct/pracsept0722/full_linked-list.py create mode 100644 data_struct/pracsept0722/list-linkedlist.py create mode 100644 data_struct/pracsept0722/node-queue.py create mode 100644 data_struct/pracsept0722/node-stack.py create mode 100644 data_struct/pracsept0722/random.py create mode 100644 data_struct/pracsept0722/simple_tree.py create mode 100644 data_struct/pracsept0722/sorted_linked-list.py create mode 100644 data_struct/pracsept0722/working_bfs_2nd.py diff --git a/data_struct/myexamples/algo/bfs.py b/data_struct/myexamples/algo/bfs.py new file mode 100644 index 0000000..60d7530 --- /dev/null +++ b/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') diff --git a/data_struct/myexamples/algo/working_bfs_2nd.py b/data_struct/myexamples/algo/working_bfs_2nd.py new file mode 100644 index 0000000..3d7f4a2 --- /dev/null +++ b/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() + + diff --git a/data_struct/myexamples/bst.py b/data_struct/myexamples/bst.py new file mode 100644 index 0000000..2b15b6a --- /dev/null +++ b/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) diff --git a/data_struct/myexamples/circular-linked.py b/data_struct/myexamples/circular-linked.py new file mode 100644 index 0000000..8cc7a7a --- /dev/null +++ b/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) diff --git a/data_struct/myexamples/double-ll.py b/data_struct/myexamples/double-ll.py new file mode 100644 index 0000000..450e933 --- /dev/null +++ b/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() diff --git a/data_struct/myexamples/example-hashmap.py b/data_struct/myexamples/example-hashmap.py new file mode 100644 index 0000000..e6f68dd --- /dev/null +++ b/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) + + + + diff --git a/data_struct/myexamples/full_linked-list.py b/data_struct/myexamples/full_linked-list.py new file mode 100644 index 0000000..f2a9f5e --- /dev/null +++ b/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() + diff --git a/data_struct/myexamples/leetcode/leetcode_linkedlist.py b/data_struct/myexamples/leetcode/leetcode_linkedlist.py new file mode 100644 index 0000000..1028796 --- /dev/null +++ b/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) diff --git a/data_struct/myexamples/list-linkedlist.py b/data_struct/myexamples/list-linkedlist.py new file mode 100644 index 0000000..ff7c3d6 --- /dev/null +++ b/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() diff --git a/data_struct/myexamples/node-stack.py b/data_struct/myexamples/node-stack.py new file mode 100644 index 0000000..568d19a --- /dev/null +++ b/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() diff --git a/data_struct/myexamples/simple_tree.py b/data_struct/myexamples/simple_tree.py new file mode 100644 index 0000000..ffcdd11 --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/bst.py b/data_struct/pracsept0722/bst.py new file mode 100644 index 0000000..3ff6ea1 --- /dev/null +++ b/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") diff --git a/data_struct/pracsept0722/circular-linked.py b/data_struct/pracsept0722/circular-linked.py new file mode 100644 index 0000000..7500235 --- /dev/null +++ b/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) diff --git a/data_struct/pracsept0722/double-ll.py b/data_struct/pracsept0722/double-ll.py new file mode 100644 index 0000000..ebca1ff --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/example-hashmap.py b/data_struct/pracsept0722/example-hashmap.py new file mode 100644 index 0000000..05ea74b --- /dev/null +++ b/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) + + + + diff --git a/data_struct/pracsept0722/full_linked-list.py b/data_struct/pracsept0722/full_linked-list.py new file mode 100644 index 0000000..b47bbc2 --- /dev/null +++ b/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() + diff --git a/data_struct/pracsept0722/list-linkedlist.py b/data_struct/pracsept0722/list-linkedlist.py new file mode 100644 index 0000000..a16233c --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/node-queue.py b/data_struct/pracsept0722/node-queue.py new file mode 100644 index 0000000..8c20693 --- /dev/null +++ b/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 + +""" diff --git a/data_struct/pracsept0722/node-stack.py b/data_struct/pracsept0722/node-stack.py new file mode 100644 index 0000000..de37985 --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/random.py b/data_struct/pracsept0722/random.py new file mode 100644 index 0000000..3455cd6 --- /dev/null +++ b/data_struct/pracsept0722/random.py @@ -0,0 +1,5 @@ +def count(): + for x in range(1,10): + print(x) + + diff --git a/data_struct/pracsept0722/simple_tree.py b/data_struct/pracsept0722/simple_tree.py new file mode 100644 index 0000000..69fcb11 --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/sorted_linked-list.py b/data_struct/pracsept0722/sorted_linked-list.py new file mode 100644 index 0000000..d2164c7 --- /dev/null +++ b/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() diff --git a/data_struct/pracsept0722/working_bfs_2nd.py b/data_struct/pracsept0722/working_bfs_2nd.py new file mode 100644 index 0000000..7695d56 --- /dev/null +++ b/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() + +

pFad - (p)hone/(F)rame/(a)nonymizer/(d)eclutterfier! Saves Data!