범용리스트(generalized list)를 역으로 만드는 방법이 뭐가 있을까요?

#include <iostream>

using namespace std;

 

template <typename T>

class GenList;

 

enum GenListNodeType { HEAD, DATA, LIST }; //타입: dummy, 데이터, 리스트

 

template <typename T>

class GenListNode

{

public:

        GenListNodeType type; //타입

        T data;

        GenList<T> *list;

        GenListNode<T> *next;

        GenListNode<T>()

        {

               type = HEAD;

               data = 0;

               list = NULL;

               next = NULL;

        }

        ~GenListNode<T>()

        {

               if (list)

                       delete list;

        }

};

 

template <typename T>

class GenList

{

private:

        GenListNode<T> *first;

public:

        GenList()

        {

               first = new GenListNode<T>; //더미노드 삽입

               first->next = NULL;

        }

        ~GenList()

        {

               GenListNode<T> *p;

               while (first->data>0) //유효데이터일 때

               {

                       p = first;

                       first = first->next;

                       delete p;

               }

        }

        void Insert(const T &item)

        {

               GenListNode<T> *temp = new GenListNode<T>;

               temp->data = item;

               temp->type = DATA;

               temp->next = first->next;

               first->next = temp; //더미노드 다음에 삽입

        }

        void Insert(const GenList<T> &gl) //리스트를 추가하는 경우

        {

               GenList<T> *temp1 = new GenList<T>(gl);

               GenListNode<T> *item = new GenListNode<T>;

               item->type = LIST;

               item->list = temp1;

               item->next = first->next;

               first->next = item;

        }

        int Depth() const

        {

               int depth = 0;

               GenListNode<T> *p = first->next;

               while (p)

               {

                       if (p->type == LIST)

                       {

                              int p_depth = p->list->Depth(); //리스트가 두개 이상인 경우를 위해

                              if (p_depth > depth)

                                      depth = p_depth;

                       }

                       p = p->next;

               }

               return ++depth;

        }

        void PrintList() const

        {

               GenListNode<T> *p = first->next;

               while (p)

               {

                       if (p->type == DATA)

                       {

                              cout << p->data;

                              if (p->next)

                                      cout << "->";

                       }

                       if (p->type == LIST) //리스트가 둘 이상일 경우 재귀식으로 출력한다

                       {

                              p->list->PrintList();

                              if (p->next)

                                      cout << "->";

                       }

                       p = p->next;

               }

        }

};

 

int main(void)

{

        GenList<int> intG;

        for (int i = 0; i < 5; i++)

               intG.Insert(i + 1);

        intG.PrintList();

        cout << endl;

 

        GenList<int> intG2;

        for (int i = 5; i < 10; i++)

               intG2.Insert(i + 1);

        intG.Insert(intG2);

        intG.PrintList();

        cout << endl;

        cout << "깊이: " << intG.Depth() << endl;

        return 0;

}

그냥 list면 어떻게 해보겠는데 범용리스트라서 그 안의 sublist들을 어떻게 해야 할지 모르겠습니다.
(a,(b,c)) -> ((c,b),a)

저 코드로 돌려보니 잘 작동합니다. 무엇이 문제인가요? 다만 ~GenList() 내부 루프가 실행되지는 않는군용

아, 코드는 잘 작동합니다만, 만들어진 리스트를 역으로 만드는 함수를 구현하고 싶은데 방법이 생각이 아나네요. 스택을 써서 하나씩 copy해서 거꾸로 다시 리스트를 만들까… 해봤는데 잘 안됩니다 ㅜㅜ

sublist도 뒤집을거면 스택에 옮기는(또는 꺼내는) 과정에서 뒤집어주면 될 것 같네용. 뒤집는 함수를 재귀적으로 짜면 될 것 같다는 생각을 해봅니다

1 Like

리슾 짜는 느낌으루… 하시면 될것 같읍니다.