Sorting Algorithms in C++

Author: suresh-srivastava

sorting-algorithms/AddressCalculationSort.cpp

@@ -0,0 +1,136 @@
+//AddressCalculationSort.cpp : Program of sorting using address calculation sort.
+
+#include<iostream>
+using namespace std;
+
+static const int maxSize = 30;
+
+class Node
+{
+	public:
+		int info;
+		Node *link;
+		Node(int data)
+		{
+			info = data;
+			link = NULL;
+		}
+};//End of class Node
+
+class SortedLinkedList
+{
+	private:
+	    Node *start;
+		bool isEmpty() const;
+	public:
+		SortedLinkedList();
+		~SortedLinkedList();
+		void insert(int data);
+		Node* getStart();
+};//End of class SortedLinkedList
+
+SortedLinkedList::SortedLinkedList()
+{
+	start = NULL;
+}//End of SortedLinkedList()
+
+SortedLinkedList::~SortedLinkedList()
+{
+	Node *ptr;
+
+	while(start != NULL)
+	{
+		ptr = start->link;
+		delete start;
+		start = ptr;
+	}
+}//End of ~SortedLinkedList()
+
+Node* SortedLinkedList::getStart()
+{ 
+	return start;
+}//End of getStart()
+
+inline bool SortedLinkedList::isEmpty() const
+{
+	return start == NULL;
+}//End of isEmpty()
+
+void SortedLinkedList::insert(int data)
+{
+	Node *temp = new Node(data);
+	
+	//List empty or new node to be inserted before first node
+	if(isEmpty() || data < start->info)
+	{
+		temp->link = start;
+		start = temp;	
+	}
+	else
+	{
+		Node *ptr = start;
+		while(ptr->link != NULL && ptr->link->info < data)
+			ptr = ptr->link;
+		temp->link = ptr->link;
+		ptr->link = temp;
+	}
+}//End of insert()
+
+int hashFn(int x, int large)
+{
+	float temp;
+    temp = (float)x / large;
+    return (int)(temp * 5);
+}//End of hashFn()
+
+void addressCalculationSort(int arr[], int n)
+{
+	SortedLinkedList list[6];
+	int i;
+
+	int large = 0;
+    for(i=0; i<n; i++)
+    {
+		if(arr[i] > large)
+			large = arr[i];
+    }
+
+	int x;
+	for(i=0; i<n; i++)
+	{
+		x = hashFn(arr[i],large);
+		list[x].insert(arr[i]);
+	}
+
+   //Elements of linked lists are copied to array
+   Node *ptr;
+   i = 0;
+   for(int j=0; j<=5; j++)
+   {
+		ptr = list[j].getStart();
+        while(ptr != NULL)
+        {
+			arr[i++] = ptr->info;
+            ptr = ptr->link;
+		}
+    }//End of for
+}//End of addressCalculationSort()
+
+int main()
+{
+	int arr[maxSize] = {194, 289, 566, 432, 654, 98, 232, 415, 345, 276, 532, 254, 165, 965, 476};
+	int n = 15;
+
+	cout << "Unsorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+	addressCalculationSort(arr,n);
+	
+	cout << "Sorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+}//End of main()

sorting-algorithms/BinaryTreeSort.cpp

@@ -0,0 +1,129 @@
+//BinaryTreeSort.cpp : Program of sorting using binary tree sort.
+
+#include<iostream>
+using namespace std;
+
+static const int maxSize = 30;
+
+class Node
+{
+	public:
+		int info;
+		Node *lchild;
+		Node *rchild;
+
+		Node(int data) 
+		{
+			info = data;
+			lchild = NULL;
+			rchild = NULL;
+		}
+};//End of class Node
+
+class BinarySearchTree
+{ 
+	private:
+		Node *root;
+		static int k;
+
+	private:
+		void destroy(Node *ptr);
+		Node* insert(Node *ptr, int data);
+		void inorder(Node *ptr, int arr[]);
+	public:
+		BinarySearchTree();
+		~BinarySearchTree();
+		bool isEmpty();
+		void insert(int data);
+		void inorder(int arr[]);
+};//End of class BinarySearchTree
+
+int BinarySearchTree::k;   
+
+BinarySearchTree::BinarySearchTree()
+{
+	root = NULL;
+}//End of constructor BinarySearchTree()
+
+BinarySearchTree::~BinarySearchTree()
+{
+	destroy(root);
+	root = NULL;
+}//End of destructor ~BinarySearchTree()
+
+void BinarySearchTree::destroy(Node *ptr)
+{
+	if(ptr == NULL)
+		return;
+	destroy(ptr->lchild);
+	destroy(ptr->rchild);
+	delete ptr;
+}//End of destroy()
+
+bool BinarySearchTree::isEmpty()
+{
+	return root == NULL;
+}//End of isEmpty()
+
+Node* BinarySearchTree::insert(Node *ptr, int data)
+{
+	if(ptr == NULL)	
+		ptr = new Node(data);
+	else if(data < ptr->info)	
+		ptr->lchild = insert(ptr->lchild, data);
+	else 
+		ptr->rchild = insert(ptr->rchild, data);  
+	return ptr;
+}//End of insert()
+
+void BinarySearchTree::insert(int data)
+{
+	root = insert(root, data);
+}//End of insert()
+
+//Recursive inorder traversal
+void BinarySearchTree::inorder(Node *ptr, int arr[])
+{
+	if(ptr == NULL)	
+		return;
+	inorder(ptr->lchild,arr);
+	arr[k++] = ptr->info;
+	inorder(ptr->rchild,arr);
+}//End of inorder()
+
+void BinarySearchTree::inorder(int arr[])
+{
+	k = 0;
+	inorder(root,arr);
+}//End of inorder()
+
+void binaryTreeSort(int arr[], int n)
+{
+	BinarySearchTree bst;
+
+    for(int i = 0; i < n; i++)
+		bst.insert(arr[i]);
+    bst.inorder(arr);
+}//End of binaryTreeSort()
+
+int main()
+{
+	int arr[maxSize] = {19, 35, 10, 12, 46, 6, 40, 3, 90, 8};
+	int n = 10;
+
+	cout << "Unsorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+	binaryTreeSort(arr,n);
+	
+	cout << "Sorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+}//End of main()
+
+
+

sorting-algorithms/BubbleSort.cpp

@@ -0,0 +1,48 @@
+//BubbleSort.cpp : Program of sorting using bubble sort.
+
+#include<iostream>
+using namespace std;
+
+static const int maxSize = 30;
+
+void bubbleSort(int arr[], int n)
+{
+	int temp, xchanges;
+
+	for(int i=0; i<n-1 ;i++)
+	{
+		xchanges = 0;
+		for(int j=0; j<n-1-i; j++)
+		{
+			if(arr[j] > arr[j+1])
+			{
+				temp = arr[j];
+				arr[j] = arr[j+1];
+				arr[j+1] = temp;
+				xchanges++;
+			}
+		}
+		if(xchanges == 0) //If list is sorted
+			break;
+	}//End of for
+}//End of bubbleSort()
+
+int main()
+{
+	int arr[maxSize] = {40, 20, 50, 60, 30, 10, 90, 97, 70, 80};
+	int n = 10;
+
+	cout << "Unsorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+	bubbleSort(arr,n);
+	
+	cout << "Sorted list is :\n"; 
+	for(int i=0; i<n; i++)
+		cout << arr[i] << " ";
+	cout << "\n";
+
+}//End of main()
+