一道微软的Mini-Test笔试题 解决方法。

题目要求基本如下：
请编写一个控制台程序,要求用户可以输入任意组条件，定义两个字母之间的大小关系。程序可以通过已输入的条件，推断出给定的两个字母之间的大小关系。例如：
用户输入：A>B
用户输入：B>C
用户输入：A?C
程序显示：A>C
用户输入：C<D
用户输入：A?D
程序显示：无法判断
用户输入：A<C
程序显示：与原有条件冲突


提供者链接在：

http://www.cppblog.com/tddyy/archive/2007/06/29/mini-test_relation.html
tddyy已经实现了这个题目

我的实现可以判断所有ASII类型，由于测试的不怎么样，可能有错误，请大家指正：
///
实现方法：
根据输入的条件，建立一个主链表，表示输入的所有的字符
主链表的每一个元素含有一个数组，用它来保存所有比他小的元素的地址。具体实现看代码。

希望黏贴的很完全，^_^.

// MiniTest.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <string>
#include <vector>
#include <vld.h>
using namespace std;

class Data  
{
    public:

    char c;

    Data(char ch)
    {
        this->c=ch;
    }
    ~Data()
    {
        if (relationlink.size ()>0)
        {
            relationlink.clear ();
        }
    }
    vector<Data*> relationlink;//保存所有小于 指针
    Data* link;//指向下一个元素
    bool operator==(Data* pdata)
    {
        if (pdata->c==c)
        {
            return true;
        }
        return false;
    }
    bool operator==(char ch)
    {
        if (c==ch)
        {
            return true;
        }
        return false;
    }
    bool operator==(Data& data)
    {
        if (data.c==c)
        {
            return true;
        }
        return false;
    }
};

class MiniTest
{
public:
    MiniTest()
    {
        mHeader=NULL;
    }
    ~MiniTest()
    {    Data* p=mHeader;
        Data* next;
        while (NULL!=p)
        {
            next=p->link;
            delete p;
            p=next;
        }
    }

    void setUserInput(string str)
    {
        if (str.length ()>3)
        {
            cout<<"请根据要求输入数据";
            return;
        }
        string tempstr=convertInput (str);
        if (""==tempstr)
        {
            return;
        }
        if ("?"==tempstr)
        {
            //Data data(str[0]);
            bool res=getResult (str[0],str[2]);
            if (res)
            {
                cout<<str[0]<<">"<<str[2]<<endl;
                return;
            }
           
            res=getResult (str[2],str[0]);
            if (res)
            {
                cout<<str[0]<<"<"<<str[2]<<endl;
                return;
            }
            cout<<"根据输入的条件还不能判断"<<endl;
            return;
        }
        if (str[0]==str[2])
        {
            cout<<"输入了相同的数据"<<endl;
            return;
        }
        Data* p;
        if (NULL==mHeader)
        {
            mHeader= new Data(tempstr[0]);
            mHeader->link=NULL;
            mLastData=mHeader;
            p=getData (tempstr[2]);
            if (p)
            {    
                mHeader->relationlink.push_back(p);
            }
            else
            {
                cout<<"run error";
            }
           
        }
        else
        {
            p=getData (tempstr[0]);
            if (IsSameCase (p,tempstr[2]))
            {
                return;
            }
            if (inputConflict (tempstr[0],tempstr[2]))
            {
                cout<<"条件冲突"<<endl;
                return;
            }
            p->relationlink.push_back (getData (tempstr[2]));
        }
    
    }

protected:

    string convertInput(string str)
    {
        char tempch=str[1];
        if (!('>'==tempch||'?'==tempch||'<'==tempch))
        {
            cout<<"请根据要求输入数据";
            return "";
        }
        if ('<'==tempch)
        {
            char temp;
            temp=str[0];
            str[0]=str[2];
            str[1]='>';
            str[2]=temp;
            return str;
        }
        if ('?'==tempch)
        {
            return "?";
        }
        return str;
    }
    Data* getData(char ch)
    {
        Data* p;
        p=mHeader;
        //assert(p);
        while (NULL!=p)
        {
            if (*p==ch)
            {
                return p;
            }
            p=p->link;
               
        }
        mLastData->link=new Data(ch);
        mLastData=mLastData->link;
        mLastData->link=NULL;
        return mLastData;
    }

    bool getResult(char ch1,char ch2)
    {
        Data* p=existData (ch1);
        if (NULL==p)
        {
            return false;
        }
        if(!searchData(p->relationlink,ch2))
        {
            return false;
        }
        return true;
    }
    Data* existData(char ch)
    {
        Data* p;
        p=mHeader;
        while (NULL!=p)
        {
            if (*p==ch)
            {
                return p;
            }
            p=p->link;
        }
        return NULL;
    }
    bool searchData(vector<Data*> vecdata,char ch)
    {    bool ret;
        int count=vecdata.size ();
        for (int i=0;i<count;i++)
        {
            if (*vecdata[i]==ch)
            {
               
                return true;
            }
             ret= searchData (vecdata[i]->relationlink,ch);
             if (ret)
             {
                 return true;
             }
        }
        return false;
    }
    bool IsSameCase(Data* p,char ch)
    {
        int count=p->relationlink.size ();
        for (int i=0;i<count;i++)
        {
            if (*p->relationlink[i]==ch)
            {
                return true;
            }
        }
        return false;
    }
    bool inputConflict(char ch1,char ch2)
    {
        Data* p=getData (ch2);
        int count=p->relationlink.size ();
        for (int i=0;i<count;i++)
        {
            if (*p->relationlink[i]==ch1)
            {
                return true;
            }
        }
        return false;
    }
protected:
        Data* mHeader;
        Data* mLastData;

};
int _tmain(int argc, _TCHAR* argv[])
{
    MiniTest* test=new MiniTest;
    while (1)
    {
        string str;
        cin>>str;
        if ("q"==str)
        {
            break;
        }
        test->setUserInput (str);
    }
    delete test;
    return 0;
}