JamesFlare/CSCI-1200
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove some code

Browse Source
This commit is contained in:
Jidong Xiao
2024-04-02 11:41:40 -04:00
parent 5090c8cdf7
commit 04983fb964
3 changed files with 0 additions and 419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
labs/11_stacks_and_queues/levelOrder_sol1.cpp
View File

@@ -1,153 +0,0 @@
#include <iostream>
#include <vector>
#include <stack>
// Definition for a binary tree node.
class TreeNode {
public:
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
class MyQueue {
public:
MyQueue() {
}
void push(TreeNode* x) {
int size = myStack1.size();
// move everything in stack1 to stack2
for(int i=0;i<size;i++){
myStack2.push(myStack1.top());
myStack1.pop();
}
// push x into stack1
myStack1.push(x);
// move everything in stack2 to stack1
for(int i=0;i<size;i++){
myStack1.push(myStack2.top());
myStack2.pop();
}
}
void pop() {
myStack1.pop();
}
TreeNode* front() {
return myStack1.top();
}
bool empty() {
return myStack1.empty();
}
int size() {
return myStack1.size();
}
private:
std::stack<TreeNode*> myStack1;
std::stack<TreeNode*> myStack2;
};
std::vector<std::vector<int>> levelOrderTraversal(TreeNode* root) {
std::vector<std::vector<int>> result;
if (root == nullptr) {
return result;
}
MyQueue myQueue;
myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
std::vector<int> current_level;
for (int i = 0; i < size; i++) {
TreeNode* current = myQueue.front();
myQueue.pop();
std::cout << current->val << " ";
if (current != nullptr) {
current_level.push_back(current->val);
if (current->left != nullptr) {
myQueue.push(current->left);
}
if (current->right != nullptr) {
myQueue.push(current->right);
}
}
}
result.push_back(current_level);
}
return result;
}
int main() {
/* test case 1
* 1
* 2 3
* 4 5 6 7
*/
TreeNode* root1 = new TreeNode(1);
root1->left = new TreeNode(2);
root1->right = new TreeNode(3);
root1->left->left = new TreeNode(4);
root1->left->right = new TreeNode(5);
root1->right->left = new TreeNode(6);
root1->right->right = new TreeNode(7);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root1);
std::cout << std::endl;
/* test case 2
* 1
* 2 3
* 4 5 6 7
* 8 9
*/
TreeNode* root2 = new TreeNode(1);
root2->left = new TreeNode(2);
root2->right = new TreeNode(3);
root2->left->left = new TreeNode(4);
root2->left->right = new TreeNode(5);
root2->right->left = new TreeNode(6);
root2->right->right = new TreeNode(7);
root2->right->right->left = new TreeNode(8);
root2->right->right->right = new TreeNode(9);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root2);
std::cout << std::endl;
/* test case 3
* 1
* 2 3
* 4 5 6 7
* 8
*/
TreeNode* root3 = new TreeNode(1);
root3->left = new TreeNode(2);
root3->right = new TreeNode(3);
root3->left->left = new TreeNode(4);
root3->left->right = new TreeNode(5);
root3->right->left = new TreeNode(6);
root3->right->right = new TreeNode(7);
root3->left->left->left = new TreeNode(8);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root3);
std::cout << std::endl;
return 0;
}

140
labs/11_stacks_and_queues/levelOrder_sol2.cpp
View File

@@ -1,140 +0,0 @@
#include <iostream>
#include <vector>
#include <list>
// Definition for a binary tree node.
class TreeNode {
public:
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
class MyQueue {
public:
MyQueue() {
}
void push(TreeNode* node) {
myList.push_back(node);
}
void pop() {
myList.pop_front();
}
TreeNode* front() {
return myList.front();
}
bool empty() {
return myList.empty();
}
int size() {
return myList.size();
}
private:
std::list<TreeNode*> myList;
};
std::vector<std::vector<int>> levelOrderTraversal(TreeNode* root) {
std::vector<std::vector<int>> result;
if (root == nullptr) {
return result;
}
MyQueue myQueue;
myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
std::vector<int> current_level;
for (int i = 0; i < size; i++) {
TreeNode* current = myQueue.front();
myQueue.pop();
std::cout << current->val << " ";
if (current != nullptr) {
current_level.push_back(current->val);
if (current->left != nullptr) {
myQueue.push(current->left);
}
if (current->right != nullptr) {
myQueue.push(current->right);
}
}
}
result.push_back(current_level);
}
return result;
}
int main() {
/* test case 1
* 1
* 2 3
* 4 5 6 7
*/
TreeNode* root1 = new TreeNode(1);
root1->left = new TreeNode(2);
root1->right = new TreeNode(3);
root1->left->left = new TreeNode(4);
root1->left->right = new TreeNode(5);
root1->right->left = new TreeNode(6);
root1->right->right = new TreeNode(7);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root1);
std::cout << std::endl;
/* test case 2
* 1
* 2 3
* 4 5 6 7
* 8 9
*/
TreeNode* root2 = new TreeNode(1);
root2->left = new TreeNode(2);
root2->right = new TreeNode(3);
root2->left->left = new TreeNode(4);
root2->left->right = new TreeNode(5);
root2->right->left = new TreeNode(6);
root2->right->right = new TreeNode(7);
root2->right->right->left = new TreeNode(8);
root2->right->right->right = new TreeNode(9);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root2);
std::cout << std::endl;
/* test case 3
* 1
* 2 3
* 4 5 6 7
* 8
*/
TreeNode* root3 = new TreeNode(1);
root3->left = new TreeNode(2);
root3->right = new TreeNode(3);
root3->left->left = new TreeNode(4);
root3->left->right = new TreeNode(5);
root3->right->left = new TreeNode(6);
root3->right->right = new TreeNode(7);
root3->left->left->left = new TreeNode(8);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root3);
std::cout << std::endl;
return 0;
}

126
labs/11_stacks_and_queues/levelOrder_sol3.cpp
View File

@@ -1,126 +0,0 @@
#include <iostream>
#include <vector>
#include <queue>
// Definition for a binary tree node.
class TreeNode {
public:
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
std::vector<std::vector<int>> levelOrderTraversal(TreeNode* root) {
std::vector<std::vector<int>> result;
if (root == nullptr) {
return result;
}
std::queue<TreeNode*> myQueue;
myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
std::vector<int> current_level;
for (int i = 0; i < size; i++) {
TreeNode* current = myQueue.front();
myQueue.pop();
std::cout << current->val << " ";
if (current != nullptr) {
current_level.push_back(current->val);
if (current->left != nullptr) {
myQueue.push(current->left);
}
if (current->right != nullptr) {
myQueue.push(current->right);
}
}
}
result.push_back(current_level);
}
return result;
}
void deleteTree(TreeNode* root){
if(root==nullptr){
return;
}
if(root->left!=nullptr){
deleteTree(root->left);
}
if(root->right!=nullptr){
deleteTree(root->right);
}
delete root;
}
int main() {
/* test case 1
* 1
* 2 3
* 4 5 6 7
*/
TreeNode* root1 = new TreeNode(1);
root1->left = new TreeNode(2);
root1->right = new TreeNode(3);
root1->left->left = new TreeNode(4);
root1->left->right = new TreeNode(5);
root1->right->left = new TreeNode(6);
root1->right->right = new TreeNode(7);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root1);
std::cout << std::endl;
/* test case 2
* 1
* 2 3
* 4 5 6 7
* 8 9
*/
TreeNode* root2 = new TreeNode(1);
root2->left = new TreeNode(2);
root2->right = new TreeNode(3);
root2->left->left = new TreeNode(4);
root2->left->right = new TreeNode(5);
root2->right->left = new TreeNode(6);
root2->right->right = new TreeNode(7);
root2->right->right->left = new TreeNode(8);
root2->right->right->right = new TreeNode(9);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root2);
std::cout << std::endl;
/* test case 3
* 1
* 2 3
* 4 5 6 7
* 8
*/
TreeNode* root3 = new TreeNode(1);
root3->left = new TreeNode(2);
root3->right = new TreeNode(3);
root3->left->left = new TreeNode(4);
root3->left->right = new TreeNode(5);
root3->right->left = new TreeNode(6);
root3->right->right = new TreeNode(7);
root3->left->left->left = new TreeNode(8);
std::cout << "Level Order Traversal: ";
levelOrderTraversal(root3);
std::cout << std::endl;
deleteTree(root1);
deleteTree(root2);
deleteTree(root3);
return 0;
}