sorting

Heap sort.py

@@ -0,0 +1,47 @@
+# Python program for implementation of heap Sort
+
+# To heapify subtree rooted at index i.
+# n is size of heap
+def heapify(arr, n, i):
+	largest = i # Initialize largest as root
+	l = 2 * i + 1	 # left = 2*i + 1
+	r = 2 * i + 2	 # right = 2*i + 2
+
+	# See if left child of root exists and is
+	# greater than root
+	if l < n and arr[i] < arr[l]:
+		largest = l
+
+	# See if right child of root exists and is
+	# greater than root
+	if r < n and arr[largest] < arr[r]:
+		largest = r
+
+	# Change root, if needed
+	if largest != i:
+		arr[i],arr[largest] = arr[largest],arr[i] # swap
+
+		# Heapify the root.
+		heapify(arr, n, largest)
+
+# The main function to sort an array of given size
+def heapSort(arr):
+	n = len(arr)
+
+	# Build a maxheap.
+	# Since last parent will be at ((n//2)-1) we can start at that location.
+	for i in range(n // 2 - 1, -1, -1):
+		heapify(arr, n, i)
+
+	# One by one extract elements
+	for i in range(n-1, 0, -1):
+		arr[i], arr[0] = arr[0], arr[i] # swap
+		heapify(arr, i, 0)
+
+# Driver code to test above
+arr = [ 12, 11, 13, 5, 6, 7]
+heapSort(arr)
+n = len(arr)
+print ("Sorted array is")
+for i in range(n):
+	print ("%d" %arr[i]),

Merge Sort.py

@@ -0,0 +1,78 @@
+# Python program for implementation of MergeSort
+
+# Merges two subarrays of arr[].
+# First subarray is arr[l..m]
+# Second subarray is arr[m+1..r]
+
+
+def merge(arr, l, m, r):
+    n1 = m - l + 1
+    n2 = r - m
+
+    # create temp arrays
+    L = [0] * (n1)
+    R = [0] * (n2)
+
+    # Copy data to temp arrays L[] and R[]
+    for i in range(0, n1):
+        L[i] = arr[l + i]
+
+    for j in range(0, n2):
+        R[j] = arr[m + 1 + j]
+
+    # Merge the temp arrays back into arr[l..r]
+    i = 0  # Initial index of first subarray
+    j = 0  # Initial index of second subarray
+    k = l  # Initial index of merged subarray
+
+    while i < n1 and j < n2:
+        if L[i] <= R[j]:
+            arr[k] = L[i]
+            i += 1
+        else:
+            arr[k] = R[j]
+            j += 1
+        k += 1
+
+    # Copy the remaining elements of L[], if there
+    # are any
+    while i < n1:
+        arr[k] = L[i]
+        i += 1
+        k += 1
+
+    # Copy the remaining elements of R[], if there
+    # are any
+    while j < n2:
+        arr[k] = R[j]
+        j += 1
+        k += 1
+
+
+# l is for left index and r is right index of the
+# sub-array of arr to be sorted
+
+
+def mergeSort(arr, l, r):
+    if l < r:
+        # Same as (l+r)//2, but avoids overflow for
+        # large l and h
+        m = l + (r - l) // 2
+
+        # Sort first and second halves
+        mergeSort(arr, l, m)
+        mergeSort(arr, m + 1, r)
+        merge(arr, l, m, r)
+
+
+# Driver code to test above
+arr = [12, 11, 13, 5, 6, 7]
+n = len(arr)
+print("Given array is")
+for i in range(n):
+    print("%d" % arr[i]),
+
+mergeSort(arr, 0, n - 1)
+print("\n\nSorted array is")
+for i in range(n):
+    print("%d" % arr[i]),

Quick sort.py

@@ -0,0 +1,46 @@
+def partition(arr, low, high):
+    i = (low - 1)  # index of smaller element
+    pivot = arr[high]  # pivot
+
+    for j in range(low, high):
+
+        # If current element is smaller than or
+        # equal to pivot
+        if arr[j] <= pivot:
+            # increment index of smaller element
+            i = i + 1
+            arr[i], arr[j] = arr[j], arr[i]
+
+    arr[i + 1], arr[high] = arr[high], arr[i + 1]
+    return (i + 1)
+
+
+# The main function that implements QuickSort
+# arr[] --> Array to be sorted,
+# low  --> Starting index,
+# high  --> Ending index
+
+# Function to do Quick sort
+
+
+def quickSort(arr, low, high):
+    if len(arr) == 1:
+        return arr
+    if low < high:
+        # pi is partitioning index, arr[p] is now
+        # at right place
+        pi = partition(arr, low, high)
+
+        # Separately sort elements before
+        # partition and after partition
+        quickSort(arr, low, pi - 1)
+        quickSort(arr, pi + 1, high)
+
+
+# Driver code to test above
+arr = [10, 7, 8, 9, 1, 5]
+n = len(arr)
+quickSort(arr, 0, n - 1)
+print("Sorted array is:")
+for i in range(n):
+    print("%d" % arr[i]),

Weight converter.py

@@ -0,0 +1,66 @@
+# Python program to  create a simple GUI
+# weight converter using Tkinter
+
+
+from tkinter import *
+
+# Create a GUI window
+window = Tk()
+
+
+# Function to convert weight
+# given in kg to grams, pounds
+# and ounces
+def from_kg():
+    # convert kg to gram
+    gram = float(e2_value.get()) * 1000
+
+    # convert kg to pound
+    pound = float(e2_value.get()) * 2.20462
+
+    # convert kg to ounce
+    ounce = float(e2_value.get()) * 35.274
+
+    # Enters the converted weight to
+    # the text widget
+    t1.delete("1.0", END)
+    t1.insert(END, gram)
+
+    t2.delete("1.0", END)
+    t2.insert(END, pound)
+
+    t3.delete("1.0", END)
+    t3.insert(END, ounce)
+
+
+# Create the Label widgets
+e1 = Label(window, text="Enter the weight in Kg")
+e2_value = StringVar()
+e2 = Entry(window, textvariable=e2_value)
+e3 = Label(window, text='Gram')
+e4 = Label(window, text='Pounds')
+e5 = Label(window, text='Ounce')
+
+# Create the Text Widgets
+t1 = Text(window, height=1, width=20)
+t2 = Text(window, height=1, width=20)
+t3 = Text(window, height=1, width=20)
+
+# Create the Button Widget
+b1 = Button(window, text="Convert", command=from_kg)
+
+# grid method is used for placing
+# the widgets at respective positions
+# in table like structure
+e1.grid(row=0, column=0)
+e2.grid(row=0, column=1)
+e3.grid(row=1, column=0)
+e4.grid(row=1, column=1)
+e5.grid(row=1, column=2)
+t1.grid(row=2, column=0)
+t2.grid(row=2, column=1)
+t3.grid(row=2, column=2)
+b1.grid(row=0, column=2)
+
+# Start the GUI
+window.mainloop()