向量<pointer> ::insert(iterator,pointer) 插入垃圾值</pointer>

Question

I am writing a recursive function to print all the possible permutations of keys which will give the same Binary Search tree.

At every node I am storing the next possible nodes in a vector(ie, deleting that node and adding its children) and recursively calling the function. I am printing the keys once there are no more nodes to add.(I know I can use vector instead of stack but I am just learning vectors).

#include<bits/stdc++.h>
#define child c
using namespace std;

typedef
struct bstnode
{
    bstnode *lc;
    int x;
    int data;
    bstnode *rc;
}* BSTPTR;

//Prints the inorder of a BST
void printIn(BSTPTR T)
{
    if(T)
    {
        printIn(T->lc);
        cout<<T->data<<' ';
        printIn(T->rc);
    }
}

//adds an element to a BST
void add(BSTPTR &T,int k)
{
    if(T)
    {
        if(k < T->data)
            add(T->lc,k);
        else
            add(T->rc,k);
    }
    else
    {
        BSTPTR t = new bstnode;
        t->data = k;
        t->lc=t->rc=NULL;
        T = t;
    }
}

//prints all the permutations in question
void printPermute(vector<BSTPTR> &LIST,BSTPTR T,stack<int> p)
{
    if(LIST.size()==0)
    {
        stack<int> q;
        int n=p.size();

        while(!p.empty())
        {
            q.push(p.top());
            p.pop();
        }
        int flag=1;
        int i=0,A[]={18,12,15,5,9,36,72,45,30};
        while(!q.empty())
        {
            int x=q.top();
            if(A[i++]!=x)
            flag=0;
            cout<<x<<' ';
            q.pop();
            p.push(x);
        }
        if(flag)
        {
            int f=9;
            f++;
        }
        cout<<endl;
    }
    else
    {
        for(auto i=LIST.begin();i<LIST.end();++i)
        {
            BSTPTR t=*i;
            p.push(t->data);

            LIST.erase(i);

            if(t->lc)
            {
                LIST.push_back(t->lc);
                if(t->rc)
                {
                    LIST.push_back(t->rc);
                    printPermute(LIST,t,p);
                    LIST.pop_back();
                }
                else
                {
                    printPermute(LIST,t,p);
                }
                LIST.pop_back();
            }
            else
            {
                if(t->rc)
                {
                    LIST.push_back(t->rc);
                    printPermute(LIST,t,p);
                    LIST.pop_back();
                }
                else
                {
                    printPermute(LIST,t,p);
                }
            }
            p.pop();
            LIST.insert(i,t);
        }
    }
}

//this is a helping function to asitis(BSTPTR) assigns the value of x for each node
void assignX(BSTPTR T,int &x)
{
    if(T)
    {
        if(T->lc == NULL)
        {
            T->x = x++;
            assignX(T->rc, x);
        }
        else
        {
            assignX(T->lc, x);
            T->x = x++;
            assignX(T->rc, x);
        }
    }
}

//prints the tree as it would look on paper. This is to give an intuitive idea of the tree's structure

void asItIs(BSTPTR T)
{
    int prev;
    assignX(T,prev=1);
    prev=0;
    queue<BSTPTR> q;
    q.push(T);
    q.push(NULL);
    while(q.size()>1)
    {
        BSTPTR t = q.front();
        q.pop();

        if(t)
        {
            for(int i=0;i<t->x-1-prev;++i)
                cout<<' ';

            cout<<t->data;
            prev = t->x;

            if(t->lc)
                q.push(t->lc);
            if(t->rc)
                q.push(t->rc);
        }
        else
        {
            cout<<endl;
            prev = 0;
            q.push(t);
        }
    }
    cout<<endl;
}


int main()
{
    BSTPTR T = NULL;
    cout<<"Enter the numbers in the tree:\n";
    int i=0,A[] = {18,12,36,5,15,30,72,9,45,-5};

    while(A[i]>=0)
    {
        add(T,A[i++]);
    }

    printIn(T);
    cout<<endl;

    asItIs(T);
    vector<BSTPTR> LIST;
    stack<int> p;
    LIST.push_back(T);
    // cout<<LIST.size();
    printPermute(LIST,T,p);
}

So my code is printing all the possible permutations starting with 18 12 but when it has to insert the node containing 12 at the end of the loop in second recursion:

//main::printPermute(only 1 iteration of for loop is there)::printPermute(at the end of 1st iteration out of 2 iterations
LIST.insert(i,t);

instead of inserting the address of that node containg the key 12 which is stored in t,it is inserting (I hope it is) a garbage value "ox31". Now this obviously messes up the furthur execution.

Why is it inserting such a value? This is more intriguing because this problem did not occur in higher levels of recursion(There are in total some 9 or 10 levels).

Answer 1

 for(auto i=LIST.begin();i<LIST.end();++i) {
   LIST.erase(i);
   LIST.insert(i,t);
   ...

The erase call invalidates the iterator to the element being erased - namely, i . Then LIST.insert(i,t) exhibits undefined behavior by way of accessing now-invalid iterator.

Further, LIST.push_back() may invalidate all iterators into the list, including i (had it not been invalidated already).

You may want to use an index, rather than an iterator, to iterate over the list, since you are modifying it so much.