New Stuff

Author: usrbinomarbash

Salmane_Douch_DS/CaseStudy2/Doubly.py

@@ -0,0 +1,70 @@
+class Node:
+    def __init__(self,isbn,title,author,year,copies):
+        self.isbn=isbn
+        self.title=title
+        self.author=author
+        self.year=year
+        self.copies=copies
+        self.next=None
+        self.prev=None
+class Doubly:
+    self.tail=None
+    self.head=None
+
+    def append(self,isbn,title,author,year,copies):
+        new_node=Node(isbn,title,author,year,copies)
+        if self.head ==None:
+            self.head=new_node
+            self.tail=new_node
+        else:
+            self.tail.next=new_node
+    def insert_inorder(self,isbn,title,author,year,copies):
+        new_node=Node(isbn,title,author,year,copies)
+        if self.head==None:
+            self.head=new_node
+            self.tail=new_node
+        if year == self.head.year:
+            new_node.next=self.head
+            self.head.previous=new_node
+            self.head=new_node
+        elif year >self.tail.year:
+            self.tail.next=new_node
+            new_node.prev=self.tail
+            self.tail=new_node
+        else:
+            walker=self.head
+            while(walker.year != None):
+                walker=walker.next
+            new_node.next=walker
+            new_node.previous=walker.previous
+            walker.previous.next=new_node
+            walker.previous=new_node
+
+
+    def __str__(self):
+
+file = open("books_data.csv", "r")
+L1=Doubly()
+for line in file:
+    list_line = line.strip().split(",")
+    print(list_line)
+def Load_data_from_file():
+    path="books_data.csv"
+    file=open(path,"r")
+    for line in file:
+        list_line=line.strip.split(",")#based on the delimtter
+        l1.insert_inorder(list_line[0],list_line[1],list_line[2],list_line[3],list_line[4])
+    file.close()
+def __str__(self):
+    print_str=""
+    current=self.head
+    while(current != None):
+        print_str+=
+def write_file_order():
+    new_file=open("ordered.txt","w")
+    walker=L1.head
+    for j in range(L1.size):
+        new_file.write(walker.title+", "+walker.year+"\n")
+        walker=walker.next
+    new_file.close()
+write_file_order()

Salmane_Douch_DS/CaseStudy2/ReadingFile.py

@@ -0,0 +1,69 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+# Build tree
+root = Node(10)
+root.left = Node(7)
+root.right = Node(12)
+root.left.left = Node(55)
+root.left.right = Node(9)
+root.right.left = Node(4)
+root.right.left.right = Node(8)
+root.right.left.right.left = Node(2)
+
+# Corrected Functions:
+
+def depth(root, value, l=1):
+    if root is None:
+        return None
+    if root.value == value:
+        return l
+    return depth(root.left, value, l+1) or depth(root.right, value, l+1)
+
+def min_depth(root):
+    if root is None:
+        return 0
+    if not root.left and not root.right:
+        return 1
+    if not root.left:
+        return 1 + min_depth(root.right)
+    if not root.right:
+        return 1 + min_depth(root.left)
+    return 1 + min(min_depth(root.left), min_depth(root.right))
+
+def left_view(root, left_list, level=0):
+    if root is None:
+        return
+    if level == len(left_list):  # fixed typo
+        left_list.append(root.value)
+    left_view(root.left, left_list, level + 1)
+    left_view(root.right, left_list, level + 1)
+
+def max_sum(root):
+    if root is None:
+        return 0
+    return root.value + max(max_sum(root.left), max_sum(root.right))
+
+# New: Check if tree is balanced
+def is_balanced(root):
+    def height_and_balanced(node):
+        if node is None:
+            return (0, True)
+        lh, left_balanced = height_and_balanced(node.left)
+        rh, right_balanced = height_and_balanced(node.right)
+        balanced = abs(lh - rh) <= 1 and left_balanced and right_balanced
+        return (1 + max(lh, rh), balanced)
+    _, balanced = height_and_balanced(root)
+    return balanced
+
+
+print("Depth of 8:", depth(root, 8))             # should return level
+print("Minimum depth:", min_depth(root))         # minimum depth
+left_result = []
+left_view(root, left_result)
+print("Left view:", left_result)
+print("Max sum path:", max_sum(root))
+print("Is balanced?:", is_balanced(root))

Salmane_Douch_DS/CaseStudy2/file.csv

@@ -0,0 +1,48 @@
+path= "bst_file.txt"
+file = open("bst_file.csv","r")
+for line in file:
+    print(line.strip().split(","))
+
+class Node:
+    def __init__(self, key,value):
+        self.key=key
+        self.id=id
+        self.value=value
+        self.left=None
+        self.right=None
+class BST:
+    def __init__(self):
+        self.root=None
+    def insert(self,root,key,value):
+        if key <= root.key
+            if root.left is None:
+                root.left = Node(key,value)
+            else:
+                self.insert(root.left, key,value)
+        else:
+            if root.right is None:
+                root.right = Node(key, value)
+            else:
+                self.insert(root.right, key, value)
+    def apppend(self,key,value):
+        if self.root is None:
+            self.root=Node(key,value)
+        else:
+            self.insert(self.root,key,value)
+    def search(self,key):
+        if self.root is None:
+            return("Not found")
+        else:
+            if(self.root.key < key):
+                self.root =
+
+
+
+bst1 = BST()
+for line in file:
+    print(line.strip().split(""))
+    key, name, price = line.strip().split(",")
+    key=int(key)
+    value =(name,float(price))
+
+

Salmane_Douch_DS/CaseStudyStacksQueuesTrees/BST.py

@@ -0,0 +1,27 @@
+class Node:
+    def __init__(self,data):
+        self.data=data
+        self.next=None
+class StackLL:
+    def __init__(self):
+        self.top = None
+    def push(self,toPush):
+        new_node=Node(toPush)
+        new_node.next=self.top
+        self.top=new_node
+    def isEmpty(self):
+        return self.top == None
+    def pop(self):
+        if self.isEmpty():
+            print("Stack underflow")
+            return None
+        toRemove=self.top
+        self.top=self.top.next
+        return toRemove
+    def peek(self):
+        if self.isEmpty():
+            print("Empty Stack")
+            return None
+        else:
+            return self.top.data
+

Salmane_Douch_DS/CaseStudyStacksQueuesTrees/BSTfile/BST.py

@@ -0,0 +1,3 @@
+1001, Widget A,9.99
+1002, Widget B, 12.49
+1003, Widget C, 7.50

Salmane_Douch_DS/CaseStudyStacksQueuesTrees/BSTfile/StackLL.py

@@ -0,0 +1,29 @@
+
+from collections import deque
+class Node:
+    def __init(self):
+        self.data=data
+        self.next=None
+class queue:
+    def __init__(self):
+        self.tail = None
+        self.head = None
+    def enqueue(self,value):
+        new_node=Node(value)
+        if self.head==None:
+            self.head=new_node
+            self.tail=new_node
+        else:
+            self.tail.next=new_node
+            self.tail=new_node
+    def dequeue(self):
+        if self.head==None
+            raise ValueError("queue empty")
+        else:
+            return_value = self.head.value
+            self.head = self.head.next
+            if self.head == None:
+                self.tail = None
+            return return_value
+
+

Salmane_Douch_DS/CaseStudyStacksQueuesTrees/BSTfile/bst_file.txt

@@ -0,0 +1,32 @@
+class Queues:
+    class Node:
+        def __init__(self,element,_next):
+            self.element=element
+            self._next=_next
+    def __init__(self):
+        self.head=None
+        self.tail=None
+        self.size=0
+
+    def __len__(self):
+        return self.size
+
+    def isEmpty(self):
+        return self.size == 0
+
+    def enqueue(self,element):
+        new_node = self.Node(element,None)
+        if self.isEmpty():
+            self.head=new_node
+        else:
+            self.tail._next=new_node
+        self.tail=new_node
+        self.size+=1
+
+    def dequeue(self):
+        if self.isEmpty():
+            return("Empty Queue")
+        result=self.head.element
+        self.head=self.head._next
+        self.size -=1
+        return result

Salmane_Douch_DS/CaseStudyStacksQueuesTrees/Queues.py

@@ -0,0 +1,20 @@
+class QueuesList():
+    def __init__(self):
+        self.L=[]
+
+    def enqueue(self,value):
+        self.L.append(value)
+
+    def dequeu(self):
+        if self.L==None
+            return None
+        else:
+            return self.L.pop(0)
+
+    def peek(self):
+        if self.isEmpty():
+            raise ValueError("Queue Empty")
+        return self.L[0]
+
+    def isEmpty(self):
+        return len(self.L)==0