设单链表的表头指针为L，结点由data，next构成，设计算法判断该链表的全部n个字符是否中心对称。如xyx、xyyx -007

设单链表的表头指针为L，结点由data，next构成，设计算法判断该链表的全部n个字符是否中心对称。如xyx、xyyx

总结

算法思想：

​ 使用栈来判断链表中的数据是否对称。先让前一半元素依次进栈。在处理链表的后一半元素时，当访问到链表的一个元素后，就从链表中弹出一个元素。按循环后数组下标来判断，是否对称

代码编写注意点：

​ 1、数组下标从0开始，前一半元素下标是从0 <= i < n/2

​ 2、判断元素个数为奇数 n%2==1

代码

//设单链表的表头指针为L，结点由data，next构成，设计算法判断该链表的全部n个字符是否中心对称。如xyx、xyyx
#include <iostream>
using namespace std;

typedef struct LNode {
    char data;
    struct LNode* next;
}LNode, * LinkList;

//参考答案
int dc(LinkList L,int n){
    int i;
    char s[n/2];     //s为字符栈
    LNode *p=L->next;   //p为工作指针，指向待处理的当前元素
    for(i=0;i<n/2;i++){    //链表前一半元素进栈，注意由于是数组，下标从零开始。所以i<n/2
        s[i]=p->data;
        p=p->next;
    }
    i--;        //恢复最后的i值
    if(n%2==1)       //元素个数为奇数，移过中心点
        p=p->next;
    while(p!=NULL&&s[i]==p->data){
        i--;
        p=p->next;
    }
    if(i==-1)
        return 1;     //对称
    else
        return 0;     //不对称

}



//自己写的代码

bool dc(LinkList L, int n) {
    char* a = new char[n];
    int i = 0, j = n - 1;     //i,j 作为数组两端的工作指针
    LNode* p = L->next; //作为遍历单链表的工作指针
    int k=0;   //字符转移
    while (p != NULL) {
        a[k] = p->data;
        p = p->next;
        k++;
    }
    while (j - i > 0) {
        if (a[i] == a[j]) {
            i++;
            j--;
        }
        else {
            cout << "错误";
            return false;
        }
    }
    delete[] a;
    return true;
}

int main() {
    LinkList L;
    L = new LNode;
    L->next = NULL;
    int n = 3;
    LNode* a, * b, * c;
    a = new LNode;
    b = new LNode;
    c = new LNode;
    a->data = 'x';
    b->data = 'y';
    c->data = 'y';
    L->next=a;
    a->next=b;
    b->next=c;
    c->next = NULL;
    cout << dc(L, n) << endl;
    delete L;
    delete a;
    delete b;
    delete c;
    system("pause");
    return 0;
}