数据结构之链表（高级应用）-优快云博客

本文链接：https://blog.youkuaiyun.com/FENGCHEN____/article/details/139250829

基本的算法实践在上一篇博文，这篇博文向大家详细展示一下数据结构的高级应用，可能有些难，但这是重点，实用性很强，而且用的好往往事半功倍，想获得力量吗，开整：

我把他们分为这几块：

链表反转：反转单向链表或双向链表。
检测链表环：判断链表中是否存在环。
合并两个有序链表：将两个有序链表合并成一个有序链表。
从链表中删除重复节点：删除链表中的重复节点。
链表排序：对链表进行排序（例如归并排序）。

下面一一用代码给出展示，代码完整，可以直接复制下来自己摸索，自己修改执行，也可以自己保留复习，话不多说，代码见：

C语言实现单向链表的高级操作

1. 链表反转

ListNode* reverse_list(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* current = head;
    ListNode* next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

2. 检测链表环

int has_cycle(ListNode* head) {
    ListNode *slow = head, *fast = head;
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) {
            return 1;
        }
    }
    return 0;
}

3. 合并两个有序链表

ListNode* merge_sorted_lists(ListNode* l1, ListNode* l2) {
    if (!l1) return l2;
    if (!l2) return l1;
    if (l1->value < l2->value) {
        l1->next = merge_sorted_lists(l1->next, l2);
        return l1;
    } else {
        l2->next = merge_sorted_lists(l1, l2->next);
        return l2;
    }
}

4. 从链表中删除重复节点

void remove_duplicates(ListNode* head) {
    ListNode* current = head;
    while (current != NULL && current->next != NULL) {
        if (current->value == current->next->value) {
            ListNode* next_next = current->next->next;
            free(current->next);
            current->next = next_next;
        } else {
            current = current->next;
        }
    }
}

5. 链表排序（归并排序）

ListNode* sorted_merge(ListNode* a, ListNode* b) {
    if (!a) return b;
    if (!b) return a;
    if (a->value <= b->value) {
        a->next = sorted_merge(a->next, b);
        return a;
    } else {
        b->next = sorted_merge(a, b->next);
        return b;
    }
}

void front_back_split(ListNode* source, ListNode** front, ListNode** back) {
    ListNode* fast = source->next;
    ListNode* slow = source;
    while (fast != NULL) {
        fast = fast->next;
        if (fast != NULL) {
            slow = slow->next;
            fast = fast->next;
        }
    }
    *front = source;
    *back = slow->next;
    slow->next = NULL;
}

void merge_sort(ListNode** head_ref) {
    ListNode* head = *head_ref;
    if ((head == NULL) || (head->next == NULL)) {
        return;
    }
    ListNode* a;
    ListNode* b;
    front_back_split(head, &a, &b);
    merge_sort(&a);
    merge_sort(&b);
    *head_ref = sorted_merge(a, b);
}

C++实现双向链表的高级操作

1. 链表反转

void reverse_list() {
    DoubleListNode *temp = nullptr;
    DoubleListNode *current = head;
    while (current != nullptr) {
        temp = current->prev;
        current->prev = current->next;
        current->next = temp;
        current = current->prev;
    }
    if (temp != nullptr) {
        head = temp->prev;
    }
}

2. 检测链表环

bool has_cycle() {
    DoubleListNode *slow = head, *fast = head;
    while (fast != nullptr && fast->next != nullptr) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) {
            return true;
        }
    }
    return false;
}

3. 合并两个有序链表

DoubleListNode* merge_sorted_lists(DoubleListNode* l1, DoubleListNode* l2) {
    if (!l1) return l2;
    if (!l2) return l1;
    if (l1->value < l2->value) {
        l1->next = merge_sorted_lists(l1->next, l2);
        if (l1->next != nullptr) {
            l1->next->prev = l1;
        }
        l1->prev = nullptr;
        return l1;
    } else {
        l2->next = merge_sorted_lists(l1, l2->next);
        if (l2->next != nullptr) {
            l2->next->prev = l2;
        }
        l2->prev = nullptr;
        return l2;
    }
}

4. 从链表中删除重复节点

void remove_duplicates() {
    DoubleListNode* current = head;
    while (current != nullptr) {
        DoubleListNode* runner = current->next;
        while (runner != nullptr) {
            if (current->value == runner->value) {
                DoubleListNode* next = runner->next;
                if (runner->prev) {
                    runner->prev->next = runner->next;
                }
                if (runner->next) {
                    runner->next->prev = runner->prev;
                }
                delete runner;
                runner = next;
            } else {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

5. 链表排序（归并排序）

DoubleListNode* sorted_merge(DoubleListNode* a, DoubleListNode* b) {
    if (!a) return b;
    if (!b) return a;
    if (a->value <= b->value) {
        a->next = sorted_merge(a->next, b);
        a->next->prev = a;
        a->prev = nullptr;
        return a;
    } else {
        b->next = sorted_merge(a, b->next);
        b->next->prev = b;
        b->prev = nullptr;
        return b;
    }
}

void split(DoubleListNode* source, DoubleListNode** front, DoubleListNode** back) {
    DoubleListNode* fast = source->next;
    DoubleListNode* slow = source;
    while (fast != nullptr) {
        fast = fast->next;
        if (fast != nullptr) {
            slow = slow->next;
            fast = fast->next;
        }
    }
    *front = source;
    *back = slow->next;
    slow->next = nullptr;
}

void merge_sort(DoubleListNode** head_ref) {
    DoubleListNode* head = *head_ref;
    if ((head == nullptr) || (head->next == nullptr)) {
        return;
    }
    DoubleListNode* a;
    DoubleListNode* b;
    split(head, &a, &b);
    merge_sort(&a);
    merge_sort(&b);
    *head_ref = sorted_merge(a, b);
}

是不是发现了一个尽分享干货的博主，创作属实不易，希望大家珍惜！