数据结构第二章线性表（三）①逆序打印单链表②删除单链表中大于minK且小于maxK的元素③双循环链表是否对称

7、逆序打印单链表

写一个函数，逆序打印单链表中的数据（单链表是带有头结点的单链表）。

#include 
using namespace std;

template <class DataType>
struct node{
     
DataType data;
node<DataType>* next;
};

template <class DataType>
class linkList{
     
    public:
        linkList();
        ~linkList();
        node<DataType>* getFirst();
        void reversePrint(node<DataType>* p);
    private:
        node<DataType>* first;
};

template <class DataType>
linkList<DataType>::linkList()
{
     
    first = new node<DataType>;
    first->next = NULL;
    node<DataType>* rear = first;
    int n;
    cin>>n;
    for(int i=0;i<n;++i){
     
        DataType elem;
        cin>>elem;
        node<DataType>* s = new node<DataType>;
        s->data = elem;
        s->next = NULL;
        rear->next = s;
        rear = s;
    }
}
template <class DataType>
linkList<DataType>::~linkList()
{
     
    node<DataType>* p;
    while(first != NULL){
     
        p = first;
        first = first->next;
        delete p;
    }
}

template <class DataType>
node<DataType>* linkList<DataType>::getFirst()
{
     
    return first;
}

template <class DataType>
void linkList<DataType>::reversePrint(node<DataType>* p)
{
     
       first->next=NULL;
             while(p!=NULL)
             {
     
                 node<DataType>*q=p->next;
                 p->next=first->next;
                 first->next=p;
                 p=q;
             }
             node<DataType>*s=first->next;
             while(s!=NULL)
             {
     
                 cout<<s->data<<" ";
                 s=s->next;
             }

}
int main()
{
     
    linkList<int> L;
    node<int>* p = L.getFirst()->next;
    if(p == NULL)
        cout<<"Empty"<<endl;
    else
        L.reversePrint(p);
    L.~linkList();
    return 0;
}

8、删除单链表中大于minK且小于maxK的元素

已知单链表中各结点的元素值为整型且自增有序，设计算法删除单链表中大于minK且小于maxK的所有元素，并释放被删结点的存储空间。

/*删除单链表中大于minK且小于maxK的元素
已知单链表中各结点的元素值为整型且自增有序，
设计算法删除单链表中大于minK且小于maxK的所
有元素，并释放被删结点的存储空间
*/#include 
using namespace std;

typedef int DataType;
typedef struct node{
    DataType data;
    node* next;
}node;
node *first;

void init( )
{
    first = new node;
    first->next = NULL;
    node* rear = first;
    int length;
    cin>>length;
    for(int i=0;i<length;++i){
        DataType elem;
        cin>>elem;
        node* s = new node;
        s->data = elem;
        s->next = NULL;
        rear->next = s;
        rear = s;
    }
}
void deleteList(DataType minK,DataType maxk)
{
   node*p=first;
          node*q=p->next;
          while(q!=NULL)
          {
              if(q->data>minK&&q->data<maxk)
              {
                  p->next=q->next;
                  delete q;
                  q=p->next;
              }
              else{
               p=p->next;
               q=p->next;
              }
          }

}
void show( )
{
    node* p = first->next;
    if(p == NULL) cout<<"Empty";
    while(p != NULL){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
int main()
{
    init();
    DataType minK,maxK;
    cin>>minK>>maxK;
    deleteList(minK,maxK);
    show();
    return 0;
}

9、双循环链表是否对称

判断带头结点的双循环链表是否对称。

#include 
using namespace std;

typedef int DataType;
typedef struct node{
     
    DataType data;
    node* next,*prior;
}node;
node* first;

void init( )
{
     
    first = new node;
    first->next = NULL;
    first->prior = NULL;
    node* rear = first;
    DataType elem;
    while(cin>>elem){
     
        node* s = new node;
        s->data = elem;
        s->next = NULL;
        s->prior = rear;
        rear->next = s;
        rear = s;
    }
    rear->next = first;
    first->prior = rear;
}
bool equalDulList()
{
     
   node*p=first->next;
       node*q=first->prior;
       while(p!=q)
       {
     
           if(p->data!=q->data)
           {
     
               return false;
           }
           p=p->next;
           q=q->prior;
       }
       return true;

}
void show()
{
     
    node* p = first->next;
    while(p != first){
     
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}
int main()
{
     
    init();
    //show();
    bool res = equalDulList();
    if(res) cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
    return 0;
}