基础数据结构之如何判断一个单链表是回文链表

一、算法思想

1）设置节点指针，依次遍历链表，将链表的一半入栈

2）判断链表的奇偶性，如果是奇数链表，我们在遍历的时候，要记住节点指针要多往后走一步，如果是偶数链表，则不需要

3）在栈里面的一半数据依次出栈，和单链表的指针依次向后走一步，两者对应的数据依次比较，直到栈为空和链表指针指向空

4）如果每次对应的值相等，则返回true,否则返回false

二、代码实现

.h头文件函数声明（进行两个头文件声明，我这里合并到一起了，大家可将其分开，一个为Link.h"，另外一个为"list_stack.h"

#pragma once
typedef int ELEM_TYPE;

//链表
typedef struct Node {
	ELEM_TYPE data;//数据域（保存数据的有效值）
	struct Node* next;//指针域（保存下一个有效结点的地址）
}Node,*PNode;

//初始化
void Init_list(struct Node* plist);

//尾插
bool Insert_tail(PNode plist, ELEM_TYPE val);

//打印
void Show(PNode plist);

//栈
typedef struct Stack {
	ELEM_TYPE* base;//存储空间基址（用来接收malloc返回在堆上申请的连续空间块的起始地址）
	int top;//当前有效长度，且可以表示下一个待插入位置的下标
	int stacksize;//当前总空间大小（以格子数为单位）
}Stack, *Pstack;

//初始化

void Init_stack(struct Stack *st);

//入栈

bool Push(struct Stack* st,ELEM_TYPE val);

//出栈

bool Pop(struct Stack* st);

//获取栈顶元素值

ELEM_TYPE Top(struct Stack* st);

//判空

bool Is_full(struct Stack* st);

//判满

bool Is_empty(struct Stack* st);

//获取有效值个数
int Getlength(PNode plist);

.cpp 栈和单链表基本代码实现

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Link.h"
#include"list_stack.h"
//栈的代码实现
//初始化
void Init_LStack(struct LStack* pstack) {
	assert(pstack != NULL);
	pstack->next = NULL;
}

//入栈（相当于单链表的头插）
bool push(struct LStack* pstack, ELEM_TYPE val) {
	assert(pstack != NULL);
	struct LStack* snewnode = (struct LStack*)malloc(sizeof(LStack));
	snewnode->data=val;
	snewnode->next = pstack->next;
	pstack->next = snewnode;
	return true;
}

//出栈（相当于单链表头删）
bool Pop(struct LStack* pstack) {
	assert(pstack != NULL);
		if (Is_Empty(pstack)) {
		return false;
	}
	struct LStack* p = pstack->next;
	pstack->next = p->next;
	free(p);
	return true;
}

//获取栈顶元素值 //不能删除
ELEM_TYPE Top(struct LStack* pstack) {
	assert(pstack != NULL);
	struct LStack* p = pstack->next;
	ELEM_TYPE temp = p->data;
	return temp;
}

//判空
bool Is_Empty(struct LStack* pstack) {
	assert(pstack != NULL);
	if (pstack->next = NULL) {
		return true; 
	}
	return false;
}

//单链表的代码实现
//初始化
void Init_list(struct Node* plist) {
	//1.判断plist是否为空地址
	assert(plist !=NULL);
	//plist->data; //头结点的数据域不使用
	plist->next = NULL;
}
//尾插
bool Insert_tail(PNode plist, ELEM_TYPE val) {
	assert(plist != NULL);
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//pnewnode->next = NULL;//这行代码可以省略，也可以留下
	struct Node* p = plist;//这里p指向头节点，还是指向第一个有效节点，下面会总结
	for (; p->next != NULL; p = p->next);
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}
//打印
void Show(PNode plist) {
	assert(plist != NULL);
	struct Node* p = plist->next;
	for (; p != NULL; p = p->next) {
		printf("%d ",p->data);
	}
	printf("\n");
}

//获取有效长度的个数
int Getlength(PNode plist) {
	assert(plist != NULL);
	int count = 0;
	struct Node* p = plist->next;
	for (; p != NULL; p = p->next) {
		count++;
	}
	return count;
}

核心代码

//判断一个单链表是否回文链表
bool Is_palindrome(struct Node* plist) {
	struct LStack head;
	Init_LStack(&head);
	struct Node* p = plist->next;
	int length = Getlength(plist);//获取有效长度的值
	
	for (int i = 0; i < length /2; i++) {//将单链表一半的数据入栈
		push(&head, p->data);
		p = p->next;
	}
	
	if (length % 2 != 0) {//如果为奇数，继续向后走一步
		p = p->next;
	}
	
	while (p != NULL && head.next != NULL) {//将栈中元素与单链表中的元素依次进行对比
		int top = Top(&head);
		if (top != p->data) { //如果对应的值不相同，则返回false
			return false;
		}
		Pop(&head);
		p = p->next;
	}
	return true;
}

main测试代码

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Link.h"
#include"list_stack.h"

int main() {
	struct Node read;
	Init_list(&read);
	Insert_tail(&read,1);
	Insert_tail(&read, 2);
	Insert_tail(&read, 3);
	Insert_tail(&read, 2);
	Insert_tail(&read, 2);

	int tag = Is_palindrome(&read);
	if (tag) {
		printf("是回文\n");
	}
	else {
		printf("不是回文\n");
	}
}