| 网站首页 | 业界新闻 | 小组 | 威客 | 人才 | 下载频道 | 博客 | 代码贴 | 在线编程 | 编程论坛
欢迎加入我们,一同切磋技术
用户名:   
 
密 码:  
共有 2963 人关注过本帖
标题:C++编写的链式数据结构
只看楼主 加入收藏
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
 问题点数:0 回复次数:13 
C++编写的链式数据结构
包括了单链表,堆栈,队列,以及二叉数和迭代器
首先发迭代器
    //保存的文件名为ListIterator.h
    #ifndef LISTITERATOR_H
    #define LISTITERATOR_H
   
   
    namespace Shining100ListIteraor//定义迭代器的名字空间
    {
        template<class T>
        class Node//定义链式结构的结点类
        {
            public:
                Node(const T& dataValue,Node<T>* linkValue):data(dataValue),link(linkValue){}//结点类的构造函数,并对结点赋于一个类型为T的值,和指向下一个结点的指针
                const T getData() const{return data;}//返回结点的数据
                Node<T>* getLink() const{return link;}//返回该结点指向下一个结点的指针
                void setData(const T& dataValue){data=dataValue;}//给结点赋于一个类型为T的值
                void setLink(Node<T>* linkValue){link=linkValue;}//设置该结点指向下一结点的指针
            private:
                T data;//结点的值
                Node<T>* link;//该结点指向下一个结点的指针
        };
        
        template<class T>
        class ListIterator//链式结构的迭代器类
        {
            public:
                ListIterator():current(NULL){}//将当前结点的值指向空
                ListIterator(Node<T>* currentValue):current(currentValue){}//将当前结点的值指向值currntValue
                const T operator *(){return current->getData();}//重载操作符*,读取当前结点的值
                ListIterator operator ++()重载操作符++,使指针指向下一个结点
                {
                    current=current->getLink();//使指针向下移
                    return *this;
                }
            
                ListIterator operator ++(int)重载操作符++(操作符在数的后面)
                {
                    ListIterator startVersion(current);
                    current=current->getLink();//使指针向下移
                    return startVersion;
                }
            
                bool operator ==(const ListIterator& rightSide) const{return current==rightSide.current;}//重在操作符==,判断等号左右两边的值是否相等
            
                bool operator !=(const ListIterator& rightSide) const{return current!=rightSide.current;}//重在操作符!=,判断等号左右两边的值是否不相等
            private:
                Node<T>* current;//指向当前结点的指针
        };
    }
    #endif

[[it] 本帖最后由 shining100 于 2008-2-10 12:04 编辑 [/it]]
搜索更多相关主题的帖子: 链式 数据结构 堆栈 结点 
2008-02-09 15:39
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
链表的头文件
    //保存的文件名为List.h
    #ifndef LIST_H
    #define LIST_H
    #include "ListIterator.h"
    using namespace Shining100ListIteraor;//引用迭代器类的名字空间

    namespace Shinining100List
    {
        template<class T>
        class List//链表类
        {
            public:
                typedef ListIterator<T> ListIterator;//在链表类中对迭代器类进行重命名
                List():node(NULL),head(NULL){}//默认构造函数,将链表的头结点和当前结点设为NULL
                List(const List<T>& l);//复制构造函数,将另外一个链表的所有结点赋给当前链表
                void headInsert(const T& dataValue);//将值为dataValue的结点插入链表的头部
                void insert(const T& dataValue);//将值为dataValue的结点插入到noed结点的后面
                void deleteNode();//删除node结点的下一个结点
                void deleteFirstNode();//删除头结点
                Node<T> search(const T& target);//搜索链表中是否存在值为target的结点
                bool isEmpty() const;//判断链表是否为空
                ListIterator begin() const{return ListIterator(head);}//使迭代器指向链表的头
                ListIterator end() const{return ListIterator();}//使迭代器指向链表的结尾
                List<T>& operator =(const List<T>& rightSide);//重载操作符=,将另外一个链表的所有结点赋给当前链表
                virtual ~List();
            private:
                Node<T>* node;//链表的当前结点
                Node<T>* head;//链表的头结点
        };
    }
    #endif

[[it] 本帖最后由 shining100 于 2008-2-11 16:56 编辑 [/it]]
2008-02-09 15:40
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
链表的实现文件
    //保存的文件名为List.cpp
    #include<iostream.h>
    #include<cstddef>
    #include<cstdlib>
    #include "List.h"
    using std::cout;


    namespace Shinining100List
    {
        template<class T>
        List<T>::List(const List<T>& l)
        {
            //判断链表是否为空,如为空,则将头指针和当前指针指向NULL
            if(l.isEmpty())
                node=head=NULL;
            else
            {
                //开辟当前链表的第一个结点
                List<T>* temp=l.head;
                head=new Node<T>(temp->getData(),NULL);开辟当前链表的头结点,并将另一个链表头结点的值赋给当前链表
                node=head;//将链表当前指针的值指向head
                temp=temp->getLink();//将另一个链表的当前结点的指针指向下一个结点
                //将另一个链表的头结点后的所有结点赋给当前链表
                while(temp!=NULL)
                {
                    node->setLink(new Node<T>(temp->getData(),NULL));//开辟一个新的结点,使新结点的值为另一个链表当前结点的值,并将新结点连接到当前结点的后面
                    node=node->getLink();
                    temp->getLink();
                }
            }
        }
               

        template<class T>
        void List<T>::headInsert(const T& dataValue)
        {
            head=new Node<T>(dataValue,head);//开辟一个新的结点,使新结点指向链表的头结点,并将链表的头指针移向当前结点
        }

        template<class T>
        void List<T>::insert(const T& dataValue)
        {
            //判断链表是否为空,如为空则创建新的结点,并将当前结点的指针和头指针的指向它
            if(isEmpty())
                head=node=new Node<T>(dataValue,NULL);
            //如不为空,则在当前结点后插入新的结点,并将当前结点的指针指向新插入的结点
            else
            {
               node->setLink(new Node<T>(dataValue,NULL));
               node=node->getLink();
            }
        }

        template<class T>
        void List<T>::deleteNode()
        {
            Node<T>* disCard;
            disCard=node->getLink();//将要删除的结点放到临时变量discard中
            node->setLink(disCard->getLink());//使要删除结点的前一个结点的指针指向要删除结点的后一个结点
            delete disCard;
        }

        template<class T>
        void List<T>::deleteFirstNode()
        {
            Node<T>* disCard;
            disCard=head;
            head=head->getLink();//将头结点所指向的下一个结点设为头结点
            delete disCard;
        }

        template<class T>
        Node<T> List<T>::search(const T& target)
        {
            Node<T>* here;
            here=head;
            //如果链表为空,则返回NULL
            if(here==NULL)
            {
                return NULL;
            }
            else
            {
                //当没有找到值,并且不是链表的最后一个结点,则将当前结点的指针指向下一个结点继续寻找
                while(here->getData()!=target && here->getLink()!=NULL)
                    here=here->getLink();
                //如果找到了,则返回该结点
                if(here->getData()==target)
                    return here;
                //如果链表中无此值,则返回NULL
                else
                {
                    return NULL;
                }
            }
        }
        
        template<class T>
        bool List<T>::isEmpty() const
        {
            return(head==NULL);//如果head为NULL,说明链表为空,返回true
        }
        
        template<class T>
        List<T>& List<T>::operator =(const List<T>& rightSide)
        {
            //如果等号右边是该链表本身,则返回该链表
            if(head=rightSide.head)
                return *this;
            else
            {
                //将当前链表的所有结点删除
                while(!isEmpty())
                {
                    Node<T>* disCard;
                    disCard=head;
                    head=head->getLink();
                    delete disCard;
                }
                //如果等号右边的链表为空,则将当前链表的头指针和当前指针设为NULL
                if(rightSide.isEmpty())
                {
                    head=node=NULL;
                    return *this;
                }
                //将等号右边链表的所有结点赋给等号左边的链表
                else
                {
                    List<T>* temp=rightSide.head;
                    head=new Node<T>(temp,NULL);
                    node=head;
                    temp=temp->getLink();
                    while(temp!=NULL)
                    {
                        node->setLink(new Node<T>(temp->getData(),temp));
                        node=node->getLink();
                        temp->getLink();
                    }
                    return *this;
                }
            }
        }
        
        template<class T>
        List<T>::~List()
        {
             Node<T>* disCard;
             //删除链表的所有结点
             while(!isEmpty())
             {
                disCard=head;
                head=head->getLink();
                delete disCard;
             }
        }
    }

[[it] 本帖最后由 shining100 于 2008-2-10 12:53 编辑 [/it]]
2008-02-09 15:41
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
堆栈的头文件
    //保存的文件名为Stack.h
    #ifndef STACK_H
    #define STACK_H
    #include "ListIterator.h"
    using namespace Shining100ListIteraor;//引用迭代器类的名字的空间
   
    namespace Shining100Stack
    {
        template<class T>
        class Stack
        {
            public:
                typedef ListIterator<T> ListIterator;//在链表类中对迭代器类进行重命名
                Stack();//默认构造函数,将堆栈的栈顶指针top设为NULL
                Stack(const Stack<T>& s);//复制构造函数,将另外一个堆栈的所有结点赋给当前堆栈
                Stack<T>& operator =(const Stack<T>& rightSide);//重载操作符=,将另外一个堆栈的所有结点赋给当前堆栈
                void push(const T& nodeValue);//将值nodeValue压入堆栈
                T pop();将堆栈中的所有数据弹出
                bool isEmpty() const;判断堆栈是否为空
                ListIterator begin() const{return ListIterator(top);}//使迭代器指向堆栈的顶top
                ListIterator end() const{return ListIterator();}//使迭代器指向堆栈的底,即将top指向NULL
                virtual ~Stack();
            private:
                Node<T>* top;//堆栈的栈顶指针
        };
    }
    #endif

[[it] 本帖最后由 shining100 于 2008-2-10 23:25 编辑 [/it]]
2008-02-09 15:42
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
堆栈的实现文件
    #include<iostream.h>
    #include<cstdlib>
    #include<cstddef>
    #include "Stack.h"
    using std::cout;
    using std::endl;
   
   
    namespace Shining100Stack
    {
        //将堆栈的栈顶指针top设为NULL
        template<class T>
        Stack<T>::Stack():top(NULL)
        {
        }
        
        template<class T>
        Stack<T>::Stack(const Stack<T>& s)
        {
        //判断堆栈是否为空,如为空,则将栈顶指针指向NULL
            if(s.isEmpty())
                top==NULL;
            else
            {
        //开辟当前堆栈的第一个结点
                Node<T>* temp=s.top;
                Node<T>* end;//设置栈底指针
                end=new Node<T>(temp->getData(),NULL);//开辟当前堆栈的栈底结点,并将另一个堆栈顶结点的值赋给当前堆栈
                top=end;//将栈底指针的值赋给栈顶指针
                temp=temp->getLink();
                //将另一个堆栈的栈顶结点后的所有结点赋给当前堆栈
                while(temp!=NULL)
                {
                    end->setLink(new Node<T>(temp->getData(),NULL));
                    temp=temp->getLink();
                    end=end->getLink();
                }
            }
        }
        
        template<class T>
        Stack<T>& Stack<T>::operator =(const Stack<T>& rightSide)
        {
            //如果等号右边是该堆栈本身,则返回该堆栈
            if(top==rightSide.top)
                return *this;
            //将当前堆栈的所有结点删除
            else
            {
                T next;
                while(!isEmpty())
                   t=pop();
            }
             //如果等号右边的堆栈为空,则将当前堆栈的栈顶指针设为NULL
            if(rightSide.isEmpty())
            {
                top=NULL;
                return *this;
            }
            else
            {
                Node<T>* temp=s.top;
                Node<T>* end;
                end=new Node<T>(temp->getData(),NULL);
                top=end;
                temp=temp->getLink();
                while(temp!=NULL)
                {
                    end->setLink(new Node<T>(temp->getData(),NULL));
                    temp=temp->getLink();
                    end=end->getLink();
                }
                return *this;
            }
        }
        
        template<class T>
        void Stack<T>::push(const T& nodeValue)
        {
            top=new Node<T>(nodeValue,top);//开辟一个新的结点,并将top指针指向新开辟的结点
        }
        
        template<class T>
        T Stack<T>::pop()
        {
            //如果堆栈为空,则退出程序
            if(isEmpty())
            {
                cout<<"Error:popping an empty stack.\n" ;
                exit(1);
            }
            Node<T>* disCard;
            T temp;
            temp=top->getData();
            disCard=top;
            top=top->getLink();
            delete disCard;
            return temp;
        }
        
        template<class T>
        bool Stack<T>::isEmpty() const
        {
            return(top==NULL);
        }
        
        template<class T>
        Stack<T>::~Stack()
        {
            Node<T>* disCard;
            while(!isEmpty())
            {
                disCard=top;
                top=top->getLink();
                delete disCard;
            }
        }
    }

[[it] 本帖最后由 shining100 于 2008-2-10 23:47 编辑 [/it]]
2008-02-09 15:48
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
队列的头文件
//保存的文件名为Queue.h
    #ifndef QUEUE_H
    #define QUEUE_H
    #include "ListIterator.h"
    using namespace Shining100ListIteraor;//引用迭代器类的名字空间
   
    namespace Shining100Queue
    {        
        template<class T>
        class Queue
        {
            public:
                typedef ListIterator<T> ListIterator;//在队列类中对迭代器类进行重命名
                Queue();//默认构造函数,将队列的首指针和当尾指针设为NULL
                Queue(const Queue<T>& q);//复制构造函数,将另外一个队列的所有结点赋给当前对列
                bool isEmpty() const;//判断队列是否为空
                void add(const T& dataValue);//向队列中增添一个结点
                T removeData();//从队列的头移出一个结点
                ListIterator begin() const{return ListIterator(front);}//使迭代器指向队列的首指针
                ListIterator end() const{return ListIterator();}//使迭代器指向队列的结尾
                Queue<T>& operator =(const Queue<T>& rightSide);//重载操作符=,将另外一个队列的所有结点赋给当前对列
                virtual ~Queue();
            private:
                Node<T>* front;//队列的队首指针
                Node<T>* back;//队列的队尾指针
        };
    }
    #endif

[[it] 本帖最后由 shining100 于 2008-2-11 16:55 编辑 [/it]]
2008-02-09 15:50
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
队列的实现文件
    #include<iostream.h>
    #include<cstdlib>
    #include "Queue.h"
    using std::cout;
   
   
    namespace Shining100Queue
    {
        template<class T>
        Queue<T>::Queue():front(NULL),back(NULL)
        {
        }
        
        template<class T>
        Queue<T>::Queue(const Queue<T>& q)
        {
            //判断队列是否为空,如为空,则将队首指针和队尾指针指向NULL
            if(q.isEmpty())
                front=back=NULL;
            else
            {
                //开辟当前队列的第一个结点
                Node<T>* temp=q.front;
                back=new Node<T>(temp->getData(),NULL);//开辟队列的第一个结点,并将另一个队列队首结点的值赋给当前队列
                front=back;//使队首指针也指向队列的第一个结点
                temp=temp->getLink();//将另一个队列的队首结点的指针指向下一个结点
                //将另一个队列的第一个结点后的所有结点赋给当前队列
                while(temp!=NULL)
                {
                    back->setLink(new Node<T>(temp->getData(),NULL));//开辟一个新的结点,使新结点的值为另一个队列当前结点的值,并将新结点连接到当前结点的后面
                    back=back->getLink();
                    temp=temp->getLink();
                }
            }
        }
        
        template<class T>
        bool Queue<T>::isEmpty() const
        {
            return(front==NULL);
        }
        
        template<class T>
        void Queue<T>::add(const T& dataValue)
        {
            //如果队列为空,则新建一个结点,并将队列的队首指针和队尾指针指像新开辟的结点
            if(isEmpty())
                front=back=new Node<T>(dataValue,NULL);
            else
            {
                back->setLink(new Node<T>(dataValue,NULL));//开辟一个新的结点,并将其添加到back结点后面
                back=back->getLink();//使back指针指向新开辟的新结点
            }
        }
        
        template<class T>
        T Queue<T>::removeData()
        {
            //如果队列为空,则退出程序
            if(isEmpty())
            {
                cout<<"Error:Removing an item from an empty queue.\n";
                exit(1);
            }
            T result;
            Node<T>* disCard;
            result=front->getData();
            disCard=front;
            front=front->getLink();
            //如果结点以被删完了,就将队列的尾指针也指向NULL
            if(front==NULL)
                back=NULL;
            delete disCard;
            return result;
        }
        
        template<class T>
        Queue<T>& Queue<T>::operator =(const Queue<T>& rightSide)
        {
            //如果等号右边的队列和等号左边是同一个队列,则直接返回当前队列
            if(front=rightSide.front)
                return *this;
            else
            {
            //删除当前队列的所有结点
                while(!isEmpty())
                {
                    Node<T>* disCard;
                    disCard=front;
                    front=front->getLink();
                    delete disCard;
                }
                //如果等号右边的队列为空,则将等号左边的队列的队首指针和队尾指针指向NULL
                if(rightSide.isEmpty())
                {
                    front=back=NULL;
                    return *this;
                }
                else
                {
                    //将等号右边的第一个结点赋给等号左边的第一个结点
                    Node<T>* temp=rightSide.front;
                    back=new Node<T>(temp->getData(),NULL);
                    front=back;
                    temp=temp->getLink();
                    //将等号右边的第一个结点后的所有结点赋给等号左边的队列
                    while(temp!=NULL)
                    {
                        back->setLink(new Node<T>(temp->getData(),NULL));
                        back=back->getLink();
                        temp=temp->getLink();
                    }
                    return *this;
                  }
              }
            }
            
            template<class T>
            Queue<T>::~Queue()
            {
                Node<T>* disCard;
                while(!isEmpty())
                {
                    disCard=front;
                    front=front->getLink();
                    delete disCard;
                }
            }
        }

[[it] 本帖最后由 shining100 于 2008-2-11 17:23 编辑 [/it]]
2008-02-09 15:52
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
二叉树的头文件
    #ifndef BINTREE_H
    #define BINTREE_H
保存的文件名为BinTree.h
    #include "ListIterator.h"
    using namespace Shining100ListIteraor;//引用迭代器类的名字空间

        
    namespace Shining100BinTree
    {
        template<class T>
        class BinTree;//首先声明二叉树类

        template<class T>
        class TreeNode//二叉树结点类
        {
            public:
                TreeNode():data(0),leftLink(NULL),rightLink(NULL){}//默认构造函数,创造一个结点,结点的值为0,该结点的左右指针都为NULL
                TreeNode(const T& dataValue,TreeNode<T>* leftLinkValue,TreeNode<T>* rightLinkValue):data(dataValue),leftLink(leftLinkValue),rightLink        (rightLinkValue){}//构造函数,创造一个结点,该结点的值为dataValue,左右指针的值分别为leftLinkValue和rightLinkValue
                friend class BinTree<T>;//将二叉树类声明为本类的友元,通过此声明,二叉树类可以直接访问本类的私有成员
            private:
                T data;//结点的值
                TreeNode<T>* leftLink;//指向该结点的左孩子
                TreeNode<T>* rightLink;//指向该结点的右孩子
        };
        
        template<class T>
        class BinTree//二叉树类
        {
            public:
                typedef ListIterator<T> ListIterator;//重命名迭代器类
                BinTree():root(NULL){}//默认构造函数,将根结点root指向NULL
                void insert(const T& dataValue);//以中序将值dataValue插入二叉树中
                T searchTree(const T& dataValue) const;//以中序搜索值dataValue是否在二叉树中
                void preOrderShow() const;//以前序遍历二叉树
                void inOrderShow() const;//以中序遍历二叉树
                void postOrderShow() const;//以后序遍历二叉树
                ListIterator begin() const{return ListIterator(root);}//使迭代器指向二叉树的根结点
                ListIterator end() const{return ListIterator();}//使迭代器指向二叉树的叶子结点
                virtual ~BinTree();
            private:
                //各函数在私有成员中的重载形式是该功能的具体实现,而公有成员中的函数则隐藏了指针的细节,以便使用
                void insert(const T& dataValue,TreeNode<T>* &subTreeRoot);
                T searchTree(const T& dataValue,TreeNode<T>* subTreeRoot) const;
                void deleteSubTree(TreeNode<T>* &subTreeRoot);
                void preOrderShow(TreeNode<T>* subTreeRoot) const;
                void inOrderShow(TreeNode<T>* subTreeRoot) const;
                void postOrderShow(TreeNode<T>* subTreeRoot) const;
                TreeNode<T>* root;//二叉树的根结点指针
        };
    }
    #endif

[[it] 本帖最后由 shining100 于 2008-2-11 23:08 编辑 [/it]]
2008-02-09 15:54
shining100
Rank: 1
等 级:新手上路
帖 子:29
专家分:0
注 册:2007-4-17
收藏
得分:0 
二叉树的实现文件
    #include<iostream.h>
    #include<cstdlib>
    #include "BinTree.h"
    using std::cout;
   
   
    namespace Shining100BinTree
    {
        template<class T>
        void BinTree<T>::insert(const T& dataValue,TreeNode<T>* &subTreeRoot)
        {
            //以递归的形式按中序插入结点
            if(subTreeRoot==NULL)
                subTreeRoot=new TreeNode<T>(dataValue,NULL,NULL);
            else if(dataValue<subTreeRoot->data)
                insert(dataValue,subTreeRoot->leftLink);
            else
                insert(dataValue,subTreeRoot->rightLink);
        }
        
        template<class T>
        void BinTree<T>::insert(const T& dataValue)
        {
            insert(dataValue,root);
        }
        
        template<class T>
        T BinTree<T>::searchTree(const T& dataValue,TreeNode<T>* subTreeRoot) const
        {
             //判断树是否为空
            if(subTreeRoot==NULL)
            {
                cout<<"There is no such number in tree.\n";
                exit(1);
            }
            //以递归的形式按中序遍历结点
            else if(subTreeRoot->data=dataValue)
                return subTreeRoot->data;
            else if(subTreeRoot->data<dataValue)
                searchTree(dataValue,subTreeRoot->leftLink);
            else
                searchTree(dataValue,subTreeRoot->rightLink);
        }
        
        template<class T>
        T BinTree<T>::searchTree(const T& dataValue) const
        {
            return searchTree(dataValue,root);
        }
        
        template<class T>
        void BinTree<T>::deleteSubTree(TreeNode<T>* &subTreeRoot)
        {
            if(subTreeRoot!=NULL)
            {
                deleteSubTree(subTreeRoot->leftLink);
                deleteSubTree(subTreeRoot->rightLink);
                delete subTreeRoot;
                subTreeRoot=NULL;
            }
        }
        
        template<class T>
        void BinTree<T>::preOrderShow(TreeNode<T>* subTreeRoot) const
        {
            if(subTreeRoot!=NULL)
            {
                cout<<subTreeRoot->data<<" ";
                preOrderShow(subTreeRoot->leftLink);
                preOrderShow(subTreeRoot->rightLink);
            }
        }
        
        template<class T>
        void BinTree<T>::preOrderShow() const
        {
            preOrderShow(root);
        }
        
        template<class T>
        void BinTree<T>::inOrderShow(TreeNode<T>* subTreeRoot) const
        {
            if(subTreeRoot!=NULL)
            {
                inOrderShow(subTreeRoot->leftLink);
                cout<<subTreeRoot->data<<" ";
                inOrderShow(subTreeRoot->rightLink);
            }
        }
        
        template<class T>
        void BinTree<T>::inOrderShow() const
        {
            inOrderShow(root);
        }
        
        template<class T>
        void BinTree<T>::postOrderShow(TreeNode<T>* subTreeRoot) const
        {
            if(subTreeRoot!=NULL)
            {
                postOrderShow(subTreeRoot->leftLink);
                postOrderShow(subTreeRoot->rightLink);
                cout<<subTreeRoot->data<<" ";
            }
        }
        
        template<class T>
        void BinTree<T>::postOrderShow() const
        {
            postOrderShow(root);
        }
        
        template<class T>
        BinTree<T>::~BinTree()
        {
            deleteSubTree(root);
        }
    }

[[it] 本帖最后由 shining100 于 2008-2-11 23:13 编辑 [/it]]
2008-02-09 15:55
天使梦魔
Rank: 16Rank: 16Rank: 16Rank: 16
等 级:版主
威 望:37
帖 子:564
专家分:2754
注 册:2007-8-29
收藏
得分:0 
太长。。。。。
还有,一点点的注解都没有,连你定义的东西都弄不清是做什么的。

会的不用看,不会的看不懂。

不清楚目的是什么
2008-02-10 09:52
快速回复:C++编写的链式数据结构
数据加载中...
 
   



关于我们 | 广告合作 | 编程中国 | 清除Cookies | TOP | 手机版

编程中国 版权所有,并保留所有权利。
Powered by Discuz, Processed in 0.017327 second(s), 7 queries.
Copyright©2004-2024, BCCN.NET, All Rights Reserved