算法【链表】 | 【链表回文】

一、链表回文

1.1 步骤

> 方法1：将链表的内容压入栈内，在将栈的元素依次弹出对比；
> 方法2：使用快慢指针，当快指针走到结束时，慢指针走到一半。此时将后半部分的链表放入链表内，
		在与前半部分进行对比；
> 方法3：不适用额外的数据结构。使用快慢指针，后将后面的链表进行逆序，与前半部分对比，对比完成后再将链表
		恢复；

1.2 代码分块

代码

/*----------------------------------------------------------------------
	> File Name: palindromeBystack.cpp
	> Author: Jxiepc
	> Mail: Jxiepc
	> Created Time: Sun 30 Jan 2022 10:39:04 AM CST
----------------------------------------------------------------------*/

/** 
 * 判断一个链表是否位回文结构
 * 若链表长度为N，时间复杂度为O(N)，额外空间复杂度为O(1)
 * */
#include <iostream>
#include <string>
#include <stack>

struct linknode{
    int val;
    struct linknode* next;
};

/** 第一种方法：将链表的内容压入栈 */
bool wayByStack (struct linknode *head) {
    std::stack<int> s;
    struct linknode *p = head;
    /** 将链表的内容压入栈内 */
    while(p->next != NULL) {
        p = p->next;
        s.push(p->val);
    }

    /** 匹配 */
    while(head->next != NULL) {
        head = head->next;
        std::cout << head->val << "-" << s.top() << std::endl;
        if(head->val != s.top()) {
           return false;
        }
        s.pop();
    }

    return true;
}


/** 取后半部分压入栈内 */
bool wayByStack_half(struct linknode *head) {
    std::stack<int> s;

    struct linknode *half = head->next;
    struct linknode *cur = head;

    /** 获取链表中间的位置 */
    while(cur->next != NULL && cur->next->next != NULL) {
        half = half->next;
        cur = cur->next->next;
    }

    /** 将后半部分的链表 */
    while(half != NULL) {
        s.push(half->val);
        half = half->next;
    }

    /** 匹配 */
    while(!s.empty()) {
        std::cout << head->val << "-" << s.top() << std::endl;
        head = head->next;
        if(s.top() != head->val)
            return false;
        s.pop();
    }

    return true;
}

/** 将右边的链表逆序与前半部分进行匹配 */
bool wayByMinSpace(struct linknode *head) {
    struct linknode *half = head;
    struct linknode *r = head;

    /** 将获取到左边区域的最后一个（中间的前一个） */
    while(r->next != NULL && r->next->next != NULL) {
        half = half->next;
        r = r->next->next;
    }

    r = half->next;        // 中间
    half->next = NULL;
    struct linknode* r_one = NULL;

    /** 变量将右边的区域倒序 */
    while(r != NULL) {
        r_one = r->next;   
        r->next = half;   
        half = r;  // 将half的指针指向r         
        r = r_one;  // 将r的指针指向r_one
    }

    r_one = half; // 存储最后一个点，用于后续将链表恢复  
    r = head;   
    bool res = true;
    

    // 匹配
    while(half->next != NULL && r->next != NULL) {
        r = r->next;
        std::cout << half->val << "=" << r->val << std::endl;
        if(half->val != r->val) {
            res = false;
            break;
        }
        half = half->next;
    }

    half = r_one->next;
    r_one->next = NULL;

    while(half != NULL) {
        r = half->next;
        half->next = r_one;
        r_one = half;
        half = r;
    } 
    
    while(r_one != NULL) {
        std::cout << r_one->val << std::endl;
        r_one = r_one->next;
        
    }

    return res;
}

int main(int argc, char* argv[])
{
    int n;
    std::cout << "请输入要链表个数：";
    std::cin >> n;
    struct linknode* head = new linknode[n];
    head->next = NULL;

    for(int i=0 ; i<n; ++i) {
        int x;
        std::cin >> x;
        struct linknode* s = new linknode;
        s->val = x;
        s->next = head->next;
        head->next = s;
    }

    //std::string ret = wayByStack(head) == 1 ? "是回文数" : "不是回文数";
    //std::string ret = wayByStack_half(head) == 1 ? "是回文数" : "不是回文数";
    std::string ret = wayByMinSpace(head) == 1 ? "是回文数" : "不是回文数"; 
    std::cout << ret << std::endl; 

    return 0;
}