单向链表

#include <iostream>
#include "Node.h"
using namespace std;

int main()
{
    Link<int>  link(5);
    
    cout <<"============打印Node============\n";
    link.printNode();
    
    cout <<"============插入Node============\n";
    link.insertNode(6);

     cout <<"============删除Node============\n";
    link.deleteNode(3);
    
    cout <<"============查找Node============\n";
    link.searchNode(2);
    
    cout <<"============link逆序============\n";
    link.reverseSort();
    link.printNode();
    
    cout <<"========判断link是否有环=========\n";
    cout << link.haveLoop() <<endl;
    
    cout <<"=========link中node排序=========\n";
    link.nodeSort();
    link.printNode();

    return 0;

}

template<class T>  //node 类
class Node
{
public:
    T  name;
    Node<T> * next;
};

template<class T>  //link 类
class Link
{
private:
    
    Node<T> * head;
    
public:
    
    Link(int n=3)
    {
        Node<T> * s    = NULL;
        Node<T> * p    = NULL;
        
        if((head = new Node<T>)==NULL)  //head created
        {
            cout<<"fail\n";
            exit(1);
        }
        cout <<"输入head:";
        cin  >>head->name;
        head->next = NULL;
        p = head;
        
        for(int i=0 ;i<n-1;i++)         //node created
        {
            if((s = new Node<T>)==NULL)
            {
                cout <<"fail\n";
                exit(1);
            }
            cout <<"输入Node:";
            cin  >>s->name;
            p->next = s;
            s->next = NULL;
            p = s;
        }
    
        cout << "Link was created successfully\n";
    }
    
    ~Link()
    {
        Node<T> * p    = NULL;
        while(head!=NULL)
        {
            p = head;
            head = head->next;
            delete p;
            p = NULL;
            cout << "over\n";
        }
    }
    
    void printNode ()                   //打印所有节点
    {
        Node<T> * p = head;
        while( p != NULL)
        {
            cout <<p->name <<"\t";
            p = p->next;
        }
        cout <<endl;
    }
    
    
    void insertNode(T _name)            //_name后边插入
    {
        Node<T> * p = head;
        while((p!=NULL) && (p->name!=_name))
        {
            p = p->next;
        }
        if(p ==NULL)
        {
            cout <<"insert failly\n";
        }
        else
        {
            Node<T> * s = NULL;
            if((s = new Node<T>)==NULL)
            {
                cout <<"fail\n";
                exit(1);
            }
            cout <<"输入Node:";
            cin  >>s->name;
            s->next = p->next;
            p->next = s;
            cout <<"insert successfully\n";
        }
        
    }

    void deleteNode(T _name)            //删除_name节点
    {
        Node<T> * p    = head;
        Node<T> * f    = NULL;
        while (p!=NULL && p->name!=_name)
        {
            f = p;
            p = p->next;
        }
        if(p==NULL)
        {
            cout <<"delete node fails\n";
        }
        else
        {
            f->next = p->next;
            cout <<"delete node successfully:"<<p->name<<endl;
            delete  p;
            p = NULL;
            
        }
    }
    
    Node<T> * searchNode(T _name)       //查找节点_name
    {
        Node<T> * p =head;
        while(p!=NULL && p->name!=_name)
        {
            p = p->next;
        }
        if(p == NULL)
        {
            cout <<"no the Node\n";
            exit(1);
        }
        else
            cout <<"Find the node:"<<p->name<<endl;
        return p;
    
    }
    
    void reverseSort()                    //逆序排列
    {
        if(head->next==NULL)
        {
            cout <<"the number of node if 1\n";
            exit(1);
        }
        
        Node<T> * p  = head->next;
        Node<T> * q  = head->next->next;
        Node<T> * t  = NULL;
        while(q!=NULL)
        {
            t = q->next;
            q->next = p;
            p = q;
            q = t;
        }
        head->next->next = NULL;
        head->next = p;
        cout <<"reverse sort successfully\n";
        
    }
    
    bool haveLoop()                     //判断link是否有环
    {
        if(head==NULL || head->next==NULL)
        {
            return false;
        }
        
        Node<T> * pFast = head;
        Node<T> * pBlow = head;
        while(pFast->next!=NULL && pFast->next->next!=NULL)
        {
            pFast = pFast->next->next;
            pBlow = pBlow->next;
            
            while(pFast == pBlow)
            {
                return  true;
            }
        }
        
        return false;
    }
    
    void nodeSort()                    //link中得Node排序
    {
        if(head==NULL && head->next==NULL)
        {
            cout <<"node is only one\n";
            exit(1);
        }
        
        int count = 0;                 //计算node的个数，除过头结点
        Node<T> * n = head;
        while (n->next != NULL)
        {
            count ++;
            n = n->next;
        }
        for (int i=0;i<count ;i++)
        {
            Node<T> * p = head->next;
            for (int j=0;j<count-i-1;j++)
            {
                if((p->name)> (p->next->name))
                {
                    T t = p->name;
                    p->name = p->next->name;
                    p->next->name = t;
                }
                p = p->next;
            }
        }
    }
    
};