数据结构 链表

最新推荐文章于 2024-09-11 15:59:47 发布
最新推荐文章于 2024-09-11 15:59:47 发布
阅读量246 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/K_A_Irving/article/details/81128349
版权

程序代码：

LinkList.h文件：
//防止重定义，与下面#endif对应
#ifndef __LINKLIST_H__
#define __LINKLIST_H__
//整个工程所需要的头文件
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <assert.h>
typedef int DataType;//类型重命名，为了方便修改顺序表中元素的类型，在这改一次就可以，不用每个地方都修改

typedef struct Node
{
    DataType data;
    struct Node* next;
}Node, *pNode, List, *pList;//结构体定义
//单链表能实现的功能

//创建一个节点
pNode BuyNode(DataType d);
//初始化链表
void InitLinkList(pList* pplist);
//销毁链表
void DestroyLinkList(pList* pplist);
//打印链表
void PrintLinkList(pList plist);
//尾部插入元素
void PushBack(pList* pplist, DataType d);
//尾部删除元素
void PopBack(pList* pplist);
//头部插入元素
void PushFront(pList* pplist, DataType d);
//头部删除元素
void PopFront(pList *pplist);
//查找元素
pNode Find(pList plist, DataType d);
//在指定位置之前插入一个值
void Insert(pList* pplist, pNode pos, DataType d);
//删除指定位置的元素
void Erase(pList* pplist, pNode pos);
//删除指定元素
void Remove(pList* pplist, DataType d);
//删除所有指定元素
void RemoveAll(pList* pplist, DataType d);
//链表长度
int GetListLength(pList plist);

//链表面试题：
//1.从尾到头打印单项链表
void PrintTailToHead_R(pList plist);
void PrintTailToHead(pList plist);
//2.删除一个无头单项链表的非尾节点（不能遍历链表）
void EraseNotTailNode(pNode pos);
//3.在无头单项链表的一个节点前插入一个节点（不能遍历链表）
void InsertNotTailNode(pNode pos, DataType d);
//4.单链表实现约瑟夫环（JosephCircle）
pNode JosephCircle(pNode plist, const int M);
//5.逆置/反转单链表
void ReverseList(pList *pplist);//三个指针
pNode ReverseList_PF(pList plist);//头插法
//6.单链表排序（冒泡排序&快速排序）
void BubbleSort(pNode* pplist);
//7.合并两个有序链表，合并后依然有序
pNode MergeOrderList(pList plist1, pList plist2);
//8.查找单链表的中间节点，要求只能遍历一次链表
pNode FindMiddleNode(pNode plist);
//9.查找单链表的倒数第K个节点，要求只能遍历一次链表
pNode FindInverseKNode(pNode plist, const int K);
//10.删除链表的倒数第K个节点
void DeleteInverseKNode(pNode* pplist, const int K);
//11.判断单链表是否带环？若带环，求环的长度？求环的入口？
pNode IsListCircle(pNode plist);
int ListCiecleLen(pNode meet);
pNode ListCircleEnter(pNode plist, pNode meet);
//  并计算每个算法的时间复杂度&空间复杂度

//12.判断两个链表是否相交，若相交，求交点（假设链表不带环）
int IsListCross(pNode plist1, pNode plist2);
pNode ListCrossPoint(pNode plist1, pNode plist2);
//13.判断两个链表是否相交，若相交，求交点（假设链表可能带环）【升级版】
int IsListCross_C(pNode plist1, pNode plist2);
pNode ListCrossPoint_C(pNode plist1, pNode plist2);
//14.复杂链表的复制。（复杂链表：一个链表的每个节点，有一个指向next指针指向的下一个节点，
//  还有一个random指针指向这个链表中的一个随机节点或者NULL）现在要求实现复制
//  这个链表，返回复制后的新链表
pNode CopyComplexList(pNode plist);
//15.求两个已排序单链表中相同的数据。
void UnionSet(pNode l1, pNode l2);
//与最前面#ifndef相对应
#endif //__LINKLIST_H__
LinkList.c文件（对前面用到的所有函数进行定义）
//头文件
#define _CRT_SECURE_NO_WARNINGS 1

#include "LinkList.h"
//创建节点
pNode BuyNode(DataType d)
{
    pNode node = malloc(sizeof(Node));
    node->data = d;
    node->next = NULL;
    return node;
}
//初始化链表
void InitLinkList(pList* pplist)
{
    assert(pplist);

    *pplist = NULL;
}
//摧毁链表
void DestroyLinkList(pList* pplist)
{
    assert(pplist);

    pNode cur = *pplist;
    pNode del = cur;

    while (cur)
    {
        del = cur;
        cur = cur->next;
        free(del);
        del = NULL;
    }

    *pplist = NULL;
}
//打印链表
void PrintLinkList(pList plist)
{
    pNode temp = plist;

    while (temp)
    {
        printf("%d-->", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}
//尾部插入元素
void PushBack(pList* pplist, DataType d)
{
    assert(pplist);

    pNode NewNode = BuyNode(d);

    if (*pplist == NULL)
    {
        *pplist = NewNode;
    }
    else
    {
        pNode cur = *pplist;

        while (cur->next)
        {
            cur = cur->next;
        }

        cur->next = NewNode;
    }
}
//尾部删除元素
void PopBack(pList* pplist)
{
    assert(pplist);

    if (*pplist == NULL)
    {
        return;
    }

    if ((*pplist)->next == NULL)
    {
        free(*pplist);
        *pplist = NULL;
        return;
    }

    pNode cur = *pplist;

    while (cur->next->next != NULL)
    {
        cur = cur->next;
    }
    free(cur->next);
    cur->next = NULL;
}
//头部插入元素
void PushFront(pList* pplist, DataType d)
{
    assert(pplist);

    pNode NewNode = BuyNode(d);

    NewNode->next = *pplist;
    *pplist = NewNode;
}
//头部删除元素
void PopFront(pList *pplist)
{
    assert(pplist);

    if (*pplist == NULL)
    {
        return;
    }

    pNode del = *pplist;
    *pplist = del->next;
    free(del);
    del = NULL;
}
//查找元素
pNode Find(pList plist, DataType d)
{
    pNode cur = plist;

    while (cur && (cur->data != d))
    {
        cur = cur->next;
    }

    if (cur != NULL)
    {
        return cur;
    }
}
//在指定位置之前插入元素
void Insert(pList* pplist, pNode pos, DataType d)
{
    assert(pplist);
    assert(pos);
    if (*pplist == NULL)
    {
        return;
    }

    if (*pplist == pos)
    {
        PushFront(pplist, d);
    }

    pNode cur = *pplist;
    pNode NewNode = BuyNode(d);

    while (cur && (cur->next != pos))
    {
        cur = cur->next;
    }

    if (cur != NULL)
    {
        cur->next = NewNode;
        NewNode->next = pos;
    }
}
//删除指定位置元素
void Erase(pList* pplist, pNode pos)
{
    assert(pplist);
    assert(pos);
    if (*pplist == NULL)
    {
        return;
    }

    if (*pplist == pos)
    {
        PopFront(&pplist);
    }

    pNode cur = *pplist;
    while (cur && (cur->next != pos))
    {
        cur = cur->next;
    }

    if (cur != NULL)
    {
        cur->next = pos->next;
        free(pos);
        pos = NULL;
    }

}
//删除指定元素
void Remove(pList* pplist, DataType d)
{
    assert(pplist);

    if (*pplist == NULL)
    {
        return;
    }

    if ((*pplist)->data == d)
    {
        PopFront(pplist);
    }
    else
    {
        pNode cur = *pplist;
        pNode temp = NULL;

        while (cur && (cur->data != d))
        {
            temp = cur;
            cur = cur->next;
        }

        if (cur != NULL)
        {
            temp->next = cur->next;
            free(cur);
            cur = NULL;
        }
    }
}
//输出所有指定元素
void RemoveAll(pList* pplist, DataType d)
{
    assert(pplist);

    if (*pplist == NULL)
    {
        return;
    }

    pNode cur = *pplist;
    pNode temp = *pplist;

    while (cur)
    {
        if ((*pplist)->data == d)
        {
            PopFront(pplist);
            cur = *pplist;
            temp = *pplist;
        }
        else
        {
            if (cur->data == d)
            {
                temp->next = cur->next;
                free(cur);
                cur = temp->next;
            }
            else
            {
                temp = cur;
                cur = cur->next;
            }
        }
    }
}
//链表长度
int GetListLength(pList plist)
{
    int count = 0;

    while (plist)
    {
        count++;
        plist = plist->next;
    }

    return count;
}
//面试题：
//1.从尾到头打印单项链表
void PrintTailToHead_R(pList plist)
{
    if (plist == NULL)
    {
        printf("NULL");
        return;
    }
    else
    {
        PrintTailToHead_R(plist->next);
        printf("<--%d", plist->data);
    }
}//递归法

void PrintTailToHead(pList plist)
{
    pNode cur = NULL;
    pNode print = plist;

    printf("NULL");

    while (cur != plist)
    {
        print = plist;

        while (print->next != cur)
        {
            print = print->next;
        }
        printf("<--%d", print->data);
        cur = print;
    }

    printf("\n");
}//设置尾节点
//2.删除一个无头单项链表的非尾节点（不能遍历链表）
void EraseNotTailNode(pNode pos)
{
    if (pos == NULL)
    {
        return;
    }

    pNode del = pos->next;
    pos->data = del->data;
    pos->next = del->next;
    free(del);
    del = NULL;
}
//3.在无头单项链表的一个节点前插入一个节点（不能遍历链表）
void InsertNotTailNode(pNode pos, DataType d)
{
    if (pos == NULL)
    {
        return;
    }

    pNode NewNode = BuyNode(pos->data);
    NewNode->next = pos->next;
    pos->next = NewNode;
    pos->data = d;
}
//4.单链表实现约瑟夫环（JosephCircle）
pNode JosephCircle(pNode plist, const int M)
{
    int m = M;
    pNode cur = NULL;
    pNode del = NULL;

    if (plist == NULL)
    {
        return NULL;
    }
    cur = plist;

    while (cur->next != cur)
    {
        m = M;

        while (--m)
        {
            cur = cur->next;
        }
        del = cur->next;
        cur->next = del->next;
        cur->data = del->data;
        free(del);
        del = NULL;
    }

    return cur;
}
//5.逆置/反转单链表
void ReverseList(pList *pplist)
{
    pNode pPre = NULL;
    pNode pCur = NULL;
    pNode pNext = NULL;

    assert(pplist);

    pCur = *pplist;

    while (pCur)
    {
        pNext = pCur->next;
        pCur->next = pPre;
        pPre = pCur;
        pCur = pNext;
    }

    *pplist = pPre;
}//三指针法

pNode ReverseList_PF(pList plist)
{
    pList NewList = NULL;
    pNode pCur = plist;
    pNode pPre = NULL;

    while (pCur)
    {
        pPre = pCur->next;
        pCur->next = NewList;
        NewList = pCur;
        pCur = pPre;
    }

    return NewList;
}//头插法
//6.单链表排序（冒泡排序&快速排序）
void BubbleSort(pNode* pplist)
{
    int flag = 0;
    pNode cur = NULL;
    pNode pre = NULL;
    pNode tail = NULL;

    assert(pplist);

    cur = *pplist;
    pre = cur->next;

    if (*pplist == NULL || (*pplist)->next == NULL)
    {
        return;
    }

    while (pre != tail)
    {
        while (pre != tail)
        {
            if (cur->data > pre->data)
            {
                DataType temp = cur->data;
                cur->data = pre->data;
                pre->data = temp;
            }

            cur = cur->next;
            pre = pre->next;
        }

        tail = cur;
        cur = *pplist;
        pre = cur->next;
    }
}//冒泡排序
//7.合并两个有序链表，合并后依然有序
pNode MergeOrderList(pList plist1, pList plist2)
{
    pList NewList = NULL;
    pNode Tail = NULL;
    pNode list1 = plist1;
    pNode list2 = plist2;

    if (list1 == NULL)
    {
        return list2;
    }
    else if (list2 == NULL)
    {
        return list1;
    }

    if (list1->data >= list2->data)
    {
        NewList = Tail = list1;
        list1 = list1->next;
    }
    else
    {
        NewList = Tail = list2;
        list2 = list2->next;
    }

    while (list1 && list2)
    {
        if (list1->data >= list2->data)
        {
            Tail->next = list1;
            list1 = list1->next;
        }
        else
        {
            Tail->next = list2;
            list2 = list2->next;
        }

        Tail = Tail->next;
    }

    if (list1 == NULL)
    {
        Tail->next = list2;
    }
    else
    {
        Tail->next = list1;
    }

    return NewList;
}
//8.查找单链表的中间节点，要求只能遍历一次链表
pNode FindMiddleNode(pNode plist)
{
    pNode fast = NULL;
    pNode slow = NULL;

    if (plist == NULL)
    {
        return NULL;
    }

    fast = plist;
    slow = plist;

    while (fast && fast->next)//fast为NULL时有偶数个节点，fast->next为NULL时有奇数个节点
    {
        slow = slow->next;
        fast = fast->next->next;
    }

    return slow;
}
//9.查找单链表的倒数第K个节点，要求只能遍历一次链表
pNode FindInverseKNode(pNode plist, const int K)
{
    pNode fast = NULL;
    pNode slow = NULL;
    int k = K;

    if (plist == NULL || K <= 0)
    {
        return NULL;
    }

    fast = plist;
    slow = plist;

    while (k--)
    {
        if (fast == NULL)
        {
            return NULL;
        }

        fast = fast->next;
    }

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

    return slow;
}
//10.删除链表的倒数第K个节点
void DeleteInverseKNode(pNode* pplist, const int K)
{
    int k = K;
    pNode fast = NULL;
    pNode slow = NULL;
    pNode pre = NULL;

    assert(pplist);

    if (K <= 0)
    {
        return ;
    }

    fast = *pplist;
    slow = *pplist;

    while (k--)
    {
        if (fast == NULL)
        {
            return ;
        }

        fast = fast->next;
    }

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

    if (slow == *pplist)
    {
        *pplist = slow->next;
        free(slow);
        slow = NULL;
    }
    else
    {
        pre->next = slow->next;
        free(slow);
        slow = NULL;
    }

}
//11.判断单链表是否带环？若带环，求环的长度？求环的入口？
//判断是否带环
pNode IsListCircle(pNode plist)
{
    pNode fast = plist;
    pNode slow = plist;

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

        if (slow == fast)
        {
            return slow;
        }
    }
    return NULL;
}
//求环的长度
int ListCiecleLen(pNode meet)
{
    int count = 1;
    pNode cur = meet;

    if (cur == NULL)
    {
        return 0;
    }

    while (cur->next != meet)
    {
        count++;
        cur = cur->next;
    }

    return count;
}
//求环的入口
pNode ListCircleEnter(pNode plist, pNode meet)
{
    pNode cur = plist;
    pNode pre = meet;

    if (plist == NULL || meet == NULL)
    {
        return NULL;
    }

    while (cur != pre)
    {
        cur = cur->next;
        pre = pre->next;
    }

    return cur;
}
//12.判断两个链表是否相交，若相交，求交点（假设链表不带环）
//判断是否相交
int IsListCross(pNode plist1, pNode plist2)
{
    pNode cur = plist1;
    pNode pre = plist2;

    if (plist1 == NULL || plist2 == NULL)
    {
        return 0;
    }

    while (cur->next != NULL)
    {
        cur = cur->next;
    }

    while (pre->next != NULL)
    {
        pre = pre->next;
    }

    if (cur == pre)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//求交点
pNode ListCrossPoint(pNode plist1, pNode plist2)
{
    int count1 = 0;
    int count2 = 0;
    int count;
    pNode cur = plist1;
    pNode pre = plist2;

    while (cur)
    {
        count1++;
        cur = cur->next;
    }

    while (pre)
    {
        count2++;
        pre = pre->next;
    }
    count = count1 - count2;

    cur = plist1;
    pre = plist2;
    if (count > 0)
    {
        while (count--)
        {
            cur = cur->next;
        }
    }
    else if (count < 0)
    {
        while (count++)
        {
            pre = pre->next;
        }
    }

    while (cur != pre)
    {
        cur = cur->next;
        pre = pre->next;
    }

    return cur;
}
//13.判断两个链表是否相交，若相交，求交点（假设链表可能带环）【升级版】
//判断是否相交
int IsListCross_C(pNode plist1, pNode plist2)
{
    pNode temp;
    pNode cur = plist1;
    pNode pre = plist2;
    pNode list1_c = IsListCircle(plist1);
    pNode list2_c = IsListCircle(plist2);

    if (plist1 == NULL || plist2 == NULL)
    {
        return 0;
    }

    if (((list1_c == NULL) && list2_c) || (list1_c && (list2_c == NULL)))
    {
        return 0;
    }

    if (list1_c && list2_c)
    {
        temp = list1_c;

        while (temp->next != list1_c)
        {
            if (temp == list2_c)
            {
                return 2;
            }

            temp = temp->next;
        }

        if (temp == list2_c)
        {
            return 2;
        }

        return 0;
    }

    return IsListCross(plist1, plist2);
}
//求相交的交点
pNode ListCrossPoint_C(pNode plist1, pNode plist2)
{
    int count1 = 0;
    int count2 = 0;
    int count;
    pNode cur = plist1;
    pNode pre = plist2;
    pNode meet1 = IsListCircle(plist1);
    pNode meet2 = IsListCircle(plist2);
    pNode enter1 = ListCircleEnter(plist1, meet1);
    pNode enter2 = ListCircleEnter(plist2, meet2);

    if (enter1 == enter2)
    {
        while (cur != meet1)
        {
            count1++;
            cur = cur->next;
        }

        while (pre != meet1)
        {
            count2++;
            pre = pre->next;
        }
        count = count1 - count2;

        cur = plist1;
        pre = plist2;
        if (count > 0)
        {
            while (count--)
            {
                cur = cur->next;
            }
        }
        else if (count < 0)
        {
            while (count++)
            {
                pre = pre->next;
            }
        }

        while (cur != pre)
        {
            cur = cur->next;
            pre = pre->next;
        }

        return cur;
    }

    return NULL;
}
test.c文件：（测试文件，检验每个函数是否能达到想要的要求）
//头文件
#define _CRT_SECURE_NO_WARNINGS 1

#include "LinkList.h"
void TestPushPopBack()
{
    pList plist;
    InitLinkList(&plist);
    PushBack(&plist, 1);
    PushBack(&plist, 2);
    PushBack(&plist, 3);
    PushBack(&plist, 4);
    PrintLinkList(plist);
    PopBack(&plist);
    PrintLinkList(plist);
    PopBack(&plist);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    PopBack(&plist);
    PrintLinkList(plist);
    PopBack(&plist);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestPushPopFront()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    PopFront(&plist);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestFindInsert()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintLinkList(plist);
    pNode pos = Find(plist, 2);
    printf("%d\n", pos->data);
    Insert(&plist, pos, 5);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestErase()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintLinkList(plist);
    pNode pos = Find(plist, 3);
    printf("%d\n", pos->data);
    Erase(&plist, pos);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestRemove()
{
    pList plist;
    PushFront(&plist, 2);
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 2);
    PushFront(&plist, 2);
    PushFront(&plist, 4);
    PushFront(&plist, 2);
    PrintLinkList(plist);
    //Remove(&plist, 2);
    RemoveAll(&plist, 2);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestLength()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintLinkList(plist);
    int count = GetListLength(plist);
    printf("链表中有%d个元素\n", count);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestPrintTailToHead()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PrintLinkList(plist);
    PrintTailToHead_R(plist);
    printf("\n");
    PrintTailToHead(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestEraseNotTailNode()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PushFront(&plist, 5);
    PushFront(&plist, 6);
    PrintLinkList(plist);
    pNode pos = Find(plist, 4);
    EraseNotTailNode(pos);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestInsertNotTailNode()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PushFront(&plist, 5);
    PushFront(&plist, 6);
    PrintLinkList(plist);
    pNode pos = Find(plist, 3);
    InsertNotTailNode(pos, 7);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestJosephCircle()
{
    pNode cur = NULL;
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PushFront(&plist, 5);
    PushFront(&plist, 6);
    PushFront(&plist, 7);
    PushFront(&plist, 8);
    PushFront(&plist, 9);
    PrintLinkList(plist);
    cur = plist;

    //构环
    while (cur->next)
    {
        cur = cur->next;
    }
    cur->next = plist;

    plist = JosephCircle(plist, 3);

    //解环
    plist->next = NULL;

    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestBubbleSort()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 6);
    PushFront(&plist, 5);
    PushFront(&plist, 4);
    PushFront(&plist, 3);
    PushFront(&plist, 2);
    PushFront(&plist, 9);
    PushFront(&plist, 8);
    PushFront(&plist, 7);
    PrintLinkList(plist);
    BubbleSort(&plist);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestFindMiddleNode()
{
    pNode mid = NULL;
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 6);
    PushFront(&plist, 5);
    PushFront(&plist, 4);
    PushFront(&plist, 3);
    PushFront(&plist, 2);
    PushFront(&plist, 7);
    PrintLinkList(plist);
    mid = FindMiddleNode(plist);
    printf("%d\n", mid->data);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestFindInverseKNode()
{
    pNode find = NULL;
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 6);
    PushFront(&plist, 5);
    PushFront(&plist, 4);
    PushFront(&plist, 3);
    PushFront(&plist, 2);
    PushFront(&plist, 7);
    PrintLinkList(plist);
    find = FindInverseKNode(plist, 3);
    printf("%d\n", find->data);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestReverseList()
{
    pList NewList = NULL;
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PushFront(&plist, 5);
    PushFront(&plist, 6);
    PushFront(&plist, 7);
    PrintLinkList(plist);
    ReverseList(&plist);
    PrintLinkList(plist);
    NewList = ReverseList_PF(plist);
    PrintLinkList(NewList);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestMergeOrderList()
{
    pList NewList = NULL;
    pList plist1;
    pList plist2;
    InitLinkList(&plist1);
    PushFront(&plist1, 1);
    PushFront(&plist1, 3);
    PushFront(&plist1, 5);
    PushFront(&plist1, 7);
    PushFront(&plist1, 9);
    PrintLinkList(plist1);

    InitLinkList(&plist2);
    PushFront(&plist2, 2);
    PushFront(&plist2, 4);
    PushFront(&plist2, 5);
    PushFront(&plist2, 6);
    PushFront(&plist2, 8);
    PrintLinkList(plist2);

    NewList = MergeOrderList(plist1, plist2);
    PrintLinkList(NewList);
    DestroyLinkList(&NewList);
    PrintLinkList(NewList);
}

这里写图片描述

void TestDeleteInverseKNode()
{
    pList plist;
    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 6);
    PushFront(&plist, 5);
    PushFront(&plist, 4);
    PushFront(&plist, 3);
    PushFront(&plist, 2);
    PushFront(&plist, 7);
    PrintLinkList(plist);
    DeleteInverseKNode(&plist, 7);
    PrintLinkList(plist);
    DestroyLinkList(&plist);
    PrintLinkList(plist);
}

这里写图片描述

void TestIsListCircle()
{
    pNode Enter;
    int len;
    pNode find1;
    pNode find2;
    pNode Meet;
    pList plist;

    InitLinkList(&plist);
    PushFront(&plist, 1);
    PushFront(&plist, 2);
    PushFront(&plist, 3);
    PushFront(&plist, 4);
    PushFront(&plist, 5);
    PushFront(&plist, 6);
    PushFront(&plist, 7);
    PushFront(&plist, 8);
    find1 = Find(plist, 1);
    find2 = Find(plist, 5);
    find1->next = find2;
    //PrintLinkList(plist);
    Meet = IsListCircle(plist);
    len = ListCiecleLen(Meet);
    Enter = ListCircleEnter(plist, Meet);

    if (Meet != NULL)
    {
        printf("链表带环，环的长度为%d ，环的入口处结点中的值为%d\n", len, Enter->data);
    }
    else
    {
        printf("链表不带环！\n");
    }
}

这里写图片描述

void TestIsListCross()
{
    pNode point;
    int cross;
    pNode find1;
    pNode find2;
    pNode find3;
    pNode find4;
    pList plist1;
    pList plist2;

    InitLinkList(&plist1);
    PushFront(&plist1, 1);
    PushFront(&plist1, 2);
    PushFront(&plist1, 3);
    PushFront(&plist1, 7);
    PushFront(&plist1, 4);
    PushFront(&plist1, 5);
    PushFront(&plist1, 6);
    PushFront(&plist1, 7);
    PushFront(&plist1, 8);
    find1 = Find(plist1, 6);
    find3 = Find(plist1, 1);
    find4 = Find(plist1, 4);
    find3->next = find4;

    InitLinkList(&plist2);
    PushFront(&plist2, 1);
    PushFront(&plist2, 2);
    PushFront(&plist2, 3);
    PushFront(&plist2, 4);
    find2 = Find(plist2, 1);

    find2->next = find1;
    //PrintLinkList(plist1);
    //PrintLinkList(plist2);

    cross = IsListCross_C(plist1, plist2);

    if (cross == 0)
    {
        printf("两条链表不相交！\n");
    }
    else if (cross == 1)
    {
        point = ListCrossPoint(plist1, plist2);
        printf("两条链表相交，交点处节点中的数为%d\n", point->data);
    }
    else
    {
        point = ListCrossPoint_C(plist1, plist2);
        if (point != NULL)
        {
            printf("两条链表相交，交点处节点中的数为%d\n", point->data);
        }
        else
        {
            printf("两条链表相交，交点为整个环\n");
        }
    }
}

这里写图片描述

//主函数，调用所有测试函数
int main()
{
    //TestPushPopBack();
    //TestPushPopFront();
    //TestFindInsert();
    //TestErase();
    //TestRemove();
    //TestLength();
    //TestPrintTailToHead();
    //TestEraseNotTailNode();
    //TestInsertNotTailNode();
    //TestJosephCircle();
    //TestBubbleSort();
    //TestFindMiddleNode();
    //TestFindInverseKNode();
    //TestReverseList();
    //TestMergeOrderList();
    //TestDeleteInverseKNode();
    //TestIsListCircle();
    TestIsListCross();

    system("pause");
    return 0;
}
C语言 数据结构链表的实例（十九种操作）
08-29
C语言数据结构链表的实例（十九种操作） 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。今天，我们将讨论C语言中的数据结构链表...
湖南大学数据结构链表实验1.zip
03-08
在本实验中，我们将深入探讨数据结构中的一个重要概念——链表。链表是一种线性数据结构，与数组不同，它不连续存储元素。在链表中，每个元素（称为节点）包含两部分：数据和指向下一个节点的指针。这个实验来自湖南...
第三章 链表结构
yuanjian0814的博客
07-19 253
3.1 链表（Linked List） 3.1.2 基本介绍 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是按照链式存储的方式存储数据，在每一个节点里存到下一个节点的指针(Pointer)。 由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时...
数据结构——链表
2301_76227083的博客
09-11 6609
学习了顺序表就知道，顺序表在大量的头插或者中间插入的时候效率是很低的，需要频繁挪动数据，那么有没有一种数据结构在处理大量头插和中间插入的时候效率非常高呢？是有的，今天我们就来学习一下链表。
数据结构-链表
一个努力拼搏的人
11-13 2552
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构链表的创建
雾的博客
05-11 4671
实现链表的创建、遍历、排序、插入、删除 。
数据结构 -- 链表详解
hu_143的博客
04-27 3379
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
【数据结构】链表
热门推荐
knous
03-13 6万+
链表
数据结构之链表
优快云全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
01-18 4299
数据结构之链表
Educoder头歌数据结构链表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案educoder 数据结构-链表及其应用 第1关：链表的实现之查找功能 /************************************************************* 链表的实现之查找功能 实现文件 更新于2020年4月21日 **************************************************************/ void LL_GetAt(LinkList L, int i, ElemType &amp
【c++数据结构 链表】
DL200406的博客
05-01 1429
链表是一种常见的数据结构，由一系列节点通过指针相连而成。每个节点包含两部分：数据域和指针域，指针域指向下一个节点。C++中的指针类似于地址引用，可用于访问和操作内存中的数据。链表的特点在于其元素可以不连续存储，通过指针串联起来形成链式结构。链表的操作包括插入和删除节点，通常通过虚拟头节点简化操作。结构体在C++中用于定义复合结构，如链表节点。链表节点的插入和删除涉及使用new运算符动态分配内存，并通过箭头语法访问节点的成员。
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
三电平SVPWM模型的Matlab仿真及其在逆变器性能优化中的应用
05-01
内容概要：本文详细介绍了三电平SVPWM模型在Matlab中的搭建与研究，重点探讨了三电平逆变器的工作原理、性能特点以及参数优化方法。文中不仅解释了三电平逆变器相较于传统两电平逆变器的优势，如更高的电压分辨率和更低的谐波失真，还深入讨论了SVPWM控制策略的具体实现步骤，包括扇区划分、中性点电压平衡、死区时间和波形生成等关键环节。此外，文章还强调了仿真与实际应用之间的差异，指出仿真只是调试的起点而非终点。 适合人群：从事电力电子、自动化控制领域的研究人员和技术人员，尤其是对逆变器建模和仿真相关工作的从业者。 使用场景及目标：适用于需要深入了解三电平逆变器特性和优化控制策略的研究项目，旨在帮助读者掌握基于Matlab的三电平SVPWM模型构建技巧，从而更好地进行逆变器性能评估和改进。 其他说明：文章提供了大量实用的Matlab代码片段，便于读者理解和实践。同时提醒读者关注仿真与现实应用间的细微差别，确保理论成果能够顺利转化为实际效益。
spring-boot-2.3.9.RELEASE.jar中文文档.zip
05-01
# 压缩文件中包含： 中文文档 jar包下载地址 Maven依赖 Gradle依赖 源代码下载地址 # 本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 # 特殊说明： ·本文档为人性化翻译，精心制作，请放心使用。 ·只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； ·不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 # 温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件；
水利规范-7p倒虹吸工程及渠道防渗衬砌设计图集.zip
最新发布
05-01
水利规范-7p倒虹吸工程及渠道防渗衬砌设计图集.zip
JAVAWeb外文文献毕业设计样本.doc
05-01
JAVAWeb外文文献毕业设计样本.doc
数据结构链表操作详解与实现
"数据结构链表清单详表" 本文将详细讲解数据结构中的链表概念，以及如何使用C语言实现链表的基本操作，包括创建链表、在链表中插入元素、删除元素和打印链表。这些知识对于学习数据结构的大学生来说非常重要，有助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值