add implementations for checking max heap and converting BST to min/max heap

Author: Adityasinghvats

26Heap/11maxheap_from_bst.cpp

@@ -0,0 +1,68 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Node{
+    public:
+    int val;
+    Node* left;
+    Node* right;
+    Node(int val){
+        this->val = val;
+        this->left = nullptr;
+        this->right = nullptr;
+    }
+};
+
+void revInorder(Node *root, vector<int> &dec){//make a decreasing inorder array
+    if (root==nullptr) return;
+    revInorder(root->right, dec);
+    dec.push_back(root->val);
+    revInorder(root->left, dec);
+}
+
+void printTree(Node *root){
+    queue<Node*> q;
+    q.push(root);
+    while(q.size()>0){
+        Node* temp = q.front();
+        q.pop();
+        cout<<temp->val<<" ";
+        if(temp->left!=nullptr) q.push(temp->left);
+        if(temp->right!=nullptr) q.push(temp->right);
+    }
+    cout<<endl;
+}
+//modify the to have preorde using the reverse sorted array
+void preorder(Node *root, vector<int> &dec, int& i){
+    if (root==nullptr) return;
+    root->val = dec[i++];
+    preorder(root->left, dec, i);
+    preorder(root->right, dec, i);
+}
+
+int main(){
+    Node* a = new Node(10);
+    Node* b = new Node(5);
+    Node* c = new Node(16);
+    Node* d = new Node(1);
+    Node* e = new Node(8);
+    Node* f = new Node(12);
+    Node* g = new Node(20);
+    a->left = b; a->right = c;
+    b->left = d; b->right = e;
+    c->left = f; c->right = g;
+    vector<int> dec;//reverse inorder
+    revInorder(a, dec);
+    cout<<"before converting to maxheap:"<<endl;
+    printTree(a);
+    int i = 0;
+    preorder(a, dec, i);
+    cout<<"after converting to maxheap:"<<endl;
+    printTree(a);
+    return 0;
+}
+/*
+before converting to maxheap:
+10 5 16 1 8 12 20 
+after converting to maxheap:
+20 16 8 12 10 5 1
+ */

26Heap/11maxheap_from_bst.exe

@@ -0,0 +1,68 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Node{
+    public:
+    int val;
+    Node* left;
+    Node* right;
+    Node(int val){
+        this->val = val;
+        this->left = nullptr;
+        this->right = nullptr;
+    }
+};
+
+void Inorder(Node *root, vector<int> &dec){//make a decreasing inorder array
+    if (root==nullptr) return;
+    Inorder(root->left, dec);
+    dec.push_back(root->val);
+    Inorder(root->right, dec);
+}
+
+void printTree(Node *root){
+    queue<Node*> q;
+    q.push(root);
+    while(q.size()>0){
+        Node* temp = q.front();
+        q.pop();
+        cout<<temp->val<<" ";
+        if(temp->left!=nullptr) q.push(temp->left);
+        if(temp->right!=nullptr) q.push(temp->right);
+    }
+    cout<<endl;
+}
+//modify the to have preorder using the sorted array
+void preorder(Node *root, vector<int> &dec, int& i){
+    if (root==nullptr) return;
+    root->val = dec[i++];
+    preorder(root->left, dec, i);
+    preorder(root->right, dec, i);
+}
+
+int main(){
+    Node* a = new Node(10);
+    Node* b = new Node(5);
+    Node* c = new Node(16);
+    Node* d = new Node(1);
+    Node* e = new Node(8);
+    Node* f = new Node(12);
+    Node* g = new Node(20);
+    a->left = b; a->right = c;
+    b->left = d; b->right = e;
+    c->left = f; c->right = g;
+    vector<int> dec;//reverse inorder
+    Inorder(a, dec);
+    cout<<"before converting to minheap:"<<endl;
+    printTree(a);
+    int i = 0;
+    preorder(a, dec, i);
+    cout<<"after converting to minheap:"<<endl;
+    printTree(a);
+    return 0;
+}
+/*
+before converting to minheap:
+10 5 16 1 8 12 20 
+after converting to minheap:
+1 5 12 8 10 16 20
+*/

26Heap/12minheap_from_bst.cpp

@@ -0,0 +1,48 @@
+#include<bits/stdc++.h>
+using namespace std;
+/*
+Check whether the binary tree is a maxheap or not
+*/
+class Node{
+    public:
+    int val;
+    Node* left;
+    Node* right;
+    Node(int val){
+        this->val = val;
+        this->left = nullptr;
+        this->right = nullptr;
+    }
+};
+bool ismax(Node *root){
+    if(root==nullptr) return true;
+    if(root->left && root->val<root->left->val) return false;
+    if(root->right && root->val<root->right->val) return false;
+    return ismax(root->left) && ismax(root->right);
+}
+bool iscbt(Node* root){
+    if(root==nullptr) return true;
+    //if either child is null
+    if(root->left==nullptr and root->right) return false;
+    if(root->left and root->right==nullptr) return false;
+    return iscbt(root->left) && iscbt(root->right);
+}
+
+int main(){
+    Node* a = new Node(20);
+    Node* b = new Node(15);
+    Node* c = new Node(10);
+    Node* d = new Node(8);
+    Node* e = new Node(11);
+    // Node* f = nullptr; //with this it is not maxheap
+    Node* f = new Node(4); //with this it is a maxheap
+    Node* g = new Node(6);
+    a->left = b; a->right = c;
+    b->left = d; b->right = e;
+    c->left = f; c->right = g;
+    // cout<<iscbt(a);
+    // cout<<ismax(a);
+    if(ismax(a) && iscbt(a)) cout<<"Binary tree is a maxheap"<<endl;
+    else cout<<"Binary tree is not a maxheap"<<endl;
+    return 0;
+}