一、链表的回文结构
思路：
找到链表的中间节点，然后逆置链表的后半部分，再一一遍历链表的前半部分和后半部分，判断是是否为回文结构。
快慢指针找到链表的中间节点
slow指针指向的就是中间节点
逆置链表后半部分
逆置链表后半部分
遍历链表前半部分和后半部分
如果left和right指向的数据不相等，就跳出循环，返回false；如果遍历到left或者right为NULL，数据都相等，那么链表具有回文结构，返回true。
这里如果是奇数个节点：
遍历结束后：
class PalindromeList {
public:
//找链表中间节点
ListNode* Listmid(ListNode* phead)
{
ListNode* fast, *slow;
fast=slow=phead;
while(fast && fast->next)
{
slow=slow->next;
fast=fast->next;
}
return slow;
}
//逆置
ListNode* reverse(ListNode* phead)
{
ListNode* l1,*l2,*l3;
l1=NULL;
l2=phead;
while(l2)
{
l3=l2->next;
l2->next=l1;
l1=l2;
l2=l3;
}
return l1;
}
bool chkPalindrome(ListNode* A) {
// write code here
//找到链表中间节点
ListNode* mid=Listmid(A);
//逆置后半部分
ListNode* phead = reverse(mid);
//比较
ListNode* left, *right;
left=A;
right=phead;
while(right && left)
{
if(right->val!=left->val)
{
return false;
}
left=left->next;
right=right->next;
}
return true;
}
};二、相交链表
判断两个链表是否相交，如果相交就返回相交节点，如果链表不相交，那就返回NULL；
思路：
先遍历两个链表，记录两个链表的节点个数；再同时遍历两个链表 ，让节点个数多的链表先往前走s（链表的节点个数差）；同时遍历两个链表，如果指向链表的指针相等，就返回当前节点；如果遍历链表结束后，都没有相等的节点，那就返回NULL。
typedef struct ListNode ListNode;
struct ListNode* getIntersectionNode(struct ListNode* headA,
struct ListNode* headB) {
if (headA == NULL) {
return NULL;
}
if (headB == NULL) {
return NULL;
}
int sizeA = 0, sizeB = 0;
ListNode *l1, *l2;
l1 = headA;
l2 = headB;
while (l1) {
sizeA++;
l1 = l1->next;
}
while (l2) {
sizeB++;
l2 = l2->next;
}
ListNode* shortList = headA;
ListNode* longList = headB;
int s = abs(sizeA - sizeB);
if (sizeA > sizeB) {
shortList = headB;
longList = headA;
}
while (s) {
s--;
longList = longList->next;
}
while (longList && shortList) {
if (longList == shortList) {
return longList;
}
longList = longList->next;
shortList = shortList->next;
}
return NULL;
}三、环形链表1
判断 链表中是否存在环，如果存在就返回true，如果不存在就返回false；
思路：快慢指针
定义两个指针fast和slow；遍历链表，fast每次向前走两步，slow每次向前走一步，如果链表存在环，fast与slow指针一定会相遇；如果遍历链表，fast或者fast->next为NULL，则链表不存在环。
根据题目所给示例来分析一下：
首先定义两个指针 fast slow
fast向前走两步，slow向前走一步
fast向前走两步，slow向前走一步
fast向前走两步，slow向前走一步
此时，fast和slow相遇，证明链表中存在环，返回true。
如果链表不存在环结构，遍历过程中fast或者fast->next指针会等于NULL，将这个作为结束条件即可。
typedef struct ListNode ListNode;
bool hasCycle(struct ListNode *head) {
ListNode* fast, *slow;
fast=slow=head;
while(fast && fast->next)
{
fast=fast->next->next;
slow=slow->next;
if(slow == fast)
{
return true;
}
}
return false;
}四、环形链表2
上面只是让我们判断链表是否带环，这道题让我们返回链表环的起始节点，如果不存在环就返回NULL。
思路：
使用快慢指针找到快慢指针的相遇节点；再定义两个指针从相遇节点和链表头结点开始遍历，两个指针相遇时的节点就是链表环的起始节点。
根据题目的示例来分析：
先找到链表快慢指针的相遇节点：
定义两个指针从链表头部和相遇节点开始遍历链表
遍历链表直到两个指针相遇
两个指针相遇，此时指针指向的节点就是链表环的起始节点。
typedef struct ListNode ListNode;
ListNode* hasCycle(struct ListNode *head) {
ListNode* fast, *slow;
fast=slow=head;
while(fast && fast->next)
{
fast=fast->next->next;
slow=slow->next;
if(slow == fast)
{
return slow;
}
}
return NULL;
}
struct ListNode *detectCycle(struct ListNode *head) {
//找到快慢指针相遇节点
ListNode* pos=hasCycle(head);
if(pos==NULL)
{
return NULL;
}
//从头结点和相遇节点开始遍历
ListNode* ptail=head;
while(1)
{
if(pos==ptail)
{
return pos;
}
pos=pos->next;
ptail=ptail->next;
}
}五、随机链表的复制
这里题目上提到了一个深拷贝
思路：
先在原链表的基础上创建节点，形成新的链表，再给链表节点的random指针赋值，最后断开新链表和原链表的连接即可。
深拷贝原链表
拷贝过后
给random指针赋值
断开新链表和原链表之前的连接
这样就深拷贝了原链表，返回新链表的头节点即可。
typedef struct Node Node;
// 创建节点
Node* BuyNode(int x) {
Node* newnode = (Node*)malloc(sizeof(Node));
newnode->next = newnode->random = NULL;
newnode->val = x;
return newnode;
}
// 深拷贝
void CopyList(Node** head) {
Node* ptail = *head;
Node* next = NULL;
while (ptail) {
next = ptail->next;
Node* newnode = BuyNode(ptail->val);
newnode->next = next;
ptail->next = newnode;
ptail = next;
}
}
void Connect(Node** head) {
Node* ptail = *head;
Node* copy = (*head)->next;
while (ptail) {
copy = ptail->next;
if (ptail->random)
copy->random = ptail->random->next;
ptail = copy->next;
}
}
struct Node* copyRandomList(struct Node* head) {
if (head == NULL)
{
return NULL;
}
// 深拷贝原链表
CopyList(&head);
// 连接random指针
Connect(&head);
// 断开链表
Node* ptail = head;
Node* newhead = head->next;
Node* copy = head->next;
while (ptail->next->next) {
ptail=copy->next;
copy->next = copy->next->next;
copy = copy->next;
}
return newhead;
}
