From 5b6f43c7ea484166f3dd16636eb62e657f376165 Mon Sep 17 00:00:00 2001 From: Minh Tien Nguyen Date: Tue, 6 Nov 2018 20:54:44 +0700 Subject: [PATCH] Update Lab7 --- Lab7/Lab7.cpp | 199 ++++++++++++++++++++++++++++++++++++++ Lab7/binarysearchtree.cpp | 80 +++++++++++++++ Lab7/binarysearchtree.h | 15 +++ Lab7/treenode.cpp | 55 +++++++++++ Lab7/treenode.h | 26 +++++ 5 files changed, 375 insertions(+) create mode 100644 Lab7/Lab7.cpp create mode 100644 Lab7/binarysearchtree.cpp create mode 100644 Lab7/binarysearchtree.h create mode 100644 Lab7/treenode.cpp create mode 100644 Lab7/treenode.h diff --git a/Lab7/Lab7.cpp b/Lab7/Lab7.cpp new file mode 100644 index 0000000..ab2eb8b --- /dev/null +++ b/Lab7/Lab7.cpp @@ -0,0 +1,199 @@ +#include +#include + +#include "binarysearchtree.h" + +#define MAX_HEAP_ELEMENT 1000 + +using namespace std; + +void reheapUp(int *&maxHeap, int pos, int size) +{ + if (pos <= 0 || pos >= size) + return; + int parent = (pos - 1) / 2; + if (maxHeap[pos] < maxHeap[parent]) + return; + swap(maxHeap[pos], maxHeap[parent]); + reheapUp(maxHeap, parent, size); +} + +int *buildHeap(int *arr, int size) +{ + int *maxHeap = new int[MAX_HEAP_ELEMENT]; + for (int i = 0; i < size; ++i) { + maxHeap[i] = arr[i]; + reheapUp(maxHeap, i, i + 1); + } + return maxHeap; +} + +//Cau_1 +void printHeap(int *heap, int size) +{ + if (size <= 0) + return; + int height = int(log(size) / log(2)) + 1; + for (int i = 0; i < size; ++i) { + int level = int(log(i + 1) / log(2)); + int space = int(pow(2, height - level - 2)); + for (int i = 0; i < space; ++i) { + cout << " "; + } + for (int i = 1; i < space; ++i) { + cout << "---"; + } + if (heap[i] < 10) + cout << "0"; + if (heap[i] < 100) + cout << "0"; + cout << heap[i]; + for (int i = 1; i < space; ++i) { + cout << "---"; + } + for (int i = 0; i < space; ++i) { + cout << " "; + } + cout << " "; + if (i == int(pow(2, level + 1) - 2)) + cout << endl; + } + cout << endl; +} + +void buildHeapFromSubroot(int *&maxHeap, int &size, TreeNode *node) +{ + if (node == nullptr) + return; + if (node->getRight() != nullptr) + buildHeapFromSubroot(maxHeap, size, node->getRight()); + maxHeap[size] = node->getData(); + ++size; + if (node->getLeft() != nullptr) + buildHeapFromSubroot(maxHeap, size, node->getLeft()); +} + +//Cau_2 +int *buildHeapFromBST(BinarySearchTree *bst, int &size) +{ + if (bst == nullptr) + return nullptr; + int *maxHeap = new int[MAX_HEAP_ELEMENT]; + size = 0; + buildHeapFromSubroot(maxHeap, size, bst->root); + return maxHeap; +} + +//Cau_3a +long long int f1(int *key, int size) +{ + long long int hf = 7719; + long long int hash = 0; + for (int i = 0; i < size; ++i) { + long long int p = 1; + for (int j = 0; j < i; ++j) { + p *= key[i]; + p %= hf; + } + p *= 7; + p %= hf; + hash += p; + hash %= hf; + } + return hash; +} + +//Cau_3b +long long int f2(int *key, int size) +{ + long long int hf = 7719; + long long int hash = 0; + for (int i = 0; i < size; ++i) { + long long int p = 1; + for (int j = 0; j < key[i]; ++j) { + p *= key[i]; + p %= hf; + } + p *= 7; + p %= hf; + hash += p; + hash %= hf; + } + return hash; +} + +//Cau_4a +void reheapUp(int *&maxHeap, int position) +{ + if (position > 0) { + int parent = (position - 1) / 2; + if (maxHeap[position] > maxHeap[parent]) { + swap(maxHeap[position], maxHeap[parent]); + reheapUp(maxHeap, position); + } + } +} + +void reheapDown(int *&maxHeap, int position, int size) +{ + if (position < 0 || position >= size) + return; + int leftChild = position * 2 + 1; + int rightChild = position * 2 + 2; + int largeChild = -1; + if (leftChild <= size - 1) { + if (rightChild <= size - 1 && maxHeap[rightChild] > maxHeap[leftChild]) { + largeChild = rightChild; + } else { + largeChild = leftChild; + } + if (maxHeap[largeChild] > maxHeap[position]) { + swap(maxHeap[largeChild], maxHeap[position]); + reheapDown(maxHeap, largeChild, size); + } + } +} + +void reheapDownMinHeap(int *&minHeap, int pos, int size) +{ + if (pos < 0 || pos > (size - 2) / 2) + return; + int l = 2 * pos + 1; + if (l >= size) + return; + int posMin = l; + int r = l + 1; + if (2 * pos + 2 < size) { + if (minHeap[r] < minHeap[posMin]) { + posMin = r; + } + } + if (minHeap[pos] > minHeap[posMin]) { + swap(minHeap[pos], minHeap[posMin]); + reheapDownMinHeap(minHeap, posMin, size); + } +} + +//Cau4_b +void maxHeapToMinHeap(int *&maxHeap, int size) +{ + for (int i = (size - 1) / 2; i >= 0; --i) + reheapDownMinHeap(maxHeap, i, size); +} + +int main() +{ + int arr[8] = {473, 309, 286, 598, 438, 663, 948, 424}; + BinarySearchTree *bst = new BinarySearchTree; + for (int i = 0; i < 8; ++i) { + TreeNode *temp = new TreeNode(arr[i]); + bst->insert(temp); + } + bst->print(); + int size = 0; + int *maxHeap = buildHeapFromBST(bst, size); + printHeap(maxHeap, size); + maxHeapToMinHeap(maxHeap, size); + printHeap(maxHeap, size); + return 0; +} diff --git a/Lab7/binarysearchtree.cpp b/Lab7/binarysearchtree.cpp new file mode 100644 index 0000000..74cfaea --- /dev/null +++ b/Lab7/binarysearchtree.cpp @@ -0,0 +1,80 @@ +#include "binarysearchtree.h" + +void BinarySearchTree::insert(TreeNode *node) +{ + if (this->root == nullptr) { + this->root = node; + return; + } + TreeNode *temp = this->root; + while (true) { + if (temp->getData() > node->getData()) { + if (temp->getLeft() == nullptr) { + temp->setLeft(node); + return; + } + temp = temp->getLeft(); + } else if (temp->getData() < node->getData()) { + if (temp->getRight() == nullptr) { + temp->setRight(node); + return; + } + temp = temp->getRight(); + } else { + return; + } + } +} + +void BinarySearchTree::remove(int removeData) +{ + if (this->root == nullptr) + return; + TreeNode *preTemp = nullptr; + TreeNode *temp = this->root; + while (temp != nullptr) { + if (temp->getData() > removeData) { + preTemp = temp; + temp = temp->getLeft(); + } else if (temp->getData() < removeData) { + preTemp = temp; + temp = temp->getRight(); + } else { + break; + } + } + if (temp != nullptr) { + if (temp->getLeft() != nullptr) { + TreeNode *preMaxL = nullptr; + TreeNode *maxL = temp->getLeft(); + while (maxL->getRight() != nullptr) { + preMaxL = maxL; + maxL = maxL->getRight(); + } + temp->setData(maxL->getData()); + if (preMaxL != nullptr) + preMaxL->setRight(maxL->getLeft()); + else + temp->setLeft(maxL->getLeft()); + delete maxL; + } else { + if (preTemp != nullptr) { + if (preTemp->getLeft() == temp) + preTemp->setLeft(temp->getRight()); + else + preTemp->setRight(temp->getRight()); + } else { + this->root = temp->getRight(); + } + delete temp; + } + } +} + +void BinarySearchTree::print() +{ + if (this->root == nullptr) + return; + this->root->print(); + cout << endl; +} diff --git a/Lab7/binarysearchtree.h b/Lab7/binarysearchtree.h new file mode 100644 index 0000000..8fe041b --- /dev/null +++ b/Lab7/binarysearchtree.h @@ -0,0 +1,15 @@ +#ifndef BINARYSEARCHTREE_H +#define BINARYSEARCHTREE_H + +#include "treenode.h" + +class BinarySearchTree +{ +public: + TreeNode *root = nullptr; + void insert(TreeNode *node); + void remove(int removeData); + void print(); +}; + +#endif // BINARYSEARCHTREE_H diff --git a/Lab7/treenode.cpp b/Lab7/treenode.cpp new file mode 100644 index 0000000..c2cc427 --- /dev/null +++ b/Lab7/treenode.cpp @@ -0,0 +1,55 @@ +#include "treenode.h" + +TreeNode::TreeNode(int data) +{ + this->data = data; +} + +TreeNode::~TreeNode() +{ + this->data = 0; + this->left = nullptr; + this->right = nullptr; +} + + +int TreeNode::getData() +{ + return this->data; +} + +void TreeNode::setData(int newData) +{ + this->data = newData; +} + +TreeNode *TreeNode::getLeft() +{ + return this->left; +} + +void TreeNode::setLeft(TreeNode *newLeft) +{ + this->left = newLeft; +} + +TreeNode *TreeNode::getRight() +{ + return this->right; +} + +void TreeNode::setRight(TreeNode *newRight) +{ + this->right = newRight; +} + +void TreeNode::print() +{ + cout << "("; + if (this->left != nullptr) + this->left->print(); + cout << this->data; + if (this->right != nullptr) + this->right->print(); + cout << ")"; +} diff --git a/Lab7/treenode.h b/Lab7/treenode.h new file mode 100644 index 0000000..a55ac98 --- /dev/null +++ b/Lab7/treenode.h @@ -0,0 +1,26 @@ +#ifndef TREENODE_H +#define TREENODE_H + +#include + +using namespace std; + +class TreeNode +{ +private: + int data; + TreeNode *left = nullptr; + TreeNode *right = nullptr; +public: + TreeNode(int data); + ~TreeNode(); + int getData(); + void setData(int newdata); + TreeNode *getLeft(); + void setLeft(TreeNode *newLeft); + TreeNode *getRight(); + void setRight(TreeNode *newRight); + void print(); +}; + +#endif // TREENODE_H