假设有一个带头节点的单链表，请设计算法判断该链表中的节点是否成等差关系

可以用一个变量记录链表中前两个节点的值的差，然后遍历整个链表，对于每个节点，判断它的值和前一个节点的值的差是否和之前记录的差相同。如果都相同，则说明链表中所有节点的值成等差关系；否则，说明不成等差关系。

具体实现可以参考以下代码：

def is_arithmetic_sequence(head):
    if not head or not head.next:
        # 链表为空或只有一个节点，一定成等差关系
        return True
    diff = head.next.val - head.val # 记录前两个节点的差
    curr = head.next.next # 从第三个节点开始遍历
    while curr:
        if curr.val - curr.next.val != diff:
            # 当前节点和前一个节点的差与之前的差不同，不成等差关系
            return False
        curr = curr.next
    return True

其中，`head`为链表的头节点。如果该链表中的所有节点成等差关系，则返回`True`；否则，返回`False`。

相关问题

C语言实现假设有一个带头结点的单链表，请设计算法判断该链表中的结点是否成等差关系

算法思路：

1. 判断链表是否为空，如果为空则返回false；

2. 初始化三个指针，分别指向头节点、第一个节点和第二个节点；

3. 判断链表长度是否小于等于2，如果是则返回true；

4. 循环遍历链表，判断每个节点与它前一个节点和前两个节点的差值是否相等，如果不相等则返回false；

5. 遍历结束后，如果没有返回false，则链表成等差关系，返回true。

算法实现：

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

#define true 1
#define false 0

typedef int bool;
typedef struct Node {
    int data;           // 数据域
    struct Node* next;  // 指针域
} Node, * LinkList;

bool isArithmetic(LinkList L) {
    if (L == NULL || L->next == NULL) {  // 链表为空或只有一个节点
        return true;
    }

    Node* p = L->next;      // 指向第一个节点
    Node* q = p->next;      // 指向第二个节点
    int diff = q->data - p->data;   // 计算前两个节点的差值

    while (q) {
        if (q->data - p->data != diff) {  // 判断当前节点与前两个节点的差值是否相等
            return false;
        }
        p = q;
        q = q->next;
    }
    return true;
}

int main() {
    LinkList L = (LinkList) malloc(sizeof(Node));
    L->next = NULL;

    Node* tail;     // 指向尾节点的指针
    tail = L;

    for (int i = 1; i <= 5; i++) {   // 构造等差数列
        Node* newNode = (Node*) malloc(sizeof(Node));
        newNode->data = i * 2;
        newNode->next = NULL;

        tail->next = newNode;
        tail = newNode;
    }

    bool res = isArithmetic(L);
    if (res) {
        printf("链表成等差关系\n");
    } else {
        printf("链表不成等差关系\n");
    }

    return 0;
}

假设有一个带头结点的单链表，请设计算法判断该链表中的结点是否成等差关系，即假设各个元素依次为a1，a2，…，an，判断a(i+1)-a(i)=a(i)-a(i-1)是否成立，其中i满足 2≤i≤n-1

算法思路：

遍历链表，对于每一个结点，判断其前后两个结点的差值是否相等，若相等则继续遍历下一个结点，若不相等则说明该链表不成等差关系。

注意头结点不参与判断。

算法步骤：

1. 定义指针p和q，将p指向头结点的下一个结点，将q指向p的下一个结点。

2. 遍历链表，对于每一个结点p，判断其前后两个结点的差值是否相等，即判断(q->data - p->data)是否等于(p->data - (p-1)->data)，若相等则继续遍历下一个结点，否则返回false。

3. 若遍历到尾结点后仍未出现不相等的情况，则返回true。

算法实现：

bool isArithmeticProgression(LinkList L){
LNode *p = L->next, *q = p->next;
while(q != NULL){
if(q->next != NULL && (q->data - p->data) != (p->data - (p->next)->data)){
return false;
}
p = p->next;
q = q->next;
}
return true;
}