手搓单链表

list.c

#define _CRT_SECURE_NO_WARNIGNS
#include<stdio.h>
#include<stdbool.h>
typedef struct node_s {
    int data;
    struct node_s* next;
} Node;

void add_before_head(Node** plist, int data) {
    // 创建结点
    Node* newNode = malloc(sizeof(Node));
    if (!newNode) {
        printf("Error: malloc failed in add_before_head.\n");
        exit(1);
    }
    // 初始化结点
    newNode->data = data;
    // 头插法
    newNode->next = *plist;
    *plist = newNode;
}

void display_list(Node* list) {
    Node* curr = list;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

Node* search_list(Node* list, int val) {
    Node* curr = list;
    while (curr != NULL) {
        if (curr->data == val) {
            return curr;
        }
        curr = curr->next;
    }
    return NULL;
}

void free_list(Node* list) {
    Node* curr = list;
    while (curr != NULL) {
        Node* next = curr->next;
        free(curr);
        curr = next;
    }
}

int middleElement(Node* list) {
    Node* curr = list;
    int n = 0;
    while (curr) {
        n++;
        curr = curr->next;
    }

    curr = list;
    for (int i = 0; i < n / 2; i++) {
        curr = curr->next;
    }
    return curr->data;
}
// 方式二
int middleElement2(Node* list) {
    Node* slow = list;
    Node* fast = list;
    // fast == NULL || fast->next == NULL
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
    }

    return slow->data;
}


bool hasCircle(Node* list) {
    Node* fast = list;
    Node* slow = list;
    do {
        // 如果 fast 到达了链表的末尾
        if (fast == NULL || fast->next == NULL) {
            return false;
        }
        fast = fast->next->next;
        slow = slow->next;
    } while (fast != slow);
    // 循环结束: fast == slow, 说明链表有环
    return true;
}


Node* reverse(Node* list) {
    Node* prev = NULL;
    Node* curr = list;

    while (curr != NULL) {
        // 保留curr的后继结点
        Node* next = curr->next;
        // 反转当前结点
        curr->next = prev;
        // 更新prev和curr
        prev = curr;
        curr = next;
    }
    //循环结束: curr == NULL, prev指向反转后的第一个结点
    return prev;
}

// 递归方式
Node* reverse2(Node* list) {
    // 边界条件
    if (list == NULL || list->next == NULL) {
        return list;
    }
    // 递归公式
    Node* result = reverse(list->next);
    list->next->next = list;
    list->next = NULL;

    return result;
}

Node* merge_two_lists(Node* list1, Node* list2) {
    Node dummynode = {0,NULL};
    Node* curr1 = list1;
    Node* curr2 = list2;
    Node* tail = &dummynode;
    while(curr1 != NULL && curr2!= NULL){
        if (curr1->data < curr2->data) {
            tail->next = curr1;
            tail = curr1;
            curr1 = curr1->next;
        }
        else {
            tail->next = curr2;
            tail = curr2;
            curr2 = curr2->next;
        }
        
    }
    tail->next = curr1 ? curr1 : curr2;
    return dummynode.next;
}

int main() {
    Node l1p3 = { 5,NULL };
    Node l1p2 = { 3,&l1p3 };
    Node l1p1 = { 1,&l1p2 };
    
    Node l2p3 = { 6,NULL };
    Node l2p2 = { 4,&l2p3 };
    Node l2p1 = { 2,&l2p2 };
    Node* new_list = merge_two_lists(&l1p1, &l2p1);
    Node* curr = new_list;
    display_list(curr);
    return 0;
}