单向循环链表代码c语言

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

typedef struct ListNode ListNode;

ListNode* createListNode(int val) {
ListNode* node = (ListNode*)malloc(sizeof(ListNode));
node->val = val;
node->next = NULL;
return node;
}

ListNode* createLinkedList(int arr[], int n) {
if (n <= 0) {
return NULL;
}

ListNode* head = createListNode(arr[0]);
ListNode *p = head;
for (int i = 1; i < n; i++) {
p->next = createListNode(arr[i]);
p = p->next;
}
p->next = head;
return head;
}

相关问题

单向循环链表约瑟夫环c语言

单向循环链表是一种特殊的链表结构，其中最后一个节点的下一个节点指向的是第一个节点，形成了一个闭合的环形。在约瑟夫环（Josephus Problem）中，通常涉及到在一个循环数组或链表中按照特定步长删除元素的问题。比如，如果每过k步就删除一个元素，问题就是找到从给定起点开始经过多少步后轮到某个特定位置的人。

在C语言中实现单向循环链表和约瑟夫环的一个简单示例可能会包含以下几个步骤：

1. 定义结构体`Node`表示链表节点，包括数据`data`和指向下个节点的指针`next`，以及一个额外的指向前一个节点的指针`prev`，因为是循环链表。

typedef struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
} Node;

2. 创建循环链表，添加节点，并设置循环链接。

void createCircularList(Node** head, int n, ...) {
    Node* current = (Node*)malloc(sizeof(Node));
    current->data = ...; // 初始化第一个节点
    if (*head) {
        (*head)->prev = current;
        current->next = *head;
    } else {
        current->next = current;
    }
    *head = current;
    // 添加更多节点...
}

3. 实现约瑟夫环的核心算法，如`findJosephusPosition`函数，接受链表头、步长k和起始位置作为参数。

int findJosephusPosition(Node* head, int k, int start) {
    Node* slow = head;
    Node* fast = head;

    while (fast && fast->next != head) {
        slow = slow->next;
        fast = fast->next->next;
    }

    fast = head;
    for (int i = 0; i < start - 1; i++) {
        fast = fast->next;
    }

    while (fast != slow) {
        fast = fast->next;
        slow = slow->next;
    }

    return slow->data;
}

使用C语言编程实现1. 定义单向循环链表节点类型。 2..尾插法创建单向循环链表并返回尾指针。 3.定义打印输出单向循环链表节点。 4. 在main函数中编写测试 (1)分别创建循环链表La 和Lb

在C语言中，我们可以按照以下步骤来实现单向循环链表：

1. 定义单向循环链表节点类型（Node结构体）：

typedef struct Node {
    int data;        // 节点数据
    struct Node* next;  // 指向下一个节点的指针
} Node;

2. 尾插法创建单向循环链表并返回尾指针：

Node* createCircularList(int arr[], int size) {
    Node* head = NULL, *tail = NULL;
    for (int i = 0; i < size; i++) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = head;

        if (!head)
            head = tail = newNode;
        else
            tail->next = head, tail = newNode;
    }
    return head;
}

3. 定义打印输出单向循环链表节点：

void printCircularList(Node* node) {
    Node* temp = node;
    do {
        printf("%d ", temp->data);
        temp = temp->next;
    } while (temp != node);
}

4. 在`main`函数中编写测试示例：

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    Node* La = createCircularList(arr, size);

    // 打印链表La
    printf("List La: ");
    printCircularList(La);

    // 创建另一个循环链表Lb
    int arr2[] = {6, 7, 8, 9, 10};
    Node* Lb = createCircularList(arr2, size);

    // 打印链表Lb
    printf("\nList Lb: ");
    printCircularList(Lb);

    free(La);
    free(Lb);  // 释放内存

    return 0;
}

在这个例子中，我们首先创建了两个循环链表`La`和`Lb`，然后分别打印它们的内容。记得在程序结束时释放分配的内存。