给定一个双链表，编写一个函数实现将双链表反转。

给定一个双链表，可以使用迭代或递归的方式来实现其反转。这里我们通过迭代法来描述：

1. 定义两个指针，`prev` 和 `curr`，初始时都指向头节点（None 或空），`prev` 指向 `None`。
2. 当 `curr` 非空时，进行以下操作：
- 保存当前节点的下一个节点，即 `next_node = curr.next`。
- 更新当前节点的 `next` 指针，使其指向 `prev`，即将 `curr.next` 赋值为 `prev`。
- 将 `prev` 和 `curr` 向前移动一步，即 `prev = curr` 和 `curr = next_node`。
3. 迭代结束后，`prev` 就会成为新的头节点，因为每次迭代我们都改变了 `curr` 的 `next` 指针。

这是Python伪代码的一个例子：

def reverse_linked_list(head):
    prev = None
    curr = head
    while curr is not None:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return prev

相关问题

1. 将双向链表从给定的截断点分成两段，两段位置互换成为新链表，若是链表为A-B-C-D-E-F，指定节点C，那么新链表为C-D-E-F-A-B，用C语言编写函数ReGroup 实现此功能

ReGroup函数的实现如下：

#include <stdlib.h>

typedef struct node {
    int value;
    struct node* next;
    struct node* prev;
} Node;

Node* ReGroup(Node* head, Node* point) {
    if (head == NULL || point == NULL) {
        return NULL;
    }

    // 找到指定节点的前一个节点
    Node* prev = point->prev;

    // 如果指定节点是头结点，则不用重组
    if (prev == NULL) {
        return head;
    }

    // 将链表分为前半部分和后半部分
    prev->next = NULL;
    point->prev = NULL;

    // 反转后半部分
    Node* cur = point;
    while (cur->next != NULL) {
        Node* temp = cur->next;
        cur->next = cur->prev;
        cur->prev = temp;
        cur = temp;
    }
    cur->next = cur->prev;
    cur->prev = prev;

    // 交换前后两部分
    Node* tail = head;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    tail->next = point;
    point->prev = tail;

    return head;
}

在调用此函数时，传入原链表的头结点和指定节点的指针即可得到分组后的新链表的头结点。

用C语言编写一个算法函数，使用链栈或队列，判定给定的字符序列是否为回文，并验证。 提示：回文是指正读和反读均相同的字符序列。要有输入。

在C语言中，我们可以使用链栈（双向链表）或者队列来判断一个字符序列是否为回文。这里我会给出一个简单的链栈实现示例，因为链栈遍历过程更直观，可以轻松地从头开始逐个比较字符直到达到序列尾部。

#include <stdio.h>
#include <stdlib.h>

// 定义节点结构体
typedef struct Node {
    char data;
    struct Node* next;
    struct Node* prev;
} Node;

// 初始化链栈
Node* initStack() {
    return (Node*)malloc(sizeof(Node));
}

// 入栈
void push(Node** top, char c) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = c;
    newNode->next = *top;
    newNode->prev = NULL;
    if (*top != NULL) {
        (*top)->prev = newNode;
    }
    *top = newNode;
}

// 出栈并返回顶部元素
char pop(Node** top) {
    if (*top == NULL) {
        printf("Error: Stack is empty.\n");
        exit(1);
    }
    char data = (*top)->data;
    Node* temp = *top;
    *top = (*top)->next;
    free(temp);
    return data;
}

// 检查回文
int isPalindrome(char str[]) {
    Node* stackTop = initStack();
    for (int i = 0; str[i] != '\0'; i++) {
        push(&stackTop, str[i]);
    }

    // 反转字符串并与链栈顶元素对比
    int j = strlen(str) - 1;
    while (j >= 0 && stackTop != NULL) {
        if (str[j] != pop(&stackTop)) {
            return 0; // 不是回文
        }
        j--;
    }
    if (stackTop == NULL) {
        return 1; // 是回文
    } else {
        return 0; // 栈未空，说明不是回文
    }
}

int main() {
    char input[100];
    printf("Enter a string to check if it's a palindrome: ");
    fgets(input, sizeof(input), stdin);

    // 移除fgets添加的换行符
    input[strlen(input) - 1] = '\0';

    if (isPalindrome(input)) {
        printf("%s is a palindrome.\n", input);
    } else {
        printf("%s is not a palindrome.\n", input);
    }

    return 0;
}