Пример #1
0
//Copy edges from first node to second
void Graph::copyNodeEdges(std::list<Node>::iterator pn1, std::list<Node>::iterator pn2)
{
    std::list< std::list<Node>::iterator >::iterator pnlist;
    for (pnlist = pn1->getXinBegin(); pnlist != pn1->getXinEnd(); pnlist++)
        setXedge((*pnlist), pn2);
    for (pnlist = pn1->getYinBegin(); pnlist != pn1->getYinEnd(); pnlist++)
        setYedge((*pnlist), pn2);
    for (pnlist = pn1->getXoutBegin(); pnlist != pn1->getXoutEnd(); pnlist++)
        setXedge(pn2, (*pnlist));
    for (pnlist = pn1->getYoutBegin(); pnlist != pn1->getYoutEnd(); pnlist++)
        setYedge(pn2, (*pnlist));
}
Пример #2
0
//Similar to clearDuplicateNodes(); inserts duplicate nodes into list instead of deleting them
void Graph::insertDuplicateNodes(std::list<Node>::iterator pn, std::list< std::list<Node>::iterator >& deleteNodes)
{
    //If there are multiple nodes in the xin list then all these nodes are identical as group elements,
    //so function will choose one to preserve and insert the rest into the given list.
    if (pn->getSizeXin() > 1)
    {
        //Select the node with the least letters to preserve.
        std::list<Node>::iterator preservedNode = pn->getXin();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getXinBegin(); plnIter != pn->getXinEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;  //counts number of letters total in the word
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            //In this case the node you have is the identity, which you definitely want to keep
            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            //If word has less letters than the current preserved node, set it as preserved
            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        //At this point the node which is to be preserved has been chosen. Now copy the edges from the
        //trash nodes to the preserved node and insert the trash nodes into the list.
        plnIter = pn->getXinBegin();
        while (plnIter != pn->getXinEnd())
        {
            //Ignore the preserved node
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            //Copy edges and add node to list
            copyNodeEdges(*plnIter, preservedNode);
            deleteNodes.push_back(*plnIter);
            plnIter++;
        }
    }


    //this is symmetrical to the above block
    if (pn->getSizeYin() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getYin();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getYinBegin(); plnIter != pn->getYinEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getYinBegin();
        while (plnIter != pn->getYinEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            copyNodeEdges(*plnIter, preservedNode);
            deleteNodes.push_back(*plnIter);
            plnIter++;
        }
    }


    if (pn->getSizeXout() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getXout();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getXoutBegin(); plnIter != pn->getXoutEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getXoutBegin();
        while (plnIter != pn->getXoutEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            copyNodeEdges(*plnIter, preservedNode);
            deleteNodes.push_back(*plnIter);
            plnIter++;
        }
    }


    if (pn->getSizeYout() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getYout();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getYoutBegin(); plnIter != pn->getYoutEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getYoutBegin();
        while (plnIter != pn->getYoutEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            copyNodeEdges(*plnIter, preservedNode);
            deleteNodes.push_back(*plnIter);
            plnIter++;
        }
    }
}
Пример #3
0
//Clear dup. nodes pointing to passed in node, return true if such dup.s found
bool Graph::clearDuplicateNodes(std::list<Node>::iterator pn)
{
    if (pn->getSizeXin() > 1)
    {
        //choose the node you want to keep by finding the one with the least letters in its word
        std::list<Node>::iterator preservedNode = pn->getXin();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getXinBegin(); plnIter != pn->getXinEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;  //counts number of letters total in the word
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            //in this case the node you have is the identity, which you definitely want to keep
            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            //if word has less letters than the current preserved node, set it as preserved
            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        //okay so at this point the node which is to be kept has been chosen. now copy the edges from the
        //trash nodes to the preserved node and delete the trash nodes
        plnIter = pn->getXinBegin();
        while (plnIter != pn->getXinEnd())
        {
            //skip over the preserved node
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            //copy edges, remove node, set the iterator to the previous node
            std::list< std::list<Node>::iterator >::iterator prevNodeIter = plnIter;
            prevNodeIter--;
            copyNodeEdges(*plnIter, preservedNode);
            removeNode(*plnIter);
            plnIter = prevNodeIter;
        }

        return true;
    }


    //this is symmetrical to the above block
    if (pn->getSizeYin() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getYin();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getYinBegin(); plnIter != pn->getYinEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getYinBegin();
        while (plnIter != pn->getYinEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            std::list< std::list<Node>::iterator >::iterator prevNodeIter = plnIter;
            prevNodeIter--;
            copyNodeEdges(*plnIter, preservedNode);
            removeNode(*plnIter);
            plnIter = prevNodeIter;
        }

        return true;
    }


    if (pn->getSizeXout() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getXout();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getXoutBegin(); plnIter != pn->getXoutEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getXoutBegin();
        while (plnIter != pn->getXoutEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            std::list< std::list<Node>::iterator >::iterator prevNodeIter = plnIter;
            prevNodeIter--;
            copyNodeEdges(*plnIter, preservedNode);
            removeNode(*plnIter);
            plnIter = prevNodeIter;
        }

        return true;
    }


    if (pn->getSizeYout() > 1)
    {
        std::list<Node>::iterator preservedNode = pn->getYout();
        int presSumExp = 0;
        std::vector<short> presWord = preservedNode->getElemName();
        for (int i = 0; i < presWord.size(); i++)
            presSumExp += presWord[i];

        std::list< std::list<Node>::iterator >::iterator plnIter;
        for (plnIter = pn->getYoutBegin(); plnIter != pn->getYoutEnd(); plnIter++)
        {
            std::vector<short> word = (*plnIter)->getElemName();
            int sumExponents = 0;
            for (int i = 0; i < word.size(); i++)
                sumExponents += word[i];

            if (sumExponents == 0)
            {
                preservedNode = *plnIter;
                break;
            }

            if (sumExponents < presSumExp)
            {
                preservedNode = *plnIter;
                presSumExp = sumExponents;
            }
        }

        plnIter = pn->getYoutBegin();
        while (plnIter != pn->getYoutEnd())
        {
            if ((*plnIter) == preservedNode)
            {
                plnIter++;
                continue;
            }

            std::list< std::list<Node>::iterator >::iterator prevNodeIter = plnIter;
            prevNodeIter--;
            copyNodeEdges(*plnIter, preservedNode);
            removeNode(*plnIter);
            plnIter = prevNodeIter;
        }

        return true;
    }


    //no duplicates found if you get to this point
    return false;
}