GeeksForGeeks - POTD | GFG POTD Answer

class Solution {
  public:
    void solve(Node* root,int &mini,int &maxi,int i){
        if(root==NULL)
        return;
        mini=min(mini,i);
        maxi=max(maxi,i);
        solve(root->left,mini,maxi,i-1);
        solve(root->right,mini,maxi,i+1);
    }
    int verticalWidth(Node* root) {
        int mini=INT_MAX;
        int maxi=INT_MIN;
        solve(root,mini,maxi,0);
        return abs(mini)+abs(maxi)+1;
    }
};

class Solution {
  private:
    unordered_map<string,int> mp;
    vector<Node*> res;
    string DFS(Node*root){
        if(!root) return "N";
        
        string str = DFS(root->left)+""+DFS(root->right)+to_string(root->data);
        mp[str]++;
        if(mp[str] == 2) res.push_back(root);
        
        return str;
    }
  public:
    vector<Node*> printAllDups(Node* root) {
        DFS(root);
        return res;
    }
};

class Solution {
  public:
    Node* removeAllDuplicates(struct Node* head) {
        Node * temp = head;
        temp = new Node(-1);
        Node * newHead = temp;
        temp->next = head;
        while(temp->next){
            Node* pointer = temp->next->next;
            bool f=false;
            while(pointer && temp->next->data == pointer->data){
                pointer=pointer->next;
                f=true;
            }
            if(f){
                temp->next = pointer;
            }else{
                temp = temp->next;
            }
        }
        return newHead->next;
    }
};

class Solution {
  public:
    bool compute(Node* head) {
        
        string ans="";
        Node *temp=head;
        
        while(temp!=NULL){
            ans+=temp->data;
            temp=temp->next;
        }
        
        string rev=ans;
        reverse(ans.begin(),ans.end());
        if(ans==rev)return true;
        return false;
    }
};

void constructTree(vector<int> &v, int ind, TreeNode* &node)
{
    node = new TreeNode(v[ind]);
    int leftInd = 2*ind + 1, rightInd = 2*ind + 2;
    if(leftInd < v.size())
    {
        constructTree(v, leftInd, node->left);
    }
    else
    {
        return;
    }
    if(rightInd < v.size())
    {
        constructTree(v, rightInd, node->right);
    }
}
// Function to make binary tree from linked list.
void convert(Node *head, TreeNode *&root) {
    
    vector<int> v;
    Node* temp = head;
    while(temp != NULL)
    {
        v.push_back(temp->data);
        temp = temp->next;
    }
    constructTree(v, 0, root);
}

Abdul Bari All Courses

class Solution {
  public:
    Node* deleteNode(Node* &head, int x) {
        Node * NewNode = head;
        if (x>1)    {
            for (int i=1;i<x-1;i++)   {
                NewNode=NewNode->next;
            }
        }
        else head = NewNode->next;
        NewNode->next=NewNode->next->next;
        
        return head;
    }
};

Abdul Bari All Courses

bool areIdentical(struct Node *head1, struct Node *head2) {
    if(head1 == NULL && head2 == NULL){
        return true;
    }
    if(head1 != NULL && head2 == NULL){
        return false;
    }
    if(head1 == NULL && head2 != NULL){
        return false;
    }
    
    bool left = areIdentical(head1->next, head2->next);
    
    bool val = head1->data == head2->data;
    
    if(left && val){
        return true;
    }
    else{
        return false;
    }
}