From 52ddab8063fb65a39ab350dff54f0db7154e9952 Mon Sep 17 00:00:00 2001
From: Farid Alijani <farid.alijani@student.lut.fi>
Date: Wed, 1 Jun 2016 22:25:55 +0200
Subject: [PATCH] bst added
---
Files_4_thesis/BST | Bin 0 -> 14150 bytes
Files_4_thesis/bst.cpp | 294 +++++++++++++++++++++++++++++++
Files_4_thesis/bst.cpp~ | 292 ++++++++++++++++++++++++++++++
MobileRobot/ObjectTrack/bst | Bin 9222 -> 13512 bytes
MobileRobot/ObjectTrack/bst.cpp | 148 +++++++++++++---
MobileRobot/ObjectTrack/bst.cpp~ | 152 ++++++++++++----
6 files changed, 825 insertions(+), 61 deletions(-)
create mode 100755 Files_4_thesis/BST
create mode 100644 Files_4_thesis/bst.cpp
create mode 100644 Files_4_thesis/bst.cpp~
diff --git a/Files_4_thesis/BST b/Files_4_thesis/BST
new file mode 100755
index 0000000000000000000000000000000000000000..b1a488a93818a9ff352afdaf38fa98d875ec5ecc
GIT binary patch
literal 14150
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
Ds+QZ9
literal 0
HcmV?d00001
diff --git a/Files_4_thesis/bst.cpp b/Files_4_thesis/bst.cpp
new file mode 100644
index 00000000..b81a9564
--- /dev/null
+++ b/Files_4_thesis/bst.cpp
@@ -0,0 +1,294 @@
+//Binary Search Tree Program
+
+#include <iostream>
+#include <cstdlib>
+using namespace std;
+
+class BinarySearchTree
+{
+ private:
+ struct tree_node
+ {
+ tree_node* left;
+ tree_node* right;
+ int data;
+ };
+ tree_node* root;
+
+ public:
+ BinarySearchTree()
+ {
+ root = NULL;
+ }
+
+ bool isEmpty() const { return root==NULL; }
+ void print_inorder();
+ void inorder(tree_node*);
+ void print_preorder();
+ void preorder(tree_node*);
+ void print_postorder();
+ void postorder(tree_node*);
+ void insert(int);
+ void remove(int);
+};
+
+// Smaller elements go left
+// larger elements go right
+void BinarySearchTree::insert(int d)
+{
+ tree_node* t = new tree_node;
+ tree_node* parent;
+ t->data = d;
+ t->left = NULL;
+ t->right = NULL;
+ parent = NULL;
+
+ // is this a new tree?
+ if(isEmpty()) root = t;
+ else
+ {
+ //Note: ALL insertions are as leaf nodes
+ tree_node* curr;
+ curr = root;
+ // Find the Node's parent
+ while(curr)
+ {
+ parent = curr;
+ if(t->data > curr->data) curr = curr->right;
+ else curr = curr->left;
+ }
+
+ if(t->data < parent->data)
+ parent->left = t;
+ else
+ parent->right = t;
+ }
+}
+
+void BinarySearchTree::remove(int d)
+{
+ //Locate the element
+ bool found = false;
+ if(isEmpty())
+ {
+ cout<<" This Tree is empty! "<<endl;
+ return;
+ }
+
+ tree_node* curr;
+ tree_node* parent;
+ curr = root;
+
+ while(curr != NULL)
+ {
+ if(curr->data == d)
+ {
+ found = true;
+ break;
+ }
+ else
+ {
+ parent = curr;
+ if(d>curr->data) curr = curr->right;
+ else curr = curr->left;
+ }
+ }
+ if(!found)
+ {
+ cout<<" Data not found! "<<endl;
+ return;
+ }
+
+
+ // 3 cases :
+ // 1. We're removing a leaf node
+ // 2. We're removing a node with a single child
+ // 3. we're removing a node with 2 children
+
+ // Node with single child
+ if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL && curr->right == NULL))
+ {
+ if(curr->left == NULL && curr->right != NULL)
+ {
+ if(parent->left == curr)
+ {
+ parent->left = curr->right;
+ delete curr;
+ }
+ else
+ {
+ parent->right = curr->right;
+ delete curr;
+ }
+ }
+ else // left child present, no right child
+ {
+ if(parent->left == curr)
+ {
+ parent->left = curr->left;
+ delete curr;
+ }
+ else
+ {
+ parent->right = curr->left;
+ delete curr;
+ }
+ }
+ return;
+ }
+
+ //We're looking at a leaf node
+ if( curr->left == NULL && curr->right == NULL)
+ {
+ if(parent->left == curr) parent->left = NULL;
+ else parent->right = NULL;
+ delete curr;
+ return;
+ }
+
+
+ //Node with 2 children
+ // replace node with smallest value in right subtree
+ if (curr->left != NULL && curr->right != NULL)
+ {
+ tree_node* chkr;
+ chkr = curr->right;
+ if((chkr->left == NULL) && (chkr->right == NULL))
+ {
+ curr = chkr;
+ delete chkr;
+ curr->right = NULL;
+ }
+ else // right child has children
+ {
+ //if the node's right child has a left child
+ // Move all the way down left to locate smallest element
+
+ if((curr->right)->left != NULL)
+ {
+ tree_node* lcurr;
+ tree_node* lcurrp;
+ lcurrp = curr->right;
+ lcurr = (curr->right)->left;
+ while(lcurr->left != NULL)
+ {
+ lcurrp = lcurr;
+ lcurr = lcurr->left;
+ }
+ curr->data = lcurr->data;
+ delete lcurr;
+ lcurrp->left = NULL;
+ }
+ else
+ {
+ tree_node* tmp;
+ tmp = curr->right;
+ curr->data = tmp->data;
+ curr->right = tmp->right;
+ delete tmp;
+ }
+
+ }
+ return;
+ }
+
+}
+
+void BinarySearchTree::print_inorder()
+{
+ inorder(root);
+}
+
+void BinarySearchTree::inorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ if(p->left) inorder(p->left);
+ cout<<" "<<p->data<<" ";
+ if(p->right) inorder(p->right);
+ }
+ else return;
+}
+
+void BinarySearchTree::print_preorder()
+{
+ preorder(root);
+}
+
+void BinarySearchTree::preorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ cout<<" "<<p->data<<" ";
+ if(p->left) preorder(p->left);
+ if(p->right) preorder(p->right);
+ }
+ else return;
+}
+
+void BinarySearchTree::print_postorder()
+{
+ postorder(root);
+}
+
+void BinarySearchTree::postorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ if(p->left) postorder(p->left);
+ if(p->right) postorder(p->right);
+ cout<<" "<<p->data<<" ";
+ }
+ else return;
+}
+
+int main()
+{
+ BinarySearchTree b;
+ int ch,tmp,tmp1;
+ while(1)
+ {
+ cout<<endl<<endl;
+ cout<<" Binary Search Tree Operations "<<endl;
+ cout<<" ----------------------------- "<<endl;
+ cout<<" 1. Insertion/Creation "<<endl;
+ cout<<" 2. In-Order Traversal "<<endl;
+ cout<<" 3. Pre-Order Traversal "<<endl;
+ cout<<" 4. Post-Order Traversal "<<endl;
+ cout<<" 5. Removal "<<endl;
+ cout<<" 6. Exit "<<endl;
+ cout<<" Enter your choice : ";
+
+ cin>>ch;
+
+ switch(ch)
+ {
+ case 1 : cout<<" Enter Number to be inserted : ";
+ cin>>tmp;
+ b.insert(tmp);
+ break;
+ case 2 : cout<<endl;
+ cout<<" In-Order Traversal "<<endl;
+ cout<<" -------------------"<<endl;
+ b.print_inorder();
+ break;
+ case 3 : cout<<endl;
+ cout<<" Pre-Order Traversal "<<endl;
+ cout<<" -------------------"<<endl;
+ b.print_preorder();
+ break;
+ case 4 : cout<<endl;
+ cout<<" Post-Order Traversal "<<endl;
+ cout<<" --------------------"<<endl;
+ b.print_postorder();
+ break;
+ case 5 : cout<<" Enter data to be deleted : ";
+ cin>>tmp1;
+ b.remove(tmp1);
+ break;
+ case 6 :
+ return 0;
+
+ }
+ }
+}
diff --git a/Files_4_thesis/bst.cpp~ b/Files_4_thesis/bst.cpp~
new file mode 100644
index 00000000..75d5deb8
--- /dev/null
+++ b/Files_4_thesis/bst.cpp~
@@ -0,0 +1,292 @@
+//Binary Search Tree Program
+
+#include <iostream>
+#include <cstdlib>
+using namespace std;
+
+class BinarySearchTree
+{
+ private:
+ struct tree_node
+ {
+ tree_node* left;
+ tree_node* right;
+ int data;
+ };
+ tree_node* root;
+
+ public:
+ BinarySearchTree()
+ {
+ root = NULL;
+ }
+
+ bool isEmpty() const { return root==NULL; }
+ void print_inorder();
+ void inorder(tree_node*);
+ void print_preorder();
+ void preorder(tree_node*);
+ void print_postorder();
+ void postorder(tree_node*);
+ void insert(int);
+ void remove(int);
+};
+
+// Smaller elements go left
+// larger elements go right
+void BinarySearchTree::insert(int d)
+{
+ tree_node* t = new tree_node;
+ tree_node* parent;
+ t->data = d;
+ t->left = NULL;
+ t->right = NULL;
+ parent = NULL;
+
+ // is this a new tree?
+ if(isEmpty()) root = t;
+ else
+ {
+ //Note: ALL insertions are as leaf nodes
+ tree_node* curr;
+ curr = root;
+ // Find the Node's parent
+ while(curr)
+ {
+ parent = curr;
+ if(t->data > curr->data) curr = curr->right;
+ else curr = curr->left;
+ }
+
+ if(t->data < parent->data)
+ parent->left = t;
+ else
+ parent->right = t;
+ }
+}
+
+void BinarySearchTree::remove(int d)
+{
+ //Locate the element
+ bool found = false;
+ if(isEmpty())
+ {
+ cout<<" This Tree is empty! "<<endl;
+ return;
+ }
+
+ tree_node* curr;
+ tree_node* parent;
+ curr = root;
+
+ while(curr != NULL)
+ {
+ if(curr->data == d)
+ {
+ found = true;
+ break;
+ }
+ else
+ {
+ parent = curr;
+ if(d>curr->data) curr = curr->right;
+ else curr = curr->left;
+ }
+ }
+ if(!found)
+ {
+ cout<<" Data not found! "<<endl;
+ return;
+ }
+
+
+ // 3 cases :
+ // 1. We're removing a leaf node
+ // 2. We're removing a node with a single child
+ // 3. we're removing a node with 2 children
+
+ // Node with single child
+ if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL && curr->right == NULL))
+ {
+ if(curr->left == NULL && curr->right != NULL)
+ {
+ if(parent->left == curr)
+ {
+ parent->left = curr->right;
+ delete curr;
+ }
+ else
+ {
+ parent->right = curr->right;
+ delete curr;
+ }
+ }
+ else // left child present, no right child
+ {
+ if(parent->left == curr)
+ {
+ parent->left = curr->left;
+ delete curr;
+ }
+ else
+ {
+ parent->right = curr->left;
+ delete curr;
+ }
+ }
+ return;
+ }
+
+ //We're looking at a leaf node
+ if( curr->left == NULL && curr->right == NULL)
+ {
+ if(parent->left == curr) parent->left = NULL;
+ else parent->right = NULL;
+ delete curr;
+ return;
+ }
+
+
+ //Node with 2 children
+ // replace node with smallest value in right subtree
+ if (curr->left != NULL && curr->right != NULL)
+ {
+ tree_node* chkr;
+ chkr = curr->right;
+ if((chkr->left == NULL) && (chkr->right == NULL))
+ {
+ curr = chkr;
+ delete chkr;
+ curr->right = NULL;
+ }
+ else // right child has children
+ {
+ //if the node's right child has a left child
+ // Move all the way down left to locate smallest element
+
+ if((curr->right)->left != NULL)
+ {
+ tree_node* lcurr;
+ tree_node* lcurrp;
+ lcurrp = curr->right;
+ lcurr = (curr->right)->left;
+ while(lcurr->left != NULL)
+ {
+ lcurrp = lcurr;
+ lcurr = lcurr->left;
+ }
+ curr->data = lcurr->data;
+ delete lcurr;
+ lcurrp->left = NULL;
+ }
+ else
+ {
+ tree_node* tmp;
+ tmp = curr->right;
+ curr->data = tmp->data;
+ curr->right = tmp->right;
+ delete tmp;
+ }
+
+ }
+ return;
+ }
+
+}
+
+void BinarySearchTree::print_inorder()
+{
+ inorder(root);
+}
+
+void BinarySearchTree::inorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ if(p->left) inorder(p->left);
+ cout<<" "<<p->data<<" ";
+ if(p->right) inorder(p->right);
+ }
+ else return;
+}
+
+void BinarySearchTree::print_preorder()
+{
+ preorder(root);
+}
+
+void BinarySearchTree::preorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ cout<<" "<<p->data<<" ";
+ if(p->left) preorder(p->left);
+ if(p->right) preorder(p->right);
+ }
+ else return;
+}
+
+void BinarySearchTree::print_postorder()
+{
+ postorder(root);
+}
+
+void BinarySearchTree::postorder(tree_node* p)
+{
+ if(p != NULL)
+ {
+ if(p->left) postorder(p->left);
+ if(p->right) postorder(p->right);
+ cout<<" "<<p->data<<" ";
+ }
+ else return;
+}
+
+int main()
+{
+ BinarySearchTree b;
+ int ch,tmp,tmp1;
+ while(1)
+ {
+ cout<<endl<<endl;
+ cout<<" Binary Search Tree Operations "<<endl;
+ cout<<" ----------------------------- "<<endl;
+ cout<<" 1. Insertion/Creation "<<endl;
+ cout<<" 2. In-Order Traversal "<<endl;
+ cout<<" 3. Pre-Order Traversal "<<endl;
+ cout<<" 4. Post-Order Traversal "<<endl;
+ cout<<" 5. Removal "<<endl;
+ cout<<" 6. Exit "<<endl;
+ cout<<" Enter your choice : ";
+ cin>>ch;
+ switch(ch)
+ {
+ case 1 : cout<<" Enter Number to be inserted : ";
+ cin>>tmp;
+ b.insert(tmp);
+ break;
+ case 2 : cout<<endl;
+ cout<<" In-Order Traversal "<<endl;
+ cout<<" -------------------"<<endl;
+ b.print_inorder();
+ break;
+ case 3 : cout<<endl;
+ cout<<" Pre-Order Traversal "<<endl;
+ cout<<" -------------------"<<endl;
+ b.print_preorder();
+ break;
+ case 4 : cout<<endl;
+ cout<<" Post-Order Traversal "<<endl;
+ cout<<" --------------------"<<endl;
+ b.print_postorder();
+ break;
+ case 5 : cout<<" Enter data to be deleted : ";
+ cin>>tmp1;
+ b.remove(tmp1);
+ break;
+ case 6 :
+ return 0;
+
+ }
+ }
+}
diff --git a/MobileRobot/ObjectTrack/bst b/MobileRobot/ObjectTrack/bst
index fbf7dfb48e654c0c3afd4cf0c70a0f624954e816..12384a64476fce3865672035f372e84a1085a6ad 100755
GIT binary patch
literal 13512
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
W735aP_5n24U`dhS)&1b~#{dAm&jc+1
delta 4006
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
diff --git a/MobileRobot/ObjectTrack/bst.cpp b/MobileRobot/ObjectTrack/bst.cpp
index 841476f1..76906a45 100644
--- a/MobileRobot/ObjectTrack/bst.cpp
+++ b/MobileRobot/ObjectTrack/bst.cpp
@@ -1,5 +1,5 @@
#include <iostream>
-
+#include <stdio.h>
using namespace std;
struct BstNode {
@@ -9,52 +9,128 @@ struct BstNode {
BstNode* right;
};
-BstNode* GetNewNode(int data){
- BstNode* newNode = new BstNode();
- newNode->data = data;
- newNode->left = newNode->right = NULL;
- return newNode;
+BstNode* Insert(BstNode* node, int inserting_value) {
+ if (node == NULL) { // No node => make a new one!
+ node = new BstNode();
+ node->data = inserting_value;
+ node->left = node->right = NULL;
+
+ }
+ else if (inserting_value <= node->data) {
+ node->left = Insert(node->left,inserting_value);
+ }
+ else {
+ node->right = Insert(node->right,inserting_value);
+ }
+
+ return node;
}
-BstNode* Insert(BstNode* root, int data) {
- if (root == NULL) {
- root = GetNewNode(data);
- } else if (data <= root->data) {
- root->left = Insert(root->left,data);
+
+bool Search(BstNode* node, int target) {
+ if (node == NULL){
+ return false;
+ } else if (target == node->data) { // bingoo, we've got this!
+ return true;
+ } else if (target < node->data) {
+ return Search(node->left,target);
} else {
- root->right = Insert(root->right,data);
+ return Search(node->right,target);
}
+
+
}
+BstNode* FindMin(BstNode* root) {
+ while(root->left != NULL){
+ root = root->left;
+ }
+ return root;
+}
-bool Search(BstNode* root, int data) {
+struct BstNode* Delete(struct BstNode* root, int data) {
if (root == NULL){
- return false;
- } else if (root->data == data) {
- return true;
- } else if (data <= root->data) {
- return Search(root->left,data);
- } else {
- return Search(root->right,data);
+ return root;
+ } else if (data < root->data)
+ {
+ root->left = Delete(root->left,data);
+ } else if (data > root->data)
+ {
+ root->right = Delete(root->right,data);
+ } else // found the data to be deleted!
+ {
+ // case 1: No child
+ if (root->left == NULL && root->right == NULL)
+ {
+ delete root;
+ root = NULL;
+ }
+ // case 2: One child
+ else if (root->left == NULL)
+ {
+ struct BstNode *temp = root;
+ root = root->right;
+ delete temp;
+ }
+ else if (root->right == NULL)
+ {
+ struct BstNode *temp = root;
+ root = root->left;
+ delete temp;
+ }
+ // case 3: Two children
+
+ else
+ {
+ struct BstNode *temp = FindMin(root->right);
+ root->data = temp->data;
+ root->right = Delete(root->right,temp->data);
+ }
}
+
+ return root;
+}
+// printing the tree
+void Inorder(BstNode *root) {
+ if (root == NULL){
+ return;
+ }
+
+ Inorder(root->left);
+ printf("%d",root->data);
+ Inorder(root->right);
}
+int size(BstNode* node) {
+
+ if (node = NULL) {
+ return 0;
+ } else {
+ return (size(node->left) + 1 /* 1 root */ + size(node->right));
+ }
+
+}
+
int main() {
+
BstNode* root; // pointer to root node
root = NULL; // tree is empty!
- Insert(root,15);
- Insert(root,10);
- Insert(root,20);
- Insert(root,25);
- Insert(root,8);
- Insert(root,12);
- Insert(root,17);
+ root = Insert(root,15);
+ root = Insert(root,10);
+ root = Insert(root,20);
+ root = Insert(root,25);
+ root = Insert(root,8);
+ root = Insert(root,12);
+ root = Insert(root,17);
+
- int number;
+
+
+ /*int number;
cout << "Please enter a number : \n";
cin >> number;
@@ -62,7 +138,21 @@ int main() {
cout << "Found! \n";
} else {
cout << "Not Found! \n";
- }
+ }*/
+
+ /*root = Delete(root,15);
+
+
+ cout << "Inorder: ";
+ Inorder(root);
+ cout<<"\n";
+ */
+
+ int num;
+ num = size(root);
+ size(root);
+ cout << "size : " << num << "\n";
+ return 0;
}
diff --git a/MobileRobot/ObjectTrack/bst.cpp~ b/MobileRobot/ObjectTrack/bst.cpp~
index 020bcf0e..9e540f55 100644
--- a/MobileRobot/ObjectTrack/bst.cpp~
+++ b/MobileRobot/ObjectTrack/bst.cpp~
@@ -1,5 +1,5 @@
#include <iostream>
-
+#include <stdio.h>
using namespace std;
struct BstNode {
@@ -9,60 +9,148 @@ struct BstNode {
BstNode* right;
};
-BstNode* GetNewNode(int data){
- BstNode* newNode = new BstNode();
- newNode->data = data;
- newNode->left = newNode->right = NULL;
- return newNode;
+BstNode* Insert(BstNode* node, int inserting_value) {
+ if (node == NULL) { // No node => make a new one!
+ node = new BstNode();
+ node->data = inserting_value;
+ node->left = node->right = NULL;
+
+ }
+ else if (inserting_value <= node->data) {
+ node->left = Insert(node->left,inserting_value);
+ }
+ else {
+ node->right = Insert(node->right,inserting_value);
+ }
+
+ return node;
}
-BstNode* Insert(BstNode* root, int data) {
- if (root == NULL) {
- root = GetNewNode(data);
- } else if (data <= root->data) {
- root->left = Insert(root->left,data);
+
+bool Search(BstNode* node, int target) {
+ if (node == NULL){
+ return false;
+ } else if (target == node->data) { // bingoo, we've got this!
+ return true;
+ } else if (target < node->data) {
+ return Search(node->left,target);
} else {
- root->right = Insert(root->right,data);
+ return Search(node->right,target);
}
+
+
}
+BstNode* FindMin(BstNode* root) {
+ while(root->left != NULL){
+ root = root->left;
+ }
+ return root;
+}
-bool Search(BstNode* root, int data) {
+struct BstNode* Delete(struct BstNode* root, int data) {
if (root == NULL){
- return false;
- } else if (root->data == data) {
- return true;
- } else if (data <= root->data) {
- return Search(root->left,data);
- } else {
- return Search(root->right,data);
+ return root;
+ } else if (data < root->data)
+ {
+ root->left = Delete(root->left,data);
+ } else if (data > root->data)
+ {
+ root->right = Delete(root->right,data);
+ } else // found the data to be deleted!
+ {
+ // case 1: No child
+ if (root->left == NULL && root->right == NULL)
+ {
+ delete root;
+ root = NULL;
+ }
+ // case 2: One child
+ else if (root->left == NULL)
+ {
+ struct BstNode *temp = root;
+ root = root->right;
+ delete temp;
+ }
+ else if (root->right == NULL)
+ {
+ struct BstNode *temp = root;
+ root = root->left;
+ delete temp;
+ }
+ // case 3: Two children
+
+ else
+ {
+ struct BstNode *temp = FindMin(root->right);
+ root->data = temp->data;
+ root->right = Delete(root->right,temp->data);
+ }
}
+
+ return root;
+}
-
+void Inorder(BstNode *root) {
+ if (root == NULL){
+ return;
+ }
+
+ Inorder(root->left);
+ printf("%d",root->data);
+ Inorder(root->right);
}
+int size(BstNode* node) {
+
+ if (node = NULL) {
+ return 0;
+ } else {
+ return (size(node->left) + 1 /* 1 root */ + size(node->right));
+ }
+
+}
+
int main() {
+
BstNode* root; // pointer to root node
root = NULL; // tree is empty!
- Insert(root,15);
- Insert(root,10);
- Insert(root,20);
- Insert(root,25);
- Insert(root,8);
- Insert(root,12);
- Insert(root,17);
+ root = Insert(root,15);
+ root = Insert(root,10);
+ root = Insert(root,20);
+ root = Insert(root,25);
+ root = Insert(root,8);
+ root = Insert(root,12);
+ root = Insert(root,17);
+
- int number;
+
+
+ /*int number;
cout << "Please enter a number : \n";
cin >> number;
if (Search(root,number) == true) {
- cout << "Found!";
+ cout << "Found! \n";
} else {
- cout << "Not Found!";
- }
+ cout << "Not Found! \n";
+ }*/
+
+ /*root = Delete(root,15);
+
+
+ cout << "Inorder: ";
+ Inorder(root);
+ cout<<"\n";
+ */
+
+ int num;
+ num = size(root);
+ size(root);
+ cout << "size : " << num << "\n";
+ return 0;
}
--
GitLab