From e5fa7f4a40e3d7adb8c70a43abe97bfa5af2d22a Mon Sep 17 00:00:00 2001 From: Anwar4499 <47696269+Anwar4499@users.noreply.github.com> Date: Thu, 1 Oct 2020 20:50:00 +0530 Subject: [PATCH 1/2] Create huffman coding --- huffman coding | 253 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 huffman coding diff --git a/huffman coding b/huffman coding new file mode 100644 index 0000000..e3a00ea --- /dev/null +++ b/huffman coding @@ -0,0 +1,253 @@ +#include +#include + +#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; +} From 1e58181666d0b034cfde5ffa33f6d3c2b13d9a8c Mon Sep 17 00:00:00 2001 From: Anwar4499 <47696269+Anwar4499@users.noreply.github.com> Date: Thu, 1 Oct 2020 21:12:43 +0530 Subject: [PATCH 2/2] Create round robin --- round robin | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 round robin diff --git a/round robin b/round robin new file mode 100644 index 0000000..af72c2a --- /dev/null +++ b/round robin @@ -0,0 +1,94 @@ +#include +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