数据结构课设个人（十）：判断单链表的对称性

问题描述 :

设带头结点的单链表的头指针为head，结点结构由data和next两个域构成，其中data域为字符型。在使用单链表ADT的基础上，设计一算法判断该链表的前n个字符是否中心对称。例如 xyx, xyyx都是中心对称。

参考函数原型：

//判断单链表的前n个结点是否中心对称

template<class ElemType>

bool Judge_Symmetry( LinkList<ElemType> &L, int num );

输入说明 :

第一行：顺序表A的数据元素的数据类型标记（0：int，1：double，2：char，3：string）

第二行：单链表A的数据元素（数据元素之间以空格分隔）

第三行：待判断对称性的链表长度

输出说明 :

如第一行输入值为0、1、2、3之外的值，直接输出“err”

否则：

第一行：单链表A的遍历结果（数据元素之间以"->"分隔）

空行

第三行：true（对称）

false（不对称）

输入范例 :

2
10
A B C D E E D C B A X Y

输出范例：

A->B->C->D->E->E->D->C->B->A->X->Y

true

代码实现：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <stdlib.h>
#include <cmath>
#include <vector>
#include <sstream>   //用于ostringstream、istringstream、stringstream这三个类
#include<stack>
#include<vector>
#include<queue>
#include<list>
using namespace std;
template<class ElemType>
struct LinkNode
{
    ElemType data;
    LinkNode<ElemType> *next;
    LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;}
    LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL)
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};
template <class ElemType>
class LinkList:public LinkNode<ElemType>
{
   private:
      LinkNode<ElemType>*head;   // 头指针
      LinkNode<ElemType>*tail;   // 尾指针
   public:
      //无参数的构造函数
      LinkList<ElemType>(){head = new LinkNode<ElemType>; head->next=NULL;tail =head;}
      //带参数的构造函数
      LinkList(const ElemType &item)
      {
          head = new LinkNode<ElemType>;
           LinkNode<ElemType>*p=new LinkNode<ElemType>;
           p->data=item;
          head->next=p;
          tail = p;
      }
      //析构函数
      ~LinkList(){delete head;}
      //重载函数:赋值
      //返回链表的长度
      int ListLength() const;
      //获取链表头指针
      LinkNode<ElemType>* GetHead() const{ return head;}
      //获取链表尾指针
      LinkNode<ElemType>* GetTail() const{ return tail;}
      //设置链表头指针
      void SetHead(LinkNode<ElemType>*p){ head = p;}
      //设置链表尾指针
      void SetTail(LinkNode<ElemType>*p){ tail = p;}
       //遍历链表
        bool ListTraverse() const{
      LinkNode<ElemType>*p=head->next;
      if(p){ cout<<p->data;  p=p->next;}
      while(p){
        cout<<"->"<<p->data;
        p=p->next;
      }
      }
      void Insert_tail(ElemType num)//表尾插入法动态生成链表
      {
          LinkNode<ElemType>* p = new LinkNode<ElemType>(num);
          tail->next=p;
           tail=p;
      }
};
template<class ElemType>
void createlinklist( LinkList<ElemType> &A){
    ElemType num;
    while(cin>>num)
        A.Insert_tail(num);
}
//判断单链表的前n个结点是否中心对称
template<class ElemType>
bool Judge_Symmetry( LinkList<ElemType> &L, int num ){
    L.ListTraverse();
    cout<<endl<<endl;
    LinkNode<ElemType>* findhead=L.GetHead()->next;
    vector<ElemType>A;
    int half=num/2;
    for(int i=0;i<half;i++){  //前一半保存到数组中
         A.push_back(findhead->data);
         findhead=findhead->next;
    }//出for循环时，findhead指向第half+1各元素;
    if(num%2==1)//待判断的单链表长度为奇数
        findhead=findhead->next;
    int flag=1;
    for(int i=half-1;i>=0;i--){
        if(findhead->data!=A[i])  { flag=0;break; }
        findhead=findhead->next;
    }
    if(flag==1)cout<<"true";
    else  cout<<"false";
    return flag;
}
int main()
{
    int kd;
    cin>>kd;
    cin.ignore();
    if(kd==0){
        LinkList<int>A;
        int num;
        cin>>num;
        createlinklist(A);
       Judge_Symmetry( A, num);
    }
    else if(kd==1){
           LinkList<double>A;
        int num;
        cin>>num;
        createlinklist(A);
         Judge_Symmetry( A, num);
    }
    else if(kd==2){
            LinkList<char>A;
        int num;
        cin>>num;
        createlinklist(A);
      //  A.ListTraverse();
        Judge_Symmetry( A, num);
    }
     else if(kd==3){
            LinkList<string>A;
        int num;
        cin>>num;
        createlinklist(A);
       Judge_Symmetry( A, num);
    }
    else
        cout<<"err"<<endl;
    return 0;
}