heap sort

dsa-roadmaps/Beginners/Problem Solving/heapsort.py

@@ -0,0 +1,48 @@
+# 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]),
+# This code is contributed by Mohit Kumra

dsa-roadmaps/Beginners/Problem Solving/maxsum.py

@@ -0,0 +1,16 @@
+def maxSubArraySum(arr,len):
+
+	max_sum_so_far = arr[0]
+	max_ending_here = 0
+
+	for i in range(0, size):
+		max_ending_here = max_ending_here + a[i]
+		if max_ending_here < 0:
+			max_ending_here = 0
+
+		# Do not compare for all elements. Compare only
+		# when max_ending_here > 0
+		elif (max_sum_so_far < max_ending_here):
+			max_sum_so_far = max_ending_here
+
+	return max_sum_so_far

heapsort.py

@@ -0,0 +1,48 @@
+# 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]),
+# This code is contributed by Mohit Kumra

path sum binary tree

@@ -0,0 +1,72 @@
+// C/C++ program to find maximum path sum in Binary Tree
+#include<bits/stdc++.h>
+using namespace std;
+
+// A binary tree node
+struct Node
+{
+	int data;
+	struct Node* left, *right;
+};
+
+// A utility function to allocate a new node
+struct Node* newNode(int data)
+{
+	struct Node* newNode = new Node;
+	newNode->data = data;
+	newNode->left = newNode->right = NULL;
+	return (newNode);
+}
+
+// This function returns overall maximum path sum in 'res'
+// And returns max path sum going through root.
+int findMaxUtil(Node* root, int &res)
+{
+	//Base Case
+	if (root == NULL)
+		return 0;
+
+	// l and r store maximum path sum going through left and
+	// right child of root respectively
+	int l = findMaxUtil(root->left,res);
+	int r = findMaxUtil(root->right,res);
+
+	// Max path for parent call of root. This path must
+	// include at-most one child of root
+	int max_single = max(max(l, r) + root->data, root->data);
+
+	// Max Top represents the sum when the Node under
+	// consideration is the root of the maxsum path and no
+	// ancestors of root are there in max sum path
+	int max_top = max(max_single, l + r + root->data);
+
+	res = max(res, max_top); // Store the Maximum Result.
+
+	return max_single;
+}
+
+// Returns maximum path sum in tree with given root
+int findMaxSum(Node *root)
+{
+	// Initialize result
+	int res = INT_MIN;
+
+	// Compute and return result
+	findMaxUtil(root, res);
+	return res;
+}
+
+// Driver program
+int main(void)
+{
+	struct Node *root = newNode(10);
+	root->left	 = newNode(2);
+	root->right	 = newNode(10);
+	root->left->left = newNode(20);
+	root->left->right = newNode(1);
+	root->right->right = newNode(-25);
+	root->right->right->left = newNode(3);
+	root->right->right->right = newNode(4);
+	cout << "Max path sum is " << findMaxSum(root);
+	return 0;
+}