├── tree
    ├── traversal.py
    ├── main.pyc
    └── main.py
├── eratosthenes
    └── main.py
├── linked_list
    └── main.py
├── bst_validator
    └── main.py
├── Files
    ├── data.txt
    └── main.py
├── gif
    └── main.py
├── README.md
├── openpyxl
    ├── test.xlsx
    └── main.py
├── password_generator
    ├── main.pyc
    └── main.py
├── queue
    └── main.py
├── ynonperek
    └── Basic_Syntax
    │   ├── 1.py
    │   └── 2.py
├── bubble_sort
    └── main.py
├── fibonacci
    ├── main.py
    └── recursive.py
├── binary_search
    ├── Python3
    │   └── main.py
    └── Python2
    │   └── main.py
├── hanoi
    └── main.py
├── bogo_sort
    └── main.py
├── testing
    └── main.py
├── insertion_sort
    └── main.py
├── selection_sort
    └── main.py
├── merge_sort
    └── main.py
├── dictionary
    └── main.py
├── heap
    └── main.py
├── linear_regression
    └── main.py
├── quicksort_inplace
    └── main.py
├── quicksort
    └── main.py
├── linked_list_sort
    └── main.py
├── linked_list_sort_alphabetical
    └── main.py
├── linked_list_sort_custom
    └── main.py
├── graham_scan
    └── main.py
└── perceptron
    └── main.py


/tree/traversal.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/eratosthenes/main.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/linked_list/main.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/bst_validator/main.py:
--------------------------------------------------------------------------------
1 | 
2 | class


--------------------------------------------------------------------------------
/Files/data.txt:
--------------------------------------------------------------------------------
1 | This is some sample data...


--------------------------------------------------------------------------------
/gif/main.py:
--------------------------------------------------------------------------------
1 | 
2 | import imageio
3 | 
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Python_Algorithms
2 | Code for various YouTube video lessons + extras
3 | 


--------------------------------------------------------------------------------
/tree/main.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bfaure/Python_Algorithms/HEAD/tree/main.pyc


--------------------------------------------------------------------------------
/openpyxl/test.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bfaure/Python_Algorithms/HEAD/openpyxl/test.xlsx


--------------------------------------------------------------------------------
/password_generator/main.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bfaure/Python_Algorithms/HEAD/password_generator/main.pyc


--------------------------------------------------------------------------------
/queue/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | import Queue
 4 | 
 5 | test = Queue.Queue()
 6 | 
 7 | test.put(1)
 8 | test.put(2)
 9 | test.put(3)
10 | 
11 | print test.get()


--------------------------------------------------------------------------------
/openpyxl/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from openpyxl import Workbook
 3 | 
 4 | wb=Workbook()
 5 | 
 6 | ws=wb.active
 7 | 
 8 | ws['A1']="This is a test"
 9 | 
10 | wb.save('test.xlsx')
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/ynonperek/Basic_Syntax/1.py:
--------------------------------------------------------------------------------
1 | 
2 | '''
3 | write a program that asks the user for an integer and prints
4 | the sum of its digits
5 | '''
6 | 
7 | val=raw_input("Enter an integer:")
8 | tot=sum([int(e) for e in str(val)])
9 | print "Sum of digits: %d"%tot


--------------------------------------------------------------------------------
/ynonperek/Basic_Syntax/2.py:
--------------------------------------------------------------------------------
 1 | 
 2 | '''
 3 | write a program that takes a filename as command line argument,
 4 | count how many times each word appears in the file and prints the 
 5 | word that appears the most, along with it's count
 6 | '''
 7 | 
 8 | import sys
 9 | print sys.argv
10 | 


--------------------------------------------------------------------------------
/bubble_sort/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | def bubble_sort(arr):
 3 | 	swapped=True
 4 | 	while swapped:
 5 | 		swapped=False
 6 | 		for i in range(1,len(arr)):
 7 | 			if arr[i-1]>arr[i]:
 8 | 				arr[i],arr[i-1] = arr[i-1],arr[i]
 9 | 				swapped=True
10 | 	return arr
11 | 
12 | a=[4,3,2,1]
13 | print a
14 | a=bubble_sort(a)
15 | print a


--------------------------------------------------------------------------------
/fibonacci/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | # prints out the first n fibonacci numbers
 3 | def fibonacci(n):
 4 | 	last_fibs=[1,1]
 5 | 	for i in xrange(n):
 6 | 		if i<2: 
 7 | 			print last_fibs[i]
 8 | 		else:
 9 | 			new_fib=sum(last_fibs)
10 | 			last_fibs[0],last_fibs[1]=last_fibs[1],new_fib 
11 | 			print new_fib
12 | 
13 | fibonacci(100)
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/binary_search/Python3/main.py:
--------------------------------------------------------------------------------
 1 | def binary_search(a,value):
 2 | 	if len(a)==0 or (len(a)==1 and a[0]!=value):
 3 | 		return False
 4 | 
 5 | 	mid=a[len(a)//2]
 6 | 	if value==mid: return True 
 7 | 	if value<mid:  return binary_search(a[:len(a)//2],value)
 8 | 	if value>mid:  return binary_search(a[len(a)//2+1:],value)
 9 | 
10 | 
11 | a=[1,2,3,4,5,6,7,8,9]
12 | print(binary_search(a,5))


--------------------------------------------------------------------------------
/fibonacci/recursive.py:
--------------------------------------------------------------------------------
 1 | 
 2 | # recursive implementation of function, prints out the
 3 | # first n fibonacci numbers
 4 | def fibonacci(n,cur_fib=[1,1],i=0):
 5 | 	if i==n:
 6 | 		return
 7 | 	if i<2:
 8 | 		print cur_fib[i]
 9 | 		return fibonacci(n,cur_fib,i+1)
10 | 	else:
11 | 		new_fib=sum(cur_fib)
12 | 		print new_fib
13 | 		return fibonacci(n,[cur_fib[1],new_fib],i+1)
14 | 
15 | fibonacci(8)
16 | 
17 | 


--------------------------------------------------------------------------------
/binary_search/Python2/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | # performs binary search on input list
 3 | def binary_search(a,value):
 4 | 	if len(a)==0 or (len(a)==1 and a[0]!=value):
 5 | 		return False
 6 | 
 7 | 	mid=a[len(a)/2]
 8 | 	if value==mid: return True 
 9 | 	if value<mid:  return binary_search(a[:len(a)/2],value)
10 | 	if value>mid:  return binary_search(a[len(a)/2+1:],value)
11 | 
12 | a=[1,2,3,4,5,6,7,8,9]
13 | print binary_search(a,5)


--------------------------------------------------------------------------------
/hanoi/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import sys
 3 | from PyQt4.QtGui import *
 4 | from PyQt4.QtCore import *
 5 | 
 6 | class main_window(QWidget):
 7 | 	def __init__(self):
 8 | 		super(main_window,self).__init__()
 9 | 		self.init_ui()
10 | 
11 | 	def init_ui(self):
12 | 		self.show()
13 | 
14 | def main():
15 | 	pyqt_app=QApplication(sys.argv)
16 | 	_=main_window()
17 | 	sys.exit(pyqt_app.exec_())
18 | 
19 | if __name__ == '__main__':
20 | 	main()


--------------------------------------------------------------------------------
/bogo_sort/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from random import randint,shuffle
 3 | 
 4 | def create_array(size=10,max=50):
 5 | 	return [randint(0,max) for _ in range(size)]
 6 | 
 7 | 
 8 | def bogo_sort(a):
 9 | 	def is_sorted(a):
10 | 		for i in xrange(1,len(a)):
11 | 			if a[i]<a[i-1]: return False
12 | 		return True
13 | 
14 | 	ct=0
15 | 	while not is_sorted(a):
16 | 		shuffle(a)
17 | 		ct+=1
18 | 	return ct,a 
19 | 
20 | a=create_array(10,10)
21 | print "Unsorted:",a
22 | ct,s=bogo_sort(a)
23 | print "Sorted:  ",s 
24 | 


--------------------------------------------------------------------------------
/testing/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import unittest
 3 | 
 4 | def multiply(a,b):
 5 | 	return a*b
 6 | 
 7 | def add(a,b):
 8 | 	return a+b
 9 | 
10 | def subtract(a,b):
11 | 	return a-b
12 | 
13 | def divide(a,b):
14 | 	return a/b 
15 | 
16 | class test_calculator(unittest.TestCase):
17 | 
18 |     def test_sum(self):
19 |     	self.assertEqual(add(2,4),2+4)
20 | 
21 |     def test_multiply(self):
22 |     	self.assertEqual(multiply(2,4),2*4)
23 | 
24 |     def test_subtract(self):
25 |     	self.assertEqual(subtract(4,2),4-2)
26 | 
27 |     def test_divide(self):
28 |     	self.assertEqual(divide(4,2),4/2)
29 | 
30 | if __name__ == '__main__':
31 |     unittest.main()


--------------------------------------------------------------------------------
/insertion_sort/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | # creates randomized arrays for testing
 3 | def create_array(size=10,max=50):
 4 | 	from random import randint
 5 | 	return [randint(0,max) for _ in range(size)]
 6 | 
 7 | # executes insertion sort on the input array 
 8 | def insertion_sort(a):
 9 | 	for sort_len in range(1,len(a)):
10 | 		cur_item=a[sort_len] # next item to insert
11 | 		insert_idx=sort_len # current index of item
12 | 		# iterate down until we reach appropriate insertion location
13 | 		while insert_idx>0 and cur_item<a[insert_idx-1]:
14 | 			a[insert_idx]=a[insert_idx-1] # shift elements to make room
15 | 			insert_idx+=-1 # decrement the insertion index
16 | 		a[insert_idx]=cur_item # insert at correct location
17 | 	return a
18 | 
19 | 
20 | a=create_array()
21 | print a 
22 | a=insertion_sort(a)
23 | print a 


--------------------------------------------------------------------------------
/selection_sort/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | def create_array(length=10,maxint=50):
 3 | 	from random import randint
 4 | 	return [randint(0,maxint) for _ in range(length)]
 5 | 
 6 | '''
 7 | def selection_sort(arr):
 8 | 	sort_idx=0 # end of sorted portion of array
 9 | 	while sort_idx<len(arr):
10 | 		min_idx=None # index of smallest item found
11 | 		for i,elem in enumerate(arr[sort_idx:]):
12 | 			if min_idx==None or elem<arr[min_idx]:
13 | 				min_idx=i+sort_idx
14 | 		arr[sort_idx],arr[min_idx]=arr[min_idx],arr[sort_idx]
15 | 		sort_idx+=1
16 | 	return arr 
17 | '''		
18 | 
19 | def selection_sort(arr):
20 | 	sort_idx=0 # end of sorted portion of array
21 | 	while sort_idx<len(arr):
22 | 		min_idx=arr[sort_idx:].index(min(arr[sort_idx:]))+sort_idx
23 | 		arr[sort_idx],arr[min_idx]=arr[min_idx],arr[sort_idx]
24 | 		sort_idx+=1
25 | 	return arr 
26 | 
27 | a=create_array()
28 | print a
29 | a=selection_sort(a)
30 | print a


--------------------------------------------------------------------------------
/merge_sort/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | # merges two sorted arrays a & b
 3 | def merge(a,b):
 4 | 	c=[]
 5 | 	a_idx,b_idx=0,0
 6 | 	while a_idx<len(a) and b_idx<len(b):
 7 | 		if a[a_idx]<b[b_idx]:
 8 | 			c.append(a[a_idx])
 9 | 			a_idx+=1
10 | 		else:
11 | 			c.append(b[b_idx])
12 | 			b_idx+=1
13 | 	if a_idx==len(a): c.extend(b[b_idx:])
14 | 	else: 			  c.extend(a[a_idx:])
15 | 	return c 
16 | 
17 | # performs merge sort on the input array
18 | def merge_sort(a):
19 | 	# a list of zero or one elements is sorted, by definition
20 | 	if len(a)<=1: return a 
21 | 	# split the list in half and call merge sort recursively on each half
22 | 	left,right = merge_sort(a[:len(a)/2]),merge_sort(a[len(a)/2:])
23 | 	# merge the now-sorted sublists
24 | 	return merge(left,right)
25 | 
26 | def create_array(size=10,max=50):
27 | 	from random import randint
28 | 	return [randint(0,max) for _ in range(size)]
29 | 
30 | a=create_array()
31 | print a 
32 | a=merge_sort(a)
33 | print a


--------------------------------------------------------------------------------
/dictionary/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | class_names = [	"jack","bob","mary","jeff","ann","pierre",
 3 | 				"martha","clause","pablo","susan","gustav"]
 4 | 
 5 | def create_dataset():
 6 | 	import random
 7 | 	num_entries = 50000000 # 50 million lines
 8 | 	f = open("data.txt","w") 
 9 | 	for i in range(num_entries):
10 | 		current = random.choice(class_names)
11 | 		f.write(current+"\n")
12 | 	f.close()
13 | 
14 | def read_dataset_list():
15 | 	class_counts = []
16 | 	for c in class_names:
17 | 		class_counts.append(0)
18 | 	f = open("data.txt","r")
19 | 	for line in f:
20 | 		idx = class_names.index(line)
21 | 		class_counts[idx]+=1
22 | 	print class_counts 
23 | 
24 | def read_dataset_dict():
25 | 	class_counts = {}
26 | 	for c in class_names:
27 | 		class_counts[c]=0
28 | 	f = open("data.txt","r")
29 | 	for line in f:
30 | 		class_counts[line]+=1
31 | 	print class_counts
32 | 
33 | import time 
34 | 
35 | start = time.time()
36 | create_dataset()
37 | print "Dataset creation took %0.1f seconds" % time.time()-start 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | 
44 | 


--------------------------------------------------------------------------------
/password_generator/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from urllib2 import urlopen
 3 | from random import choice,randint
 4 | from passwordmeter import test
 5 | from os.path import isfile
 6 | 
 7 | if not isfile('words.txt'):
 8 | 	print 'Downloading words.txt...'
 9 | 	url='https://raw.githubusercontent.com/dwyl/english-words/master/words.txt'
10 | 	words_file=open('words.txt','w')
11 | 	words_file.write(urlopen(url).read())
12 | 
13 | words=open('words.txt','r').read().split("\n")
14 | special_chars=['!','?']
15 | 
16 | def create_password(num_words=2,num_numbers=4,num_special=1):
17 | 	pass_str=''
18 | 	for _ in xrange(num_words):
19 | 		pass_str+=choice(words).lower().capitalize()
20 | 	for _ in xrange(num_numbers):
21 | 		pass_str+=str(randint(0,9))
22 | 	for _ in xrange(num_special):
23 | 		pass_str+=choice(special_chars)
24 | 	return pass_str
25 | 
26 | def main():
27 | 	pass_str=create_password()
28 | 	strength,_=test(pass_str)
29 | 
30 | 	print '\nPassword: %s'%pass_str
31 | 	print 'Strength: %0.5f'%strength
32 | 
33 | if __name__ == '__main__':
34 | 	main()


--------------------------------------------------------------------------------
/heap/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | class min_heap:
 3 | 	def __init__(self):
 4 | 		self.data=[0]
 5 | 		self.size= 0
 6 | 
 7 | 	def insert(self,value):
 8 | 		self.data.append(value)
 9 | 		self.size+=1
10 | 		self._percolate_up(self.size)
11 | 
12 | 	def _percolate_up(self,i):
13 | 		while i//2>0:
14 | 			if self.data[i]<self.data[i//2]:
15 | 				self.data[i],self.data[i//2]=self.data[i//2],self.data[i]
16 | 			i=i//2
17 | 
18 | 	def _percolate_down(self,i):
19 | 		while (i*2)<=self.size:
20 | 			min_child=self._min_child(i)
21 | 			if self.data[i]>self.data[min_child]:
22 | 				self.data[i],self.data[min_child]=self.data[min_child],self.data[i]
23 | 			i=min_child
24 | 
25 | 	def _min_child(self,i):
26 | 		if i*2+1>self.size: return i*2
27 | 		else:
28 | 			if self.data[i*2]<self.data[i*2+1]: return i*2
29 | 			else:                               return i*2+1
30 | 
31 | 	def pop_min(self):
32 | 		min=self.data[1]
33 | 		self.data[1]=self.data[self.size]
34 | 		self.size+=-1
35 | 		self.data.pop()
36 | 		self._percolate_down(1)
37 | 		return min
38 | 
39 | 	def 
40 | 
41 | 
42 | 
43 | 
44 | 
45 | 
46 | 


--------------------------------------------------------------------------------
/linear_regression/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from matplotlib import pyplot as plt 
 3 | from random import randint
 4 | import numpy as np
 5 | 
 6 | def create_points(ct=20,min=0,max=50):
 7 | 	return [[randint(min,max),randint(min,max)] \
 8 | 			for _ in range(ct)]
 9 | 
10 | def scatter_plot(coords,m=None,b=None):
11 | 	xs,ys=zip(*coords) # unzip into x and y coord lists
12 | 	plt.scatter(xs,ys) # plot the data points
13 | 
14 | 	if m!=None and b!=None:
15 | 		# plot the line of best fit
16 | 		x=np.array(range(min(xs),max(xs)+1))
17 | 		y=eval('%s*x+%s'%(m,b))
18 | 		plt.plot(x,y)
19 | 
20 | 	plt.show()
21 | 
22 | 
23 | # finds values for m & b such that the equation
24 | # y = m*x + b has minimal error when fit to the 
25 | # input data set
26 | def linear_regression(pts):
27 | 	xs,ys=zip(*pts) # unzip the set of points
28 | 
29 | 	sum_x,sum_y=sum(xs),sum(ys)
30 | 	sum_xy=sum([a[0]*a[1] for a in pts])
31 | 	sum_x_sqrd=sum([a*a for a in xs])
32 | 	sum_y_sqrd=sum([a*a for a in ys])
33 | 	n=len(pts)
34 | 
35 | 	b=((sum_y*sum_x_sqrd)-(sum_x*sum_xy))/(n*sum_x_sqrd-sum_x*sum_x)
36 | 	m=((n*sum_xy)-(sum_x*sum_y))/(n*sum_x_sqrd-sum_x*sum_x)
37 | 
38 | 	return m,b
39 | 
40 | 
41 | #pts=create_points()
42 | pts=[[0,0],[1,1],[2,2],[3,3],[4,4],[5,5]]
43 | m,b=linear_regression(pts)
44 | scatter_plot(pts,m,b)


--------------------------------------------------------------------------------
/Files/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | '''
 3 | # creating a file
 4 | f=open('data.txt','w')
 5 | f.write('This is some sample data...')
 6 | f.close()
 7 | 
 8 | # Then open the file and show viewers
 9 | '''
10 | 
11 | '''
12 | # reading from a file
13 | f=open('data.txt','r')
14 | print f.read()
15 | f.close()
16 | 
17 | # Then run the script and show viewers the output
18 | '''
19 | 
20 | '''
21 | # appending to a file
22 | f=open('data.txt','a')
23 | f.write('\nAnd this is some more data...')
24 | f.close()
25 | 
26 | # Then open the file and show viewers
27 | '''
28 | 
29 | '''
30 | # iterating over each line of a file
31 | f=open('data.txt','r')
32 | for line in f:
33 | 	print line.strip() # remove the \n endline
34 | f.close()
35 | 
36 | # Then show the output in terminal
37 | '''
38 | 
39 | '''
40 | # printing out each byte of the file
41 | from os.path import getsize
42 | f=open('data.txt','r')
43 | for i in range(getsize('data.txt')):
44 | 	f.seek(i)
45 | 	print "Byte #%d:\t%s"%(i,f.read(1))
46 | f.close()
47 | 
48 | # Then show the output in terminal
49 | '''
50 | 
51 | '''
52 | # overwriting a file
53 | f=open('data.txt','w')
54 | f.write('Out with the old, in with the new.')
55 | f.close()
56 | 
57 | # Then open the file and show viewers
58 | '''
59 | 
60 | '''
61 | # checking if a file exists
62 | from os.path import isfile
63 | print "Is data.txt a file?",isfile('data.txt')
64 | print "Is dater.txt a file?",isfile('dater.txt')
65 | 
66 | # Then show the output in terminal
67 | '''
68 | 
69 | '''
70 | # viewing the contents of a directory
71 | from os import listdir
72 | print "Elements of current directory:",listdir('.')
73 | 
74 | # Then show the output in terminal
75 | '''
76 | 
77 | 
78 | 
79 | 


--------------------------------------------------------------------------------
/quicksort_inplace/main.py:
--------------------------------------------------------------------------------
 1 | 
 2 | from random import randint
 3 | 
 4 | def create_array(size=10,max=50):
 5 | 	return [randint(0,max) for _ in range(size)]
 6 | 
 7 | def quicksort(a):
 8 | 	if len(a)<=1: return a 
 9 | 	smaller,equal,larger=[],[],[]
10 | 	pivot=a[randint(0,len(a)-1)]
11 | 	for x in a:
12 | 		if x<pivot: 	smaller.append(x)
13 | 		elif x==pivot: 	equal.append(x)
14 | 		else:			larger.append(x)
15 | 	return quicksort(smaller)+equal+quicksort(larger)
16 | 
17 | def partition(a,low,high):
18 | 	i=low-1 # to be the final pivot index
19 | 	pivot=a[high] # pivot value itself
20 | 	for j in range(low,high): # iterate up to pivot index
21 | 		if a[j]<=pivot:
22 | 			i+=1 # increment final pivot index 
23 | 			a[i],a[j]=a[j],a[i]
24 | 	a[i+1],a[high]=a[high],a[i+1]
25 | 	return i+1
26 | 
27 | def quicksort_inplace(a,low=0,high=None):
28 | 	if high==None: 
29 | 		high=len(a)-1
30 | 	if low<high:
31 | 		p_idx=partition(a,low,high)
32 | 		quicksort_inplace(a,low,p_idx-1)
33 | 		quicksort_inplace(a,p_idx+1,high)
34 | 
35 | 
36 | from time import time
37 | times={'initial':[],'inplace':[]}
38 | sizes=[10,100,1000,10000,100000,1000000]
39 | samples=3
40 | 
41 | for s in sizes:
42 | 
43 | 	# regular quicksort
44 | 	tot=0.0
45 | 	for _ in range(samples):
46 | 		a=create_array(size=s,max=s)
47 | 		t0=time()
48 | 		a=quicksort(a)
49 | 		t1=time()
50 | 		tot+=(t1-t0)
51 | 	times['initial'].append(float(tot/samples))
52 | 
53 | 	# inplace quicksort
54 | 	tot=0.0
55 | 	for _ in range(samples):
56 | 		a=create_array(size=s,max=s)
57 | 		t0=time()
58 | 		quicksort(a)
59 | 		t1=time()
60 | 		tot+=(t1-t0)
61 | 	times['inplace'].append(float(tot/samples))
62 | 
63 | print "n\tQuicksort\tQuicksort (inplace)"
64 | print "_"*35
65 | for i,s in enumerate(sizes):
66 | 	print "%d\t%0.5f  \t%0.5f"%(
67 | 		s,
68 | 		times['initial'][i],
69 | 		times['inplace'][i])
70 | 
71 | 


--------------------------------------------------------------------------------
/quicksort/main.py:
--------------------------------------------------------------------------------
 1 | from random import randint
 2 | 
 3 | # merges two sorted arrays a & b
 4 | def merge(a,b):
 5 | 	c=[]
 6 | 	a_idx,b_idx=0,0
 7 | 	while a_idx<len(a) and b_idx<len(b):
 8 | 		if a[a_idx]<b[b_idx]:
 9 | 			c.append(a[a_idx])
10 | 			a_idx+=1
11 | 		else:
12 | 			c.append(b[b_idx])
13 | 			b_idx+=1
14 | 	if a_idx==len(a): c.extend(b[b_idx:])
15 | 	else: 			  c.extend(a[a_idx:])
16 | 	return c 
17 | 
18 | # performs merge sort on the input array
19 | def merge_sort(a):
20 | 	# a list of zero or one elements is sorted, by definition
21 | 	if len(a)<=1: return a 
22 | 	# split the list in half and call merge sort recursively on each half
23 | 	left,right = merge_sort(a[:len(a)/2]),merge_sort(a[len(a)/2:])
24 | 	# merge the now-sorted sublists
25 | 	return merge(left,right)
26 | 
27 | 
28 | # applies quicksort to the input array, returns sorted array
29 | def quicksort(a):
30 | 	if len(a)<=1: return a 
31 | 
32 | 	smaller,equal,larger=[],[],[]
33 | 	pivot=a[randint(0,len(a)-1)]
34 | 
35 | 	for x in a:
36 | 		if x<pivot:    smaller.append(x)
37 | 		elif x==pivot: equal.append(x)
38 | 		else:          larger.append(x)
39 | 
40 | 	return quicksort(smaller)+equal+quicksort(larger)
41 | 
42 | def create_array(size=10,max=50):
43 | 	return [randint(0,max) for _ in range(size)]
44 | 
45 | 
46 | times={'quick':[],'merge':[]}
47 | n=[10,100,1000,10000,100000]
48 | samples=5
49 | from time import time 
50 | 
51 | for size in n:
52 | 
53 | 	tot_time=0.0
54 | 	for _ in range(samples):
55 | 		a=create_array(size,size)
56 | 		t0=time()
57 | 		s=merge_sort(a)
58 | 		t1=time()
59 | 		tot_time+=(t1-t0)
60 | 	times['merge'].append(tot_time/float(samples))
61 | 
62 | 	tot_time=0.0
63 | 	for _ in range(samples):
64 | 		a=create_array(size,size)
65 | 		t0=time()
66 | 		s=quicksort(a)
67 | 		t1=time()
68 | 		tot_time+=(t1-t0)
69 | 	times['quick'].append(tot_time/float(samples))
70 | 
71 | print "n\tQuicksort\tMergesort"
72 | print 40*"_"
73 | for i,size in enumerate(n):
74 | 	print "%d\t%0.5f \t%0.5f"%(
75 | 		size,
76 | 		times['quick'][i],
77 | 		times['merge'][i])
78 | 


--------------------------------------------------------------------------------
/linked_list_sort/main.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # Simple node class
  3 | class node:
  4 | 	def __init__(self,data=None):
  5 | 		self.data=data
  6 | 		self.next=None
  7 | 
  8 | # Linked list class (seen in video lesson)
  9 | class linked_list:
 10 | 	def __init__(self):
 11 | 		self.head=node()
 12 | 
 13 | 	# Adds new node containing 'data' to the end of the linked list.
 14 | 	def append(self,data):
 15 | 		new_node=node(data)
 16 | 		cur=self.head
 17 | 		while cur.next!=None:
 18 | 			cur=cur.next
 19 | 		cur.next=new_node
 20 | 
 21 | 	# Returns the length (integer) of the linked list.
 22 | 	def length(self):
 23 | 		cur=self.head
 24 | 		total=0
 25 | 		while cur.next!=None:
 26 | 			total+=1
 27 | 			cur=cur.next
 28 | 		return total 
 29 | 
 30 | 	# Prints out the linked list in traditional Python list format. 
 31 | 	def display(self):
 32 | 		elems=[]
 33 | 		cur_node=self.head
 34 | 		while cur_node.next!=None:
 35 | 			cur_node=cur_node.next
 36 | 			elems.append(cur_node.data)
 37 | 		print elems
 38 | 
 39 | 	# Returns the value of the node at 'index'. 
 40 | 	def get(self,index):
 41 | 		if index>=self.length():
 42 | 			print "ERROR: 'Get' Index out of range!"
 43 | 			return None
 44 | 		cur_idx=0
 45 | 		cur_node=self.head
 46 | 		while True:
 47 | 			cur_node=cur_node.next
 48 | 			if cur_idx==index: return cur_node.data
 49 | 			cur_idx+=1
 50 | 
 51 | 	# Deletes the node at index 'index'.
 52 | 	def erase(self,index):
 53 | 		if index>=self.length():
 54 | 			print "ERROR: 'Erase' Index out of range!"
 55 | 			return 
 56 | 		cur_idx=0
 57 | 		cur_node=self.head
 58 | 		while True:
 59 | 			last_node=cur_node
 60 | 			cur_node=cur_node.next
 61 | 			if cur_idx==index:
 62 | 				last_node.next=cur_node.next
 63 | 				return
 64 | 			cur_idx+=1
 65 | 
 66 | 	# Allows for bracket operator syntax (i.e. a[0] to return first item).
 67 | 	def __getitem__(self,index):
 68 | 		return self.get(index)
 69 | 
 70 | 	# ADDED THIS METHOD
 71 | 	# Simplifies the code for selection sort,
 72 | 	# swaps the values at input indices 'index_1'
 73 | 	# and 'index_2', all other values unchanged
 74 | 	def swap(self,index_1,index_2):
 75 | 		val_1=self.get(index_1) # value at 'index_1'
 76 | 		val_2=self.get(index_2) # value at 'index_2'
 77 | 
 78 | 		# Iterate through list and replace values
 79 | 		cur_idx=0
 80 | 		cur_node=self.head
 81 | 		while cur_idx<self.length():
 82 | 			cur_node=cur_node.next
 83 | 			if cur_idx==index_1: 
 84 | 				cur_node.data=val_2
 85 | 			if cur_idx==index_2:
 86 | 				cur_node.data=val_1
 87 | 			cur_idx+=1
 88 | 
 89 | # Selection sort tailored to work for a linked list input,
 90 | # assuming a linked list with the attributes of the above class
 91 | def linked_list_selection_sort(L):
 92 | 	sort_idx=0 # end of sorted portion of array
 93 | 	while sort_idx<L.length():
 94 | 		min_idx=None # to be the index of the next smallest value 
 95 | 		min_val=None # to be the smallest value found
 96 | 		# iterate through unsorted portion and find smallest item
 97 | 		for i in range(sort_idx,L.length()):
 98 | 			if min_idx==None or L[i]<min_val:
 99 | 				min_idx=i
100 | 				min_val=L[i]
101 | 		# increase sorted portion by swapping in next smallest
102 | 		# item at the righthand side (end of sorted portion)
103 | 		L.swap(min_idx,sort_idx)
104 | 		sort_idx+=1
105 | 	return L
106 | 
107 | # Create instance of linked list class
108 | arr=linked_list()
109 | 
110 | # Add some elements in unsorted order
111 | arr.append(4)
112 | arr.append(3)
113 | arr.append(2)
114 | arr.append(1)
115 | 
116 | # Display the unsorted list
117 | arr.display()
118 | 
119 | # Sort using custom selection sort
120 | linked_list_selection_sort(arr)
121 | 
122 | # Display the (now sorted) list
123 | arr.display()


--------------------------------------------------------------------------------
/linked_list_sort_alphabetical/main.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # Simple node class
  3 | class node:
  4 | 	def __init__(self,data=None):
  5 | 		self.data=data
  6 | 		self.next=None
  7 | 
  8 | # Linked list class (seen in video lesson)
  9 | class linked_list:
 10 | 	def __init__(self):
 11 | 		self.head=node()
 12 | 
 13 | 	# Adds new node containing 'data' to the end of the linked list.
 14 | 	def append(self,data):
 15 | 		new_node=node(data)
 16 | 		cur=self.head
 17 | 		while cur.next!=None:
 18 | 			cur=cur.next
 19 | 		cur.next=new_node
 20 | 
 21 | 	# Returns the length (integer) of the linked list.
 22 | 	def length(self):
 23 | 		cur=self.head
 24 | 		total=0
 25 | 		while cur.next!=None:
 26 | 			total+=1
 27 | 			cur=cur.next
 28 | 		return total 
 29 | 
 30 | 	# Prints out the linked list in traditional Python list format. 
 31 | 	def display(self):
 32 | 		elems=[]
 33 | 		cur_node=self.head
 34 | 		while cur_node.next!=None:
 35 | 			cur_node=cur_node.next
 36 | 			elems.append(cur_node.data)
 37 | 		print elems
 38 | 
 39 | 	# Returns the value of the node at 'index'. 
 40 | 	def get(self,index):
 41 | 		if index>=self.length() or index<0:
 42 | 			print "ERROR: 'Get' Index out of range!"
 43 | 			return None
 44 | 		cur_idx=0
 45 | 		cur_node=self.head
 46 | 		while True:
 47 | 			cur_node=cur_node.next
 48 | 			if cur_idx==index: return cur_node.data
 49 | 			cur_idx+=1
 50 | 
 51 | 	# Deletes the node at index 'index'.
 52 | 	def erase(self,index):
 53 | 		if index>=self.length() or index<0:
 54 | 			print "ERROR: 'Erase' Index out of range!"
 55 | 			return 
 56 | 		cur_idx=0
 57 | 		cur_node=self.head
 58 | 		while True:
 59 | 			last_node=cur_node
 60 | 			cur_node=cur_node.next
 61 | 			if cur_idx==index:
 62 | 				last_node.next=cur_node.next
 63 | 				return
 64 | 			cur_idx+=1
 65 | 
 66 | 	# Allows for bracket operator syntax (i.e. a[0] to return first item).
 67 | 	def __getitem__(self,index):
 68 | 		return self.get(index)
 69 | 
 70 | 	# ADDED THIS METHOD
 71 | 	# Simplifies the code for selection sort,
 72 | 	# swaps the values at input indices 'index_1'
 73 | 	# and 'index_2', all other values unchanged
 74 | 	def swap(self,index_1,index_2):
 75 | 		val_1=self.get(index_1) # value at 'index_1'
 76 | 		val_2=self.get(index_2) # value at 'index_2'
 77 | 
 78 | 		# Iterate through list and replace values
 79 | 		cur_idx=0
 80 | 		cur_node=self.head
 81 | 		while cur_idx<self.length():
 82 | 			cur_node=cur_node.next
 83 | 			if cur_idx==index_1: 
 84 | 				cur_node.data=val_2
 85 | 			if cur_idx==index_2:
 86 | 				cur_node.data=val_1
 87 | 			cur_idx+=1
 88 | 
 89 | # Selection sort tailored to work for a linked list input,
 90 | # assuming a linked list with the attributes of the above class
 91 | def linked_list_selection_sort(L):
 92 | 	sort_idx=0 # end of sorted portion of array
 93 | 	while sort_idx<L.length():
 94 | 		min_idx=None # to be the index of the next smallest value 
 95 | 		min_val=None # to be the smallest value found
 96 | 		# iterate through unsorted portion and find smallest item
 97 | 		for i in range(sort_idx,L.length()):
 98 | 			if min_idx==None or L[i]<min_val:
 99 | 				min_idx=i
100 | 				min_val=L[i]
101 | 		# increase sorted portion by swapping in next smallest
102 | 		# item at the righthand side (end of sorted portion)
103 | 		L.swap(min_idx,sort_idx)
104 | 		sort_idx+=1
105 | 	return L
106 | 
107 | # Create instance of linked list class
108 | arr=linked_list()
109 | 
110 | # Add some elements in unsorted order
111 | arr.append(4)
112 | arr.append(3)
113 | arr.append(2)
114 | arr.append(1)
115 | 
116 | # Display the unsorted list
117 | arr.display()
118 | 
119 | # Sort using custom selection sort
120 | linked_list_selection_sort(arr)
121 | 
122 | # Display the (now sorted) list
123 | arr.display()


--------------------------------------------------------------------------------
/linked_list_sort_custom/main.py:
--------------------------------------------------------------------------------
  1 | 
  2 | # Simple node class
  3 | class node:
  4 | 	def __init__(self,data=None):
  5 | 		self.data=data
  6 | 		self.next=None
  7 | 
  8 | # Linked list class (seen in video lesson)
  9 | class linked_list:
 10 | 	def __init__(self):
 11 | 		self.head=node()
 12 | 
 13 | 	# Adds new node containing 'data' to the end of the linked list.
 14 | 	def append(self,data):
 15 | 		new_node=node(data)
 16 | 		cur=self.head
 17 | 		while cur.next!=None:
 18 | 			cur=cur.next
 19 | 		cur.next=new_node
 20 | 
 21 | 	# Returns the length (integer) of the linked list.
 22 | 	def length(self):
 23 | 		cur=self.head
 24 | 		total=0
 25 | 		while cur.next!=None:
 26 | 			total+=1
 27 | 			cur=cur.next
 28 | 		return total 
 29 | 
 30 | 	# Prints out the linked list in traditional Python list format. 
 31 | 	def display(self):
 32 | 		elems=[]
 33 | 		cur_node=self.head
 34 | 		while cur_node.next!=None:
 35 | 			cur_node=cur_node.next
 36 | 			elems.append(cur_node.data)
 37 | 		print elems
 38 | 
 39 | 	# Returns the value of the node at 'index'. 
 40 | 	def get(self,index):
 41 | 		if index>=self.length() or index<0:
 42 | 			print "ERROR: 'Get' Index out of range!"
 43 | 			return None
 44 | 		cur_idx=0
 45 | 		cur_node=self.head
 46 | 		while True:
 47 | 			cur_node=cur_node.next
 48 | 			if cur_idx==index: return cur_node.data
 49 | 			cur_idx+=1
 50 | 
 51 | 	# Deletes the node at index 'index'.
 52 | 	def erase(self,index):
 53 | 		if index>=self.length() or index<0:
 54 | 			print "ERROR: 'Erase' Index out of range!"
 55 | 			return 
 56 | 		cur_idx=0
 57 | 		cur_node=self.head
 58 | 		while True:
 59 | 			last_node=cur_node
 60 | 			cur_node=cur_node.next
 61 | 			if cur_idx==index:
 62 | 				last_node.next=cur_node.next
 63 | 				return
 64 | 			cur_idx+=1
 65 | 
 66 | 	# Allows for bracket operator syntax (i.e. a[0] to return first item).
 67 | 	def __getitem__(self,index):
 68 | 		return self.get(index)
 69 | 
 70 | 	# ADDED THIS METHOD
 71 | 	# Simplifies the code for selection sort,
 72 | 	# swaps the values at input indices 'index_1'
 73 | 	# and 'index_2', all other values unchanged
 74 | 	def swap(self,index_1,index_2):
 75 | 		val_1=self.get(index_1) # value at 'index_1'
 76 | 		val_2=self.get(index_2) # value at 'index_2'
 77 | 
 78 | 		# Iterate through list and replace values
 79 | 		cur_idx=0
 80 | 		cur_node=self.head
 81 | 		while cur_idx<self.length():
 82 | 			cur_node=cur_node.next
 83 | 			if cur_idx==index_1: 
 84 | 				cur_node.data=val_2
 85 | 			if cur_idx==index_2:
 86 | 				cur_node.data=val_1
 87 | 			cur_idx+=1
 88 | 
 89 | # Selection sort tailored to work for a linked list input,
 90 | # assuming a linked list with the attributes of the above class
 91 | def linked_list_selection_sort(L):
 92 | 	sort_idx=0 # end of sorted portion of array
 93 | 	while sort_idx<L.length():
 94 | 		min_idx=None # to be the index of the next smallest value 
 95 | 		min_val=None # to be the smallest value found
 96 | 		# iterate through unsorted portion and find smallest item
 97 | 		for i in range(sort_idx,L.length()):
 98 | 			if min_idx==None or L[i].name<min_val:
 99 | 				min_idx=i
100 | 				min_val=L[i].name
101 | 		# increase sorted portion by swapping in next smallest
102 | 		# item at the righthand side (end of sorted portion)
103 | 		L.swap(min_idx,sort_idx)
104 | 		sort_idx+=1
105 | 	return L
106 | 
107 | # Create instance of linked list class
108 | arr=linked_list()
109 | 
110 | # Custom object held in list
111 | class obj:
112 | 	def __init__(self,name='none'):
113 | 		self.name=name
114 | 	def __repr__(self):
115 | 		return self.name
116 | 
117 | # Add some elements in unsorted order
118 | arr.append(obj('z'))
119 | arr.append(obj('y'))
120 | arr.append(obj('x'))
121 | arr.append(obj('w'))
122 | 
123 | # Display the unsorted list
124 | arr.display()
125 | 
126 | # Sort using custom selection sort
127 | linked_list_selection_sort(arr)
128 | 
129 | # Display the (now sorted) list
130 | arr.display()


--------------------------------------------------------------------------------
/graham_scan/main.py:
--------------------------------------------------------------------------------
  1 | 
  2 | from matplotlib import pyplot as plt # for plotting
  3 | from random import randint # for sorting and creating data pts
  4 | from math import atan2 # for computing polar angle
  5 | 
  6 | # Returns a list of (x,y) coordinates of length 'num_points',
  7 | # each x and y coordinate is chosen randomly from the range 
  8 | # 'min' up to 'max'.
  9 | def create_points(ct,min=0,max=50):
 10 | 	return [[randint(min,max),randint(min,max)] \
 11 | 			for _ in range(ct)]
 12 | 
 13 | # Creates a scatter plot, input is a list of (x,y) coordinates.
 14 | # The second input 'convex_hull' is another list of (x,y) coordinates
 15 | # consisting of those points in 'coords' which make up the convex hull,
 16 | # if not None, the elements of this list will be used to draw the outer
 17 | # boundary (the convex hull surrounding the data points).
 18 | def scatter_plot(coords,convex_hull=None):
 19 | 	xs,ys=zip(*coords) # unzip into x and y coord lists
 20 | 	plt.scatter(xs,ys) # plot the data points
 21 | 
 22 | 	if convex_hull!=None:
 23 | 		# plot the convex hull boundary, extra iteration at
 24 | 		# the end so that the bounding line wraps around
 25 | 		for i in range(1,len(convex_hull)+1):
 26 | 			if i==len(convex_hull): i=0 # wrap
 27 | 			c0=convex_hull[i-1]
 28 | 			c1=convex_hull[i]
 29 | 			plt.plot((c0[0],c1[0]),(c0[1],c1[1]),'r')
 30 | 	plt.show()
 31 | 
 32 | 
 33 | # Returns the polar angle (radians) from p0 to p1.
 34 | # If p1 is None, defaults to replacing it with the
 35 | # global variable 'anchor', normally set in the 
 36 | # 'graham_scan' function.
 37 | def polar_angle(p0,p1=None):
 38 | 	if p1==None: p1=anchor
 39 | 	y_span=p0[1]-p1[1]
 40 | 	x_span=p0[0]-p1[0]
 41 | 	return atan2(y_span,x_span)
 42 | 
 43 | 
 44 | # Returns the euclidean distance from p0 to p1,
 45 | # square root is not applied for sake of speed.
 46 | # If p1 is None, defaults to replacing it with the
 47 | # global variable 'anchor', normally set in the 
 48 | # 'graham_scan' function.
 49 | def distance(p0,p1=None):
 50 | 	if p1==None: p1=anchor
 51 | 	y_span=p0[1]-p1[1]
 52 | 	x_span=p0[0]-p1[0]
 53 | 	return y_span**2 + x_span**2
 54 | 
 55 | 
 56 | # Returns the determinant of the 3x3 matrix...
 57 | # 	[p1(x) p1(y) 1]
 58 | #	[p2(x) p2(y) 1]
 59 | # 	[p3(x) p3(y) 1]
 60 | # If >0 then counter-clockwise
 61 | # If <0 then clockwise
 62 | # If =0 then collinear
 63 | def det(p1,p2,p3):
 64 | 	return   (p2[0]-p1[0])*(p3[1]-p1[1]) \
 65 | 			-(p2[1]-p1[1])*(p3[0]-p1[0])
 66 | 
 67 | 
 68 | # Sorts in order of increasing polar angle from 'anchor' point.
 69 | # 'anchor' variable is assumed to be global, set from within 'graham_scan'.
 70 | # For any values with equal polar angles, a second sort is applied to
 71 | # ensure increasing distance from the 'anchor' point.
 72 | def quicksort(a):
 73 | 	if len(a)<=1: return a
 74 | 	smaller,equal,larger=[],[],[]
 75 | 	piv_ang=polar_angle(a[randint(0,len(a)-1)]) # select random pivot
 76 | 	for pt in a:
 77 | 		pt_ang=polar_angle(pt) # calculate current point angle
 78 | 		if   pt_ang<piv_ang:  smaller.append(pt)
 79 | 		elif pt_ang==piv_ang: equal.append(pt)
 80 | 		else: 				  larger.append(pt)
 81 | 	return   quicksort(smaller) \
 82 | 			+sorted(equal,key=distance) \
 83 | 			+quicksort(larger)
 84 | 
 85 | 
 86 | # Returns the vertices comprising the boundaries of
 87 | # convex hull containing all points in the input set. 
 88 | # The input 'points' is a list of (x,y) coordinates.
 89 | # If 'show_progress' is set to True, the progress in 
 90 | # constructing the hull will be plotted on each iteration.
 91 | def graham_scan(points,show_progress=False):
 92 | 	global anchor # to be set, (x,y) with smallest y value
 93 | 
 94 | 	# Find the (x,y) point with the lowest y value,
 95 | 	# along with its index in the 'points' list. If
 96 | 	# there are multiple points with the same y value,
 97 | 	# choose the one with smallest x.
 98 | 	min_idx=None
 99 | 	for i,(x,y) in enumerate(points):
100 | 		if min_idx==None or y<points[min_idx][1]:
101 | 			min_idx=i
102 | 		if y==points[min_idx][1] and x<points[min_idx][0]:
103 | 			min_idx=i
104 | 
105 | 	# set the global variable 'anchor', used by the
106 | 	# 'polar_angle' and 'distance' functions
107 | 	anchor=points[min_idx]
108 | 
109 | 	# sort the points by polar angle then delete 
110 | 	# the anchor from the sorted list
111 | 	sorted_pts=quicksort(points)
112 | 	del sorted_pts[sorted_pts.index(anchor)]
113 | 
114 | 	# anchor and point with smallest polar angle will always be on hull
115 | 	hull=[anchor,sorted_pts[0]]
116 | 	for s in sorted_pts[1:]:
117 | 		while det(hull[-2],hull[-1],s)<=0:
118 | 			del hull[-1] # backtrack
119 | 			#if len(hull)<2: break
120 | 		hull.append(s)
121 | 		if show_progress: scatter_plot(points,hull)
122 | 	return hull
123 | 
124 | # For each size in the 'sizes' list, compute the average
125 | # time to find the Convex Hull for a dataset of that size,
126 | # the range used for max and min for the create_points function
127 | # is always 10 times the highest value in the 'sizes' list.
128 | def benchmark(sizes=[10,100,1000,10000,100000]):
129 | 	for s in sizes:
130 | 		tot=0.0
131 | 		for _ in range(3):
132 | 			pts=create_points(s,0,max(sizes)*10)
133 | 			t0=time()
134 | 			hull=graham_scan(pts,False)
135 | 			tot+=(time()-t0)
136 | 		print "size %d time: %0.5f"%(s,tot/3.0)
137 | 
138 | 
139 | pts=create_points(10)
140 | print "Points:",pts
141 | hull=graham_scan(pts,True)
142 | print "Hull:",hull
143 | scatter_plot(pts,hull)
144 | 


--------------------------------------------------------------------------------
/tree/main.py:
--------------------------------------------------------------------------------
  1 | 
  2 | import sys
  3 | 
  4 | class node:
  5 | 	def __init__(self,value=None):
  6 | 		self.value=value
  7 | 		self.parent=None # added this
  8 | 		self.left_child=None
  9 | 		self.right_child=None
 10 | 
 11 | 	# added this
 12 | 	def __str__(self):
 13 | 		return "Node with value: %d"%self.value
 14 | 
 15 | class binary_tree:
 16 | 	def __init__(self):
 17 | 		self.root=None
 18 | 
 19 | 	def insert(self,value):
 20 | 		if self.root==None: self.root=node(value)
 21 | 		else: 			    self._insert(value,self.root)
 22 | 
 23 | 	def _insert(self,value,cur_node):
 24 | 		if value<cur_node.value:
 25 | 			if cur_node.left_child!=None: self._insert(value,cur_node.left_child)
 26 | 			else: 						  
 27 | 				cur_node.left_child=node(value)
 28 | 				cur_node.left_child.parent=cur_node # added this 
 29 | 		else:
 30 | 			if cur_node.right_child!=None: self._insert(value,cur_node.right_child)
 31 | 			else: 						   
 32 | 				cur_node.right_child=node(value)
 33 | 				cur_node.right_child.parent=cur_node
 34 | 
 35 | 	def find(self,value):
 36 | 		return self._find(value,self.root) if self.root!=None else None
 37 | 
 38 | 	def _find(self,value,cur_node):
 39 | 		if value==cur_node.value: 
 40 | 			return cur_node 
 41 | 		elif value<cur_node.value and cur_node.left_child!=None: 
 42 | 			return self._find(value,cur_node.left_child)
 43 | 		elif value>cur_node.value and cur_node.right_child!=None:
 44 | 			return self._find(value,cur_node.right_child)
 45 | 
 46 | 	def print_tree(self):
 47 | 		if self.root!=None: self._print_tree(self.root)
 48 | 
 49 | 	def _print_tree(self,cur_node):
 50 | 		if cur_node!=None:
 51 | 			self._print_tree(cur_node.left_child)
 52 | 			print "%d "%cur_node.value
 53 | 			self._print_tree(cur_node.right_child)
 54 | 
 55 | 	def depth(self):
 56 | 		return self._depth(self.root,0) if self.root!=None else 0
 57 | 
 58 | 	def _depth(self,cur_node,cur_depth):
 59 | 		if cur_node==None: return cur_depth
 60 | 		left_depth=self._depth(cur_node.left_child,cur_depth+1)
 61 | 		right_depth=self._depth(cur_node.right_child,cur_depth+1)
 62 | 		return max(left_depth,right_depth)
 63 | 
 64 | 	def display(self):
 65 | 		print "_"*15
 66 | 		levels=[]
 67 | 		cur_nodes=[self.root]
 68 | 		while True:
 69 | 			if len(cur_nodes)==0: break
 70 | 			cur_values=[]
 71 | 			next_nodes=[]
 72 | 			for n in cur_nodes:
 73 | 				if n.value!=None:       cur_values.append(n.value)
 74 | 				if n.left_child!=None:  next_nodes.append(n.left_child)
 75 | 				if n.right_child!=None: next_nodes.append(n.right_child)
 76 | 			levels.append(cur_values)
 77 | 			cur_nodes=next_nodes
 78 | 		for i,level in enumerate(levels):
 79 | 			sys.stdout.write("Level %d:  "%i)
 80 | 			for n in level:
 81 | 				sys.stdout.write("%d "%n)
 82 | 			sys.stdout.write("\n")
 83 | 		print "_"*15
 84 | 
 85 | 	# performs breath-first search for value parameter
 86 | 	def bfs(self,value):
 87 | 		cur_nodes=[self.root]
 88 | 		while True:
 89 | 			next_nodes=[]
 90 | 			for c in cur_nodes:
 91 | 				if c.value==value: return True
 92 | 				if c.left_child!=None:  next_nodes.append(c.left_child)
 93 | 				if c.right_child!=None: next_nodes.append(c.right_child)
 94 | 			cur_nodes=next_nodes
 95 | 			if len(cur_nodes)==0:
 96 | 				return False
 97 | 
 98 | 	# performs pre-order depth-first search for value parameter
 99 | 	def dfs(self,value,cur_node=-1):
100 | 		if cur_node==-1:          cur_node=self.root
101 | 		if cur_node==None:        return False
102 | 		if cur_node.value==value: return True
103 | 		in_left  =self.dfs(value,cur_node.left_child)
104 | 		in_right =self.dfs(value,cur_node.right_child)
105 | 		if in_left or in_right: 
106 | 			return True
107 | 		else:
108 | 			return False
109 | 
110 | 	# deletes the specified input node
111 | 	def delete_node(self,node):
112 | 
113 | 		# HELPER FUNCTION
114 | 		# returns the node with minimum value in a tree (could be a sub-tree)
115 | 		def min_value_node(n):
116 | 			current=n 
117 | 			while current.left_child!=None:
118 | 				current=current.left_child
119 | 			return current
120 | 
121 | 		# HELPER FUNCTION
122 | 		# returns the number of children for the specified node
123 | 		def num_children(n):
124 | 			num_children=0
125 | 			if n.left_child!=None: num_children+=1
126 | 			if n.right_child!=None: num_children+=1
127 | 			return num_children
128 | 
129 | 		# get the parent of the node to be deleted
130 | 		node_parent=node.parent 
131 | 
132 | 		# get the number of children for the node
133 | 		node_children=num_children(node)
134 | 
135 | 		# CASE 1 (node has no children)
136 | 		if node_children==0:
137 | 
138 | 			# remove the reference to the node from the parent
139 | 			if node_parent.left_child==node:
140 | 				node_parent.left_child=None
141 | 			else:
142 | 				node_parent.right_child=None 
143 | 
144 | 		# CASE 2 (node has a single child)
145 | 		elif node_children==1:
146 | 
147 | 			# get the child node
148 | 			child=node.left_child if node.left_child!=None else node.right_child
149 | 
150 | 			# put the child node in place of the delete node
151 | 			if node_parent.left_child==node: node_parent.left_child=child 
152 | 			else: node_parent.right_child=child 
153 | 
154 | 			# set the parent of the new child
155 | 			child.parent=node_parent
156 | 
157 | 		# CASE 3 (node has two children)
158 | 		else:
159 | 			# get the inorder successor of the deleted node
160 | 			inorder_successor = min_value_node(node.right_child)
161 | 			# copy the inorder successor's content to deleted node
162 | 			node.value = inorder_successor.value 
163 | 			# delete the inorder successor 
164 | 			self.delete_node(inorder_successor)
165 | 
166 | 	# deletes the node in the tree with the specified value
167 | 	def delete_value(self,value):
168 | 		return self.delete_node(self.find(value))
169 | 
170 | 
171 | tree = binary_tree()
172 | tree.insert(3)
173 | tree.insert(4)
174 | tree.insert(0)
175 | tree.insert(-4)
176 | tree.insert(2)
177 | tree.insert(8)
178 | 
179 | tree.display()
180 | 
181 | 
182 | 
183 | 
184 | 
185 | 
186 | 


--------------------------------------------------------------------------------
/perceptron/main.py:
--------------------------------------------------------------------------------
  1 | from __future__ import print_function
  2 | import matplotlib,sys
  3 | from matplotlib import pyplot as plt
  4 | import numpy as np
  5 | 
  6 | def predict(inputs,weights):
  7 | 	activation=0.0
  8 | 	for i,w in zip(inputs,weights):
  9 | 		activation += i*w 
 10 | 	return 1.0 if activation>=0.0 else 0.0
 11 | 
 12 | def plot(matrix,weights=None,title="Prediction Matrix"):
 13 | 
 14 | 	if len(matrix[0])==3: # if 1D inputs, excluding bias and ys 
 15 | 		fig,ax = plt.subplots()
 16 | 		ax.set_title(title)
 17 | 		ax.set_xlabel("i1")
 18 | 		ax.set_ylabel("Classifications")
 19 | 
 20 | 		if weights!=None:
 21 | 			y_min=-0.1
 22 | 			y_max=1.1
 23 | 			x_min=0.0
 24 | 			x_max=1.1
 25 | 			y_res=0.001
 26 | 			x_res=0.001
 27 | 			ys=np.arange(y_min,y_max,y_res)
 28 | 			xs=np.arange(x_min,x_max,x_res)
 29 | 			zs=[]
 30 | 			for cur_y in np.arange(y_min,y_max,y_res):
 31 | 				for cur_x in np.arange(x_min,x_max,x_res):
 32 | 					zs.append(predict([1.0,cur_x],weights))
 33 | 			xs,ys=np.meshgrid(xs,ys)
 34 | 			zs=np.array(zs)
 35 | 			zs = zs.reshape(xs.shape)
 36 | 			cp=plt.contourf(xs,ys,zs,levels=[-1,-0.0001,0,1],colors=('b','r'),alpha=0.1)
 37 | 		
 38 | 		c1_data=[[],[]]
 39 | 		c0_data=[[],[]]
 40 | 
 41 | 		for i in range(len(matrix)):
 42 | 			cur_i1 = matrix[i][1]
 43 | 			cur_y  = matrix[i][-1]
 44 | 
 45 | 			if cur_y==1:
 46 | 				c1_data[0].append(cur_i1)
 47 | 				c1_data[1].append(1.0)
 48 | 			else:
 49 | 				c0_data[0].append(cur_i1)
 50 | 				c0_data[1].append(0.0)
 51 | 
 52 | 		plt.xticks(np.arange(x_min,x_max,0.1))
 53 | 		plt.yticks(np.arange(y_min,y_max,0.1))
 54 | 		plt.xlim(0,1.05)
 55 | 		plt.ylim(-0.05,1.05)
 56 | 
 57 | 		c0s = plt.scatter(c0_data[0],c0_data[1],s=40.0,c='r',label='Class -1')
 58 | 		c1s = plt.scatter(c1_data[0],c1_data[1],s=40.0,c='b',label='Class 1')
 59 | 
 60 | 		plt.legend(fontsize=10,loc=1)
 61 | 		plt.show()
 62 | 		return
 63 | 
 64 | 	if len(matrix[0])==4: # if 2D inputs, excluding bias and ys
 65 | 		fig,ax = plt.subplots()
 66 | 		ax.set_title(title)
 67 | 		ax.set_xlabel("i1")
 68 | 		ax.set_ylabel("i2")
 69 | 
 70 | 		if weights!=None:
 71 | 			map_min=0.0
 72 | 			map_max=1.1
 73 | 			y_res=0.001
 74 | 			x_res=0.001
 75 | 			ys=np.arange(map_min,map_max,y_res)
 76 | 			xs=np.arange(map_min,map_max,x_res)
 77 | 			zs=[]
 78 | 			for cur_y in np.arange(map_min,map_max,y_res):
 79 | 				for cur_x in np.arange(map_min,map_max,x_res):
 80 | 					zs.append(predict([1.0,cur_x,cur_y],weights))
 81 | 			xs,ys=np.meshgrid(xs,ys)
 82 | 			zs=np.array(zs)
 83 | 			zs = zs.reshape(xs.shape)
 84 | 			cp=plt.contourf(xs,ys,zs,levels=[-1,-0.0001,0,1],colors=('b','r'),alpha=0.1)
 85 | 
 86 | 		c1_data=[[],[]]
 87 | 		c0_data=[[],[]]
 88 | 		for i in range(len(matrix)):
 89 | 			cur_i1 = matrix[i][1]
 90 | 			cur_i2 = matrix[i][2]
 91 | 			cur_y  = matrix[i][-1]
 92 | 			if cur_y==1:
 93 | 				c1_data[0].append(cur_i1)
 94 | 				c1_data[1].append(cur_i2)
 95 | 			else:
 96 | 				c0_data[0].append(cur_i1)
 97 | 				c0_data[1].append(cur_i2)
 98 | 
 99 | 		plt.xticks(np.arange(0.0,1.1,0.1))
100 | 		plt.yticks(np.arange(0.0,1.1,0.1))
101 | 		plt.xlim(0,1.05)
102 | 		plt.ylim(0,1.05)
103 | 
104 | 		c0s = plt.scatter(c0_data[0],c0_data[1],s=40.0,c='r',label='Class -1')
105 | 		c1s = plt.scatter(c1_data[0],c1_data[1],s=40.0,c='b',label='Class 1')
106 | 
107 | 		plt.legend(fontsize=10,loc=1)
108 | 		plt.show()
109 | 		return
110 | 	
111 | 	print("Matrix dimensions not covered.")
112 | 
113 | # each matrix row: up to last row = inputs, last row = y (classification)
114 | def accuracy(matrix,weights):
115 | 	num_correct = 0.0
116 | 	preds       = []
117 | 	for i in range(len(matrix)):
118 | 		pred   = predict(matrix[i][:-1],weights) # get predicted classification
119 | 		preds.append(pred)
120 | 		if pred==matrix[i][-1]: num_correct+=1.0 
121 | 	print("Predictions:",preds)
122 | 	return num_correct/float(len(matrix))
123 | 
124 | # each matrix row: up to last row = inputs, last row = y (classification)
125 | def train_weights(matrix,weights,nb_epoch=10,l_rate=1.00,do_plot=False,stop_early=True,verbose=True):
126 | 	for epoch in range(nb_epoch):
127 | 		cur_acc = accuracy(matrix,weights)
128 | 		print("\nEpoch %d \nWeights: "%epoch,weights)
129 | 		print("Accuracy: ",cur_acc)
130 | 		
131 | 		if cur_acc==1.0 and stop_early: break 
132 | 		if do_plot: plot(matrix,weights,title="Epoch %d"%epoch)
133 | 		
134 | 		for i in range(len(matrix)):
135 | 			prediction = predict(matrix[i][:-1],weights) # get predicted classificaion
136 | 			error      = matrix[i][-1]-prediction		 # get error from real classification
137 | 			if verbose: sys.stdout.write("Training on data at index %d...\n"%(i))
138 | 			for j in range(len(weights)): 				 # calculate new weight for each node
139 | 				if verbose: sys.stdout.write("\tWeight[%d]: %0.5f --> "%(j,weights[j]))
140 | 				weights[j] = weights[j]+(l_rate*error*matrix[i][j]) 
141 | 				if verbose: sys.stdout.write("%0.5f\n"%(weights[j]))
142 | 
143 | 	plot(matrix,weights,title="Final Epoch")
144 | 	return weights 
145 | 
146 | def main():
147 | 
148 | 	nb_epoch		= 10
149 | 	l_rate  		= 1.0
150 | 	plot_each_epoch	= False
151 | 	stop_early 		= True
152 | 
153 | 	part_A = True  
154 | 
155 | 	if part_A: # 3 inputs (including single bias input), 3 weights
156 | 
157 | 				# 	Bias 	i1 		i2 		y
158 | 		matrix = [	[1.00,	0.08,	0.72,	1.0],
159 | 					[1.00,	0.10,	1.00,	0.0],
160 | 					[1.00,	0.26,	0.58,	1.0],
161 | 					[1.00,	0.35,	0.95,	0.0],
162 | 					[1.00,	0.45,	0.15,	1.0],
163 | 					[1.00,	0.60,	0.30,	1.0],
164 | 					[1.00,	0.70,	0.65,	0.0],
165 | 					[1.00,	0.92,	0.45,	0.0]]
166 | 		weights= [	 0.20,	1.00,  -1.00		] # initial weights specified in problem
167 | 
168 | 	else: # 2 inputs (including single bias input), 2 weights
169 | 		
170 | 		nb_epoch = 1000
171 | 
172 | 				# 	Bias 	i1 		y
173 | 		matrix = [	[1.00,	0.08,	1.0],
174 | 					[1.00,	0.10,	0.0],
175 | 					[1.00,	0.26,	1.0],
176 | 					[1.00,	0.35,	0.0],
177 | 					[1.00,	0.45,	1.0],
178 | 					[1.00,	0.60,	1.0],
179 | 					[1.00,	0.70,	0.0],
180 | 					[1.00,	0.92,	0.0]]
181 | 		weights= [	 0.20,	1.00		] # initial weights specified in problem
182 | 
183 | 	train_weights(matrix,weights=weights,nb_epoch=nb_epoch,l_rate=l_rate,do_plot=plot_each_epoch,stop_early=stop_early)
184 | 
185 | 
186 | if __name__ == '__main__':
187 | 	main()


--------------------------------------------------------------------------------