Create huffman coding

huffman coding

@@ -0,0 +1,253 @@
+#include <stdio.h> 
+#include <stdlib.h> 
+
+#define MAX_TREE_HT 100 
+
+struct MinHeapNode { 
+
+
+	char data; 
+
+
+	unsigned freq; 
+
+	struct MinHeapNode *left, *right; 
+}; 
+
+
+struct MinHeap { 
+
+
+	unsigned size; 
+
+
+	unsigned capacity; 
+
+
+	struct MinHeapNode** array; 
+}; 
+
+
+struct MinHeapNode* newNode(char data, unsigned freq) 
+{ 
+	struct MinHeapNode* temp 
+		= (struct MinHeapNode*)malloc
+(sizeof(struct MinHeapNode)); 
+
+	temp->left = temp->right = NULL; 
+	temp->data = data; 
+	temp->freq = freq; 
+
+	return temp; 
+} 
+
+
+struct MinHeap* createMinHeap(unsigned capacity) 
+
+{ 
+
+	struct MinHeap* minHeap 
+		= (struct MinHeap*)malloc(sizeof(struct MinHeap)); 
+	minHeap->size = 0; 
+
+	minHeap->capacity = capacity; 
+
+	minHeap->array 
+		= (struct MinHeapNode**)malloc(minHeap-> 
+capacity * sizeof(struct MinHeapNode*)); 
+	return minHeap; 
+} 
+
+void swapMinHeapNode(struct MinHeapNode** a, 
+					struct MinHeapNode** b) 
+
+{ 
+
+	struct MinHeapNode* t = *a; 
+	*a = *b; 
+	*b = t; 
+} 
+
+void minHeapify(struct MinHeap* minHeap, int idx) 
+
+{ 
+
+	int smallest = idx; 
+	int left = 2 * idx + 1; 
+	int right = 2 * idx + 2; 
+
+	if (left < minHeap->size && minHeap->array[left]-> 
+freq < minHeap->array[smallest]->freq) 
+		smallest = left; 
+
+	if (right < minHeap->size && minHeap->array[right]-> 
+freq < minHeap->array[smallest]->freq) 
+		smallest = right; 
+
+	if (smallest != idx) { 
+		swapMinHeapNode(&minHeap->array[smallest], 
+						&minHeap->array[idx]); 
+		minHeapify(minHeap, smallest); 
+	} 
+} 
+
+
+int isSizeOne(struct MinHeap* minHeap) 
+{ 
+
+	return (minHeap->size == 1); 
+} 
+
+
+struct MinHeapNode* extractMin(struct MinHeap* minHeap) 
+
+{ 
+
+	struct MinHeapNode* temp = minHeap->array[0]; 
+	minHeap->array[0] 
+		= minHeap->array[minHeap->size - 1]; 
+
+	--minHeap->size; 
+	minHeapify(minHeap, 0); 
+
+	return temp; 
+} 
+
+void insertMinHeap(struct MinHeap* minHeap, 
+				struct MinHeapNode* minHeapNode) 
+
+{ 
+
+	++minHeap->size; 
+	int i = minHeap->size - 1; 
+
+	while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) { 
+
+		minHeap->array[i] = minHeap->array[(i - 1) / 2]; 
+		i = (i - 1) / 2; 
+	} 
+
+	minHeap->array[i] = minHeapNode; 
+} 
+
+void buildMinHeap(struct MinHeap* minHeap) 
+
+{ 
+
+	int n = minHeap->size - 1; 
+	int i; 
+
+	for (i = (n - 1) / 2; i >= 0; --i) 
+		minHeapify(minHeap, i); 
+} 
+
+void printArr(int arr[], int n) 
+{ 
+	int i; 
+	for (i = 0; i < n; ++i) 
+		printf("%d", arr[i]); 
+
+	printf("\n"); 
+} 
+
+
+int isLeaf(struct MinHeapNode* root) 
+
+{ 
+
+	return !(root->left) && !(root->right); 
+} 
+
+
+struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size) 
+
+{ 
+
+	struct MinHeap* minHeap = createMinHeap(size); 
+
+	for (int i = 0; i < size; ++i) 
+		minHeap->array[i] = newNode(data[i], freq[i]); 
+
+	minHeap->size = size; 
+	buildMinHeap(minHeap); 
+
+	return minHeap; 
+} 
+
+
+struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size) 
+
+{ 
+	struct MinHeapNode *left, *right, *top; 
+
+
+	struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size); 
+
+	while (!isSizeOne(minHeap)) { 
+
+
+		left = extractMin(minHeap); 
+		right = extractMin(minHeap); 
+
+
+		top = newNode('$', left->freq + right->freq); 
+
+		top->left = left; 
+		top->right = right; 
+
+		insertMinHeap(minHeap, top); 
+	} 
+
+
+	return extractMin(minHeap); 
+} 
+
+void printCodes(struct MinHeapNode* root, int arr[], int top) 
+
+{ 
+
+
+	if (root->left) { 
+
+		arr[top] = 0; 
+		printCodes(root->left, arr, top + 1); 
+	} 
+
+	if (root->right) { 
+
+		arr[top] = 1; 
+		printCodes(root->right, arr, top + 1); 
+	} 
+
+
+	if (isLeaf(root)) { 
+
+		printf("%c: ", root->data); 
+		printArr(arr, top); 
+	} 
+} 
+
+
+void HuffmanCodes(char data[], int freq[], int size) 
+
+{ 
+
+	struct MinHeapNode* root 
+		= buildHuffmanTree(data, freq, size); 
+
+	int arr[MAX_TREE_HT], top = 0; 
+
+	printCodes(root, arr, top); 
+} 
+int main() 
+{ 
+
+	char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' }; 
+	int freq[] = { 5, 9, 12, 13, 16, 45 }; 
+
+	int size = sizeof(arr) / sizeof(arr[0]); 
+
+	HuffmanCodes(arr, freq, size); 
+
+	return 0; 
+} 

round robin

@@ -0,0 +1,94 @@
+#include<iostream> 
+using namespace std; 
+
+void findWaitingTime(int processes[], int n, 
+			int bt[], int wt[], int quantum) 
+{ 
+	int rem_bt[n]; 
+	for (int i = 0 ; i < n ; i++) 
+		rem_bt[i] = bt[i]; 
+
+	int t = 0; // Current time 
+
+	while (1) 
+	{ 
+		bool done = true; 
+
+		for (int i = 0 ; i < n; i++) 
+		{ 
+
+			if (rem_bt[i] > 0) 
+			{ 
+				done = false; // There is a pending process 
+
+				if (rem_bt[i] > quantum) 
+				{ 
+
+					t += quantum; 
+
+					rem_bt[i] -= quantum; 
+				} 
+
+				else
+				{ 
+
+					t = t + rem_bt[i]; 
+
+					wt[i] = t - bt[i]; 
+
+					rem_bt[i] = 0; 
+				} 
+			} 
+		} 
+
+		if (done == true) 
+		break; 
+	} 
+} 
+
+void findTurnAroundTime(int processes[], int n, 
+						int bt[], int wt[], int tat[]) 
+{ 
+
+	for (int i = 0; i < n ; i++) 
+		tat[i] = bt[i] + wt[i]; 
+} 
+
+void findavgTime(int processes[], int n, int bt[], 
+									int quantum) 
+{ 
+	int wt[n], tat[n], total_wt = 0, total_tat = 0; 
+
+	findWaitingTime(processes, n, bt, wt, quantum); 
+
+	findTurnAroundTime(processes, n, bt, wt, tat); 
+
+	cout << "Processes "<< " Burst time "
+		<< " Waiting time " << " Turn around time\n"; 
+
+	for (int i=0; i<n; i++) 
+	{ 
+		total_wt = total_wt + wt[i]; 
+		total_tat = total_tat + tat[i]; 
+		cout << " " << i+1 << "\t\t" << bt[i] <<"\t "
+			<< wt[i] <<"\t\t " << tat[i] <<endl; 
+	} 
+
+	cout << "Average waiting time = "
+		<< (float)total_wt / (float)n; 
+	cout << "\nAverage turn around time = "
+		<< (float)total_tat / (float)n; 
+} 
+
+int main() 
+{ 
+
+	int processes[] = { 1, 2, 3}; 
+	int n = sizeof processes / sizeof processes[0]; 
+
+	int burst_time[] = {10, 5, 8}; 
+
+	int quantum = 2; 
+	findavgTime(processes, n, burst_time, quantum); 
+	return 0; 
+}