• 模板——链表模板、有序链表模板及测试


    //==============================================================================

    //链表模板《C++编程——数据结构与程序设计方法》16.2作为抽象数据类型的链表

    //Header File:linkedList.h
    #ifndef _LINKEDLIST_H
    #define _LINKEDLIST_H

    template<class Type>
    struct nodeType
    {
     Type info;
     nodeType<Type>* link;
    };

    template<class Type>
    class linkedListType
    {
    public:
     const linkedListType<Type>& operator =(const linkedListType<Type>&);
     //对于含有指针数据成员的类,必须明确重载赋值运算符。
     void initializeList();
     bool isEmptyList();
     bool isFullList();
     void print();
     int length();
     void destroyList();
     void retrieveFirst(Type& firstElement);
     void search(const Type& searchItem);
     void insertFirst(const Type& newItem);
     void insertLast(const Type& newItem);
     void deleteNode(const Type& deleteItem);
     linkedListType();
     linkedListType(const linkedListType<Type>& otherList);//拷贝构造函数
     ~linkedListType();
    protected:
     nodeType<Type>* first;//数据成员是protected,而不是private.这是由于要从这个类中派生其他类。
     nodeType<Type>* last;
    };

    template<class Type>
    bool linkedListType<Type>::isEmptyList()
    {
     return(first==NULL);
    }

    template<class Type>
    bool linkedListType<Type>::isFullList()
    {
     return false;
    }

    template<class Type>
    linkedListType<Type>::linkedListType()
    {
     first=NULL;
     last=NULL;
    }

    template<class Type>
    void linkedListType<Type>::destroyList()
    {
     nodeType<Type> *temp;
     while(first!=NULL)
     {
      temp=first;
      first=first->link;
      delete temp;
     }
     last=NULL;
    }

    template<class Type>
    void linkedListType<Type>::initializeList()
    {
     destroyList();
    }

    template<class Type>
    void linkedListType<Type>::print()
    {
     nodeType<Type>* current;
     current=first;
     while(current!=NULL)
     {
      cout<<current->info<<" ";
      current=current->link;
     }
    }

    //链表的长度
    template<class Type>
    int linkedListType<Type>::length()
    {
     int count=0;
     nodeType<Type>* current;
     current=first;
     while(current!=NULL)
     {
      count++;
      current=current->link;
     }
     return count;
    }

    //检索第一个节点中的数据
    template<class Type>
    void linkedListType<Type>::retrieveFirst(Type& firstElement)
    {
     firstElement=first->info;
    }

    //查找链表
    template<class Type>
    void linkedListType<Type>::search(const Type& item)
    {
     nodeType<Type>* current;
     bool found;

     if(first==NULL)
      cout<<"Cannot search an empty list. "<<endl;
     else
     {
      current=first;
      found=false;
      while(!found&&current!=NULL)
       if(current->info==item)
        found=true;
       else
        current=current->link;
      if(found)
       cout<<"Item is found in the list. "<<endl;
      else
       cout<<"Item is not in the list."<<endl;
     }
    }

    //插入第一个节点
    template<class Type>
    void linkedListType<Type>::insertFirst(const Type& newItem)
    {
     nodeType<Type>* newNode;

    newNode=new nodeType<Type>;
     newNode->info=newItem;
     newNode->link=first;
     first=newNode;

     if(last==NULL)
      last=newNode;
    }
    //插入最后一个节点
    template<class Type>
    void linkedListType<Type>::insertLast(const Type& newItem)
    {
     nodeType<Type>* newNode;
     newNode=new nodeType<Type>;
     newNode->info=newItem;
     newNode->link=NULL;

     if(first==NULL)
     {
      first=newNode;
      last=newNode;
     }
     else
     {
      last->link=newNode;
      last=newNode;
     }
    }

    //删除节点
    template<class Type>
    void linkedListType<Type>::deleteNode(const Type& deleteItem)
    {
     nodeType<Type>* current;
     nodeType<Type>* trailCurrent;
     bool found;

     if(first==NULL)
      cout<<"Cannot delete from an empty list./n";
     else
     {
      if(first->info==deleItem)
      {
       current=first;
       first=first->link;
       if(frist==NULL)
        last=NULL;
       delete current;
      }
      else
      {
       found=false;
       trailCurrent=first;
       current=first->link;

       while(!found&&(current!=NULL))
       {
        if(current->info!=deleteItem)
        {
         trailCurrent=current;
         current=current->link;
        }
        else
         found=true;
       }
       if(found)
       {
        trailCurrent->link=current->link;
        if(last=current)
         last=trailCurrent;
        delete current;
       }
       else
        cout<<"Item to be deleted is not in the list."<<endl;
      }
     }
    }

    //析构函数
    template<class Type>
    linkedListType<Type>::~linkedListType()
    {
     nodeType<Type>* temp;

     while(first!=NULL)
     {
      temp=first;
      first=first->link;
      delete temp;
     }
     last=NULL;
    }

    //拷贝构造函数
    template<class Type>
    linkedListType<Type>::linkedListType(const linkedListType<Type>& otherList)
    //形参是对象的常引用,在函数中不能改变实参的值
    {
     nodeType<Type>* newNOde;
     nodeType<Type>* current;

     if(otherList.First==NULL)
     {
      first=NULL;
      last=NULL;
     }
     else
     {
      //拷贝第一个节点
      current=otherList.first;
      first=new nodeType<Type>;
      first->info=current->info;
      first->Link=NULL;
      last=first;

      current=current->link;
      while(current!=NULL)
      {
       newNode=new nodeType<Type>;
       newNode->info=current->info;
       newNode->link=NULL;

       last->link=newNode;
       current=current->link;
      }
     }
    }

    //重载赋值运算符
    template<class Type>
    const linkedListType<Type>& linkedListType<Type>::operator =(const linkedListType<Type>& otherList)
    {
     nodeType<Type>* newNode;
     nodeType<Type>* current;

     if(this!=&otherList)//避免自拷贝
     {
      if(first!=NULL)
       destroyList();
      if(otherList.first==NULL)//如果otherList是空
      {
       first=NULL;
       last=NULL;
      }
      else
      {
       //拷贝第一个节点
       current=otherList.first;
       first=new nodeType<Type>;
       first->info=current->info;
       first->link=NULL;
       last=first;

       current=current->link;
       while(current!=NULL)
       { 
        newNode=new nodeType<Type>;
        newNode->info=current->info;
        newNode->link=NULL;

        last->link=newNode;
        last=newNode;
        current=current->link;
       }
      }
     }
     return *this;
    }

    #endif

    //===========================================================================

    //有序链表模板——《C++编程——数据结构与程序设计方法》16.3有序链表
    //Header File:orderedList.h
    #ifndef _ORDEREDLIST_H
    #define _ORDEREDLIST_H

    #include <iostream>
    #include "linkedList.h"

    using namespace std;
    //有序链表通常进行下面的操作
    //1.初始化链表
    //2.检查链表是否为空
    //3.检查甸表是否为满
    //4.打印链表
    //5.逆向打印链表
    //6.删除链表
    //7.在链表中查找给定的元素
    //8.在链表中插入一个元素
    //9.在链表中删除一个元素
    //10.查找链表长度
    //11。拷贝链表
    //有序链表与一般链表很类似,可以从类linkedListType派生
    //需要改变查找、插入和删除操作的算法
    template<class Type>
    class orderedLinkedListType:public linkedListType<Type>
    {
     public:
      void search(const Type& item);//查找
      void insertNode(const Type& newItem);//插入
      void deleteNode(const Type& deleteitem);//删除
      void printListReverse() const;//逆向打印,常成员函数,只能引用本类中的数据成员,而不能修改它们。
     private:
      void reversePrint(nodeType<Type> *current) const;
    };

    //查找节点
    template<class Type>
    void orderedLinkedListType<Type>::search(const Type& item)
    {
     bool found;
     nodeType<Type>* current;
     
     found=false;
     current=first;

     if(first==NULL)
      cout<<"Cannot search an empty list. "<<endl;
     else
     {
      while(current!=NULL&&!found)
       if(current->info>=item)//有序链表,找到比要找的数大的,就不用再找了
        found=true;
       else
        current=current->link;
      if(current==NULL)
       cout<<"Item is not in the List"<<endl;
      else
       if(current->info==item)
        cout<<"Item is found in the list"<<endl;
       else
        cout<<"Item is not in the list"<<endl;
     }
    }

    //插入节点
    template<class Type>
    void orderedLinkedListType<Type>::insertNode(const Type& newitem)
    {
     nodeType<Type>* current;
     nodeType<Type>* trailCurrent;
     nodeType<Type>* newNode;
     bool found;

     newNode=new nodeType<Type>;
     newNode->info=newitem;
     newNode->link=NULL;

     if(first==NULL)
      first=newNode;
     else
     {
      current=first;
      found=false;

      while(current!=NULL&&!found)
       if(current->info>=newitem)
        found=true;
       else
       {
        trailCurrent=current;
        current=current->link;
       }
      if(current==first)
      {
       newNode->link=first;
       first=newNode;
      }
      else
      {
       trailCurrent->link=newNode;
       newNode->link=current;
      }
     }
    }

    //删除节点
    template<class Type>
    void orderedLinkedListType<Type>::deleteNode(const Type& deleteItem)
    {
     nodeType<Type>* current;
     nodeType<Type>* trailCurrent;
     bool found;

     if(first==NULL)
      cout<<"Cannot delete from an empty List."<<endl;
     else
     {
      current=first;
      found=false;

      while(current!=NULL&&!found)
       if(current->info>=deleteItem)
        found=true;
       else
       {
        trailCurrent=current;
        current=current->link;
       }
      if(current==NULL)
       cout<<"Item to be delete is not in the list."<<endl;
      else
       if(current->info==deleteItem)
       {
        if(first==current)
        {
         first=first->link;
         delete current;
        }
        else
        {
         trailCurrent->link=current->link;
         delete current;
        }
       }
       else
        cout<<"Item to be delete is not in the list."<<endl;
     }
    }

    //逆向打印链表
    template<class Type>
    void orderedLinkedListType<Type>::printListReverse() const
    {
     reversePrint(first);
     cout<<endl;
    }

    template<class Type>
    void orderedLinkedListType<Type>::reversePrint(nodeType<Type>* current) const
    {
     if(current!=NULL)
     {
      reversePrint(current->link);
      cout<<current->info<<" ";
     }
    }

    #endif

    //========================================================================

    //测试程序,测试有序链表中的各种操作《C++编程——数据结构与程序设计方法》16.3有序链表
    //实现文件:testOrderedList.cpp
    #include <iostream>
    #include "orderedList.h"

    using namespace std;

    int main()
    {
     orderedLinkedListType<int> list1,list2;
     int num;

     cout<<"Line 3:Enter integers ending with -999"<<endl;
     cin>>num;

     while(num!=-999)
     {
      list1.insertNode(num);
      cin>>num;
     }

     cout<<endl;

     cout<<"Line 9:List 1 : ";
     list1.print();
     cout<<endl;

     cout<<"Line 12: List 1 in the reverse order: "<<endl;
     list1.printListReverse();
     cout<<endl;

     list2=list1;

     cout<<"Line 16: List 2: ";
     list2.print();
     cout<<endl;

     cout<<"Line 19:Enter the number to be deleted: ";
     cin>>num;
     cout<<endl;

     list2.deleteNode(num);

     cout<<"Line 23: After deleteing the onde, List 2: "<<endl;
     list2.print();
     cout<<endl;

     return 0;
    }

  • 相关阅读:
    带参的方法
    类的无参方法
    类和对象
    关于线程间的通信的几个解决事例
    一个简单的邮件发送
    关于process
    关于java的static语句块
    关于struts2拦截器获取页面参数
    hexo github pages 首页不展示,出现代码怎么办
    使用Hexo搭建个人博客(三)
  • 原文地址:https://www.cnblogs.com/WestGarden/p/3138419.html
Copyright © 2020-2023  润新知