repo setup, pushed 8 files

Author: joeyajames

BinarySearchTree.py

@@ -0,0 +1,114 @@
+# Binary Search Tree in Python
+
+class Node:
+	def __init__(self, val):
+		self.value = val
+		self.leftChild = None
+		self.rightChild = None
+		
+	def insert(self, data):
+		if self.value == data:
+			return False
+			
+		elif self.value > data:
+			if self.leftChild:
+				return self.leftChild.insert(data)
+			else:
+				self.leftChild = Node(data)
+				return True
+
+		else:
+			if self.rightChild:
+				return self.rightChild.insert(data)
+			else:
+				self.rightChild = Node(data)
+				return True
+				
+	def find(self, data):
+		if(self.value == data):
+			return True
+		elif self.value > data:
+			if self.leftChild:
+				return self.leftChild.find(data)
+			else:
+				return False
+		else:
+			if self.rightChild:
+				return self.rightChild.find(data)
+			else:
+				return False
+
+	def preorder(self):
+		if self:
+			print (str(self.value))
+			if self.leftChild:
+				self.leftChild.preorder()
+			if self.rightChild:
+				self.rightChild.preorder()
+
+	def postorder(self):
+		if self:
+			if self.leftChild:
+				self.leftChild.postorder()
+			if self.rightChild:
+				self.rightChild.postorder()
+			print (str(self.value))
+
+	def inorder(self):
+		if self:
+			if self.leftChild:
+				self.leftChild.inorder()
+			print (str(self.value))
+			if self.rightChild:
+				self.rightChild.inorder()
+
+class Tree:
+	def __init__(self):
+		self.root = None
+
+	def insert(self, data):
+		if self.root:
+			return self.root.insert(data)
+		else:
+			self.root = Node(data)
+			return True
+
+	def find(self, data):
+		if self.root:
+			return self.root.find(data)
+		else:
+			return False
+			
+	def preorder(self):
+		print("PreOrder")
+		self.root.preorder()
+        
+	def postorder(self):
+		print("PostOrder")
+		self.root.postorder()
+			
+	def inorder(self):
+		print("InOrder")
+		self.root.inorder()
+
+bst = Tree()
+print(bst.insert(10))
+bst.insert(5)
+bst.insert(15)
+bst.insert(11)
+bst.preorder()
+bst.postorder()
+bst.inorder()
+
+
+
+
+
+
+
+
+
+
+
+
+

BinaryToDecimal.py

@@ -0,0 +1,34 @@
+# Python: Binary to Decimal Conversion
+# binToDec and decToBin functions are rendered obsolete by the universal convert function
+
+def binToDec(binNum):
+	decNum = 0
+	power = 0
+	while binNum > 0:
+		decNum += 2 ** power * (binNum % 10)
+		binNum //= 10
+		power += 1
+	return decNum
+	
+def decToBin(decNum):
+	binNum = 0
+	power = 0
+	while decNum > 0:
+		binNum += 10 ** power * (decNum % 2)
+		decNum //= 2
+		power += 1
+	return binNum
+	
+def convert(fromNum, fromBase, toBase):
+	toNum = 0
+	power = 0
+	while fromNum > 0:
+		toNum += fromBase ** power * (fromNum % toBase)
+		fromNum //= toBase
+		power += 1
+	return toNum
+
+# print (str(binToDec(101011)))
+# print (str(decToBin(128)))
+print (str(convert(127, 10, 8)))	# converts 127 in  base 10 to base 8
+print (str(convert(101001, 2, 2)))	

HexToDec.py

@@ -0,0 +1,18 @@
+# Python Hexadecimal to Decimal Conversion
+
+def __getDecDigit(digit):
+	digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
+		'A', 'B', 'C', 'D', 'E', 'F']
+	for x in range(len(digits)):
+		if digit == digits[x]:
+			return x
+			
+def hexToDec(hexNum):
+	decNum = 0
+	power = 0
+	for digit in range(len(hexNum), 0, -1):
+		decNum = decNum + 16 ** power * __getDecDigit(hexNum[digit-1])
+		power += 1
+	print(str(decNum))
+	
+hexToDec("A5")

LinkedLists.py

@@ -0,0 +1,66 @@
+class Node(object):
+
+    def __init__ (self, d, n = None):
+        self.data = d
+        self.next_node = n
+
+    def get_next (self):
+        return self.next_node
+
+    def set_next (self, n):
+        self.next_node = n
+
+    def get_data (self):
+        return self.data
+
+    def set_data (self, d):
+        self.data = d
+
+
+class LinkedList (object):
+
+    def __init__(self, r = None):
+        self.root = r
+        self.size = 0
+
+    def get_size (self):
+        return self.size
+
+    def add (self, d):
+        new_node = Node (d, self.root)
+        self.root = new_node
+        self.size += 1
+
+    def remove (self, d):
+        this_node = self.root
+        prev_node = None
+
+        while this_node:
+            if this_node.get_data() == d:
+                if prev_node:
+                    prev_node.set_next(this_node.get_next())
+                else:
+                    self.root = this_node
+                self.size -= 1
+                return True		# data removed
+            else:
+                prev_node = this_node
+                this_node = this_node.get_next()
+        return False  # data not found
+
+    def find (self, d):
+        this_node = self.root
+        while this_node:
+            if this_node.get_data() == d:
+                return d
+            else:
+                this_node = this_node.get_next()
+        return None
+
+myList = LinkedList()
+myList.add(5)
+myList.add(8)
+myList.add(12)
+myList.remove(8)
+print(myList.remove(12))
+print(myList.find(5))

MaxHeap.py

@@ -0,0 +1,60 @@
+# Python MaxHeap
+# public functions: push, peek, pop
+# private functions: __swap, __floatUp, __bubbleDown
+
+class MaxHeap:
+	def __init__(self, items=[]):
+		super().__init__()
+		self.heap = [0]
+		for i in items:
+			self.heap.append(i)
+			self.__floatUp(len(self.heap) - 1)
+
+	def push(self, data):
+		self.heap.append(data)
+		self.__floatUp(len(self.heap) - 1)
+
+	def peek(self):
+		if self.heap[1]:
+			return self.heap[1]
+		else:
+			return False
+			
+	def pop(self):
+		if len(self.heap) > 2:
+			self.__swap(1, len(self.heap) - 1)
+			max = self.heap.pop()
+			self.__bubbleDown(1)
+		elif len(self.heap) == 2:
+			max = self.heap.pop()
+		else: 
+			max = False
+		return max
+
+	def __swap(self, i, j):
+		self.heap[i], self.heap[j] = self.heap[j], self.heap[i]
+
+	def __floatUp(self, index):
+		parent = index//2
+		if index <= 1:
+			return
+		elif self.heap[index] > self.heap[parent]:
+			self.__swap(index, parent)
+			self.__floatUp(parent)
+
+	def __bubbleDown(self, index):
+		left = index * 2
+		right = index * 2 + 1
+		largest = index
+		if len(self.heap) > left and self.heap[largest] < self.heap[left]:
+			largest = left
+		if len(self.heap) > right and self.heap[largest] < self.heap[right]:
+			largest = right
+		if largest != index:
+			self.__swap(index, largest)
+			self.__bubbleDown(largest)
+
+m = MaxHeap([95, 3, 21])
+m.push(10)
+print(str(m.heap[0:len(m.heap)]))
+print(str(m.pop()))

Primes.py

@@ -0,0 +1,21 @@
+# prime number calculator
+
+max = int(input("Find primes up to what number? : "))
+primeList = []
+
+for x in range(2, max + 1):
+	isPrime = True
+	index = 0
+	root = int(x ** 0.5) + 1
+	
+	while index < len(primeList) and primeList[index] <= root:
+		if x % primeList[index] == 0:
+			isPrime = False
+			break
+		index += 1
+			
+	if isPrime:
+		primeList.append(x)
+		
+print(primeList)
+		

python_sorting.py SortingAlgorithms.py

@@ -0,0 +1,29 @@
+# Temperature Conversion Program
+
+def menu():
+	print("\n1. Celsius to Fahrenheit")
+	print("2. Fahrenheit to Celsius")
+	print("3. Exit")
+	choice = int(input("Enter a choice: "))
+	return choice
+	
+def toCelsius(f):
+	return int((f - 32) / 1.8)
+
+def toFahrenheit(c):
+	return int(c * 1.8 + 32)
+	
+def main():
+	choice = menu()
+	while choice != 3:
+		if choice == 1:
+			c = eval(input("Enter degrees Celsius: "))
+			print(str(c) + "C = " + str(toFahrenheit(c)) + "F")
+		elif choice == 2:
+			f = eval(input("Enter degrees Fahrenheit: "))
+			print(str(f) + "F = " + str(toCelsius(f)) + "C")
+		else:
+			print("Invalid choice.")
+		choice = menu()
+		
+main()