链表相关练习

最新推荐文章于 2024-05-01 10:28:08 发布
最新推荐文章于 2024-05-01 10:28:08 发布
阅读量159 收藏 1
点赞数
分类专栏： C 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41804778/article/details/80569506
版权

链表练习题

  • 创建链表
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct SListNode
{
    int data;
    struct SListNode *pNext;
}SList;
  • 初始化头部
void Init(SList **pphead)
{
    *pphead = NULL;
}
  • 输出链表
void Print(SList *pHead)
{
    assert(pHead);
    if(pHead == NULL)
    {
        printf("链表为空\n");
        return;
    }
    while(pHead != NULL)
    {
        printf("%d -> ",pHead->data);
        pHead = pHead->pNext;
    }
    printf("NULL\n");
}
  • 尾插
void SListPushBack(SList **ppHead, int data)
{
    SList *pNode; 
    SList *pNew = (SList *)malloc(sizeof(SList));
    if(*ppHead == NULL)
    {
        *ppHead = pNew;
        pNew->data = data;
        pNew->pNext = NULL;
        return;
    }
    pNode = *ppHead;
    while(pNode->pNext != NULL)
    {
        pNode = pNode->pNext;
    }
    pNode->pNext = pNew;
    pNew->data = data;
    pNew->pNext = NULL;
}
  • 头部插入
void SListPushFront(SList **ppHead, int data)
{
    SList *pNew = (SList *)malloc(sizeof(SList));
    if(*ppHead == NULL)
    {
        *ppHead = pNew;
        pNew->data = data;
        pNew->pNext = NULL;
        return;
    }
    pNew->pNext = *ppHead;
    pNew->data = data;
    *ppHead = pNew;
}
  • 尾删
void SListPopBack(SList **ppHead)
{
    SList *pHead = *ppHead;
    SList *pNode;
    if(*ppHead == NULL)
    {
        printf("链表为空\n");
        return;
    }
    if(pHead->pNext == NULL)
    {
        free(pHead);
        *ppHead = NULL;
        return;
    }
    while(pHead->pNext != NULL)
    {
        pNode = pHead;
        pHead = pHead->pNext;
    }
    free(pHead);
    pNode->pNext = NULL;
}
  • 头删
void SListPopFront(SList **ppHead)
{
    SList *pHead = *ppHead;
    if(pHead->pNext == NULL)
    {
        free(pHead);
        *ppHead = NULL;
        return;
    }
    *ppHead = pHead->pNext;
    free(pHead);
}
  • 随机插
void SListInsert(SList **ppHead, int x, int data)
{
    SList *pHead;
    SList *pNew = (SList *)malloc(sizeof(SList));
    pHead = *ppHead;
    if(pHead->data == x)
    {
        pNew->pNext = pHead;
        pNew->data = data;
        *ppHead = pNew;
        return;
    }
    while(pHead->pNext->data != x)
    {
        pHead = pHead->pNext;
    }
    pNew->pNext = pHead->pNext;
    pHead->pNext = pNew;
    pNew->data = data;
}
  • 删除
void SListDel(SList **ppHead, int data)
{
    SList *pHead = *ppHead;
    SList *pNode;
    if(pHead->data == data)
    {
        SListPopFront(ppHead);
        return;
    }
    while(pHead != NULL)
    {
        if(pHead->data == data)
        {
            pNode->pNext = pHead->pNext;
            free(pHead);
            return;
        }
        pNode = pHead;
        pHead = pHead->pNext;
    }
}
  • 按值删除所有
void SListRemoveAll(SList **ppHead, int data)
{
    SList *pNode = *ppHead;
    SList *pNode1;
    while(pNode->pNext != NULL)
    {
        if(pNode->pNext->data == data)
        {
            pNode1 = pNode->pNext;
            pNode->pNext = pNode1->pNext;
            free(pNode1);
        }else
        {
            pNode = pNode->pNext;
        }
    }
    if((*ppHead)->data == data)
    {
        SListPopFront(ppHead);
    }
}
  • 查找
SList *SListFind(SList *pHead, int data)
{
    SList *pNode = pHead;
    while(pNode != NULL)
    {
        if(pNode->data == data)
        {
            return pNode;
        }
        pNode = pNode->pNext;
    }
    return NULL;
}
  • 销毁
void SListDestroy(SList **ppHead)
{
    SList *pNode;
    assert(ppHead);
    while(*ppHead != NULL)
    {
        pNode = *ppHead;
        *ppHead = (*ppHead)->pNext;
        free(pNode);
    }
}
  • 删除一个无头单链表的非尾节点（不能遍历链表）
//换船上的人，不换船本体
void DelSList(SList **ppHead,int data)
{
    SList *pHead = *ppHead;
    assert(ppHead);
    while(pHead->data != data)
    {
        pHead = pHead->pNext;
    }
    while(pHead->pNext->pNext != NULL)
    {
        pHead->data = pHead->pNext->data;
        pHead = pHead->pNext;
    }
    pHead->data = pHead->pNext->data;
    free(pHead->pNext);
    pHead->pNext = NULL;
}
  • 反转链表
void SListRever(SList **ppHead)
{
    SList *p1,*p2,*p3;
    assert(ppHead);
    p1 = NULL;
    p2 = *ppHead;
    p3 = p2->pNext;
    while(p2 != NULL)
    {
        p2->pNext = p1;
        p1 = p2;
        p2 = p3;
        if(p3 != NULL)
        {
            p3 = p3->pNext;
        }
    }
    *ppHead = p1;
}
  • 在无头单链表的一个节点前插入一个节点（不能遍历链表）
void InsertNoFirstNode(SList **ppPos, int data)
{
    SList *pPos = *ppPos;
    SList *pNode;
    assert(ppPos);
    if(*ppPos == NULL)
    {
        SListPushBack(ppPos, data);
        return;
    }
    pNode = (SList *)malloc(sizeof(SList));
    pNode->data = data;
    pNode->pNext = NULL;

    pNode->pNext = pPos->pNext;
    pPos->pNext = pNode;
    pNode->data = pPos->data;
    pPos->data = data;
}
  • 单链表实现约瑟夫环
void SListJosephCircle(SList **ppHead, int n)
{
    SList *pHead = *ppHead;
    SList *pNode;
    int i;
    while(pHead->pNext != NULL)
    {
        pHead = pHead->pNext;
    }
    pHead->pNext = *ppHead;
    pHead = *ppHead;
    while(pHead->pNext != pHead)
    {
        i = n;
        while((--i)>0)
        {
            pNode = pHead;
            pHead = pHead->pNext;
        }

        pNode->pNext = pHead->pNext;
        free(pHead);

        pHead = pNode->pNext;
    }
    pHead->pNext = NULL;
    *ppHead = pHead;
}
  • 逆向打印链表
void PrintFail(SList *pHead)
{
    if(pHead == NULL)
    {
        return;
    }
    else
    {
        PrintFail(pHead->pNext);
        printf("->%d",pHead->data);

    }
}
  • 排序链表
//遍历链表，每次遍历删除值最大的链子，然后再创建到另一个链表上。
void SListSort(SList **ppHead)
{
    SList *pHead = *ppHead;
    SList *pNode = *ppHead;
    SList *First = NULL;
    int i = 0;
    while(pHead != NULL)
    {
        pNode = pHead;
        i = 0;
        while(pNode != NULL)
        {
            if(pNode->data > i)
            {
                i = pNode->data;
            }
            pNode = pNode->pNext;
        }
        SListPushBack(&First, i);
        SListDel(&pHead, i);
    }
    *ppHead = First;
}
  • 合并有序链表
//遍历两个链表，创建一个新的链表，两个链表中较小的放入新链表，最后将多余的放入新链表中
SList *SListmerge(SList **ppHead, SList **pptwo)
{
    SList *pone = *ppHead;
    SList *ptwo = *pptwo;
    SList *merge = NULL;
    SList *ptmp = NULL;
    while(pone != NULL && ptwo != NULL)
    {
        if(pone->data < ptwo->data)
        {
            SListPushBack(&merge, pone->data);
            pone = pone->pNext;
        }else
        {
            SListPushBack(&merge, ptwo->data);
            ptwo = ptwo->pNext;
        }
    }
    if(pone == NULL)
    {
        ptmp = ptwo;
    }else
    {
        ptmp = pone;
    }
    while(ptmp != NULL)
    {
        SListPushBack(&merge, ptmp->data);
        ptmp = ptmp->pNext;
    }
    return merge;
}
  • 求两个链表的交集
//遍历链表相同的放在新链表中
SList *SListintersection(SList **ppone, SList **pptwo)
{
    SList *pone = *ppone;
    SList *ptwo = *pptwo;
    SList *pnew = NULL;
    while(pone != NULL)
    {
        ptwo = *pptwo;
        while(ptwo != NULL)
        {
            if(pone->data == ptwo->data)
            {
                SListPushBack(&pnew, pone->data);
            }
            ptwo = ptwo->pNext;
        }
        pone = pone->pNext;
    }
    return pnew;
}
  • 求两个链表的并集
//先让新链表等于其中一个链表，然后用一个链表遍历另一个，
//如果链表里没有另一个链表里的数，保存并将状态置1，然后加入到新链表中，然后将状态置0，
//遍历过程中及时修改状态值，决定是否将其加入并集中。
SList * SListUnion(SList **ppone, SList **pptwo)
{
    SList *pone = *ppone;
    SList *ptwo = *pptwo;
    SList *pnew = pone;
    int stract = 0;
    int tmp = 0;
    if(pone == NULL && ptwo != NULL)
        return ptwo;
    if(ptwo == NULL && pone != NULL)
        return pone;
    assert(ppone&&pptwo);
    while(ptwo != NULL)
    {
        pone = *ppone;
        while(pone != NULL)
        {
            if(pone->data != ptwo->data)
            {
                stract = 1;
                tmp = ptwo->data;
                //SListPushBack(&pnew, 1);
            }
            if(pone->data == ptwo->data)
            {
                stract = 0;
                //SListPopBack(&pnew);
                break;
            }
            pone = pone->pNext;
        }
        if(stract == 1)
        {
            SListPushBack(&pnew, tmp);
            stract = 0;
        }
        ptwo = ptwo->pNext;
    }
    return pnew;
}
  • 求链表长度
int SListstrlen(SList *pHead)
{
    int count = 0;
    SList *str = pHead;
    while(str != NULL)
    {
        count++;
        str = str->pNext;
    }
    return count;
}
  • 两个链表是否相交，求交点
//链表如果相交，终点肯定是一致的，比较他们的末尾节点的地址，相等则相交。
//如果相交，求出俩链表长度，让长的先走链表长度差的步数，
//然后两链表同时向后走，地址相等时，两个链表相交
SList *SListIsintersect(SList *pHead, SList *ptwo1)
{
    SList *pone = pHead;
    SList *ptwo = ptwo1;
    SList *Long = NULL;
    SList *Short = NULL;
    int n = 0;
    int x = SListstrlen(pone);
    int y = SListstrlen(ptwo);
    if(x > y)
    {
        Long = pone;
        Short = ptwo;
        n = x-y;
    }
    else
    {
        Long = ptwo;
        Short = pone;
        n = y-x;
    }
    for(n; n>0; n--)
    {
        Long = Long->pNext;
    }
    while(Long != Short)
    {
        Long = Long->pNext;
        Short = Short->pNext;
    }
    return Long;
}
  • 删除倒数第K个节点
//定义两个指针，其中一个先走k-1步，然后两个同时遍历，
//先走的走完链表时，后走的刚好走到倒数第k个点上
void SListDelK(SList **pptwo, int k)
{
    SList *pfast = *pptwo;
    SList *pslow = *pptwo;
    SList *Del = NULL;
    assert(pptwo);
    while(k-1)
    {
        k--;
        pfast = pfast->pNext;
    }
    if(pfast->pNext == NULL)
    {
        SListPopFront(pptwo);
        return;
    }
    while(pfast->pNext != NULL)
    {
        Del = pslow;
        pfast = pfast->pNext;
        pslow = pslow->pNext;
    }
    Del->pNext = pslow->pNext;
}
  • 计算相遇点
//判断链表是否有环，定义两个指针，一个每次走两步，一个每次走一步，
//如果最后两个指针能指向同一个点，说明链表有环。
SList *SListmeet(SList *ptwo)
{
    SList *fast = ptwo;
    SList *slow = ptwo;
    if(ptwo == NULL)
    {
        return NULL;
    }
    while(1)
    {
        if(fast->pNext == NULL || fast->pNext->pNext == NULL)
        {
            return NULL;
        }
        fast = fast->pNext->pNext;
        slow = slow->pNext;
        if(fast == slow)
        {
            return slow;
        }
    }
}
  • 计算环的入口
//两个指针，一个从链表开始部分走，一个从相遇的点开始走，当两个指针相等的时候，就是环的入口点
SList *SListCircle(SList *ptwo, SList *meet)
{
    SList *first = ptwo;
    SList *pMeet = meet;
    assert(ptwo && meet);
    while(first != pMeet)
    {
        first = first->pNext;
        pMeet = pMeet->pNext;
    }
    return first;
}
  • 环的长度
int SListlen(SList *meet)
{
    int count = 1;
    SList *pMeet = meet->pNext;
    while(pMeet != meet)
    {
        count++;
        pMeet = pMeet->pNext;
    }
    return count;
}
  • 复杂链表的拷贝
/*
void CListCopy(CList **ppHead, SList **ppCopy)
{
    CList *pHead = *ppHead;
    CList *Copy = *ppCopy;
    CList *pNode = NULL;
    Clist *Next = NULL;
    CList *pNew = NULL;
    assert(ppHead);
    while(pHead != NULL)
    {
        pNode = pHead->pNext;
        pNew = (CList *)malloc(sizeof(CList));
        pNew->data = pHead->data;
        pNew->Rom = NULL;
        pNew->pNext = pNode;
        pHead->pNext = pNew;
        pHead = pHead->pNext-pNext;
    }
    pHead = *ppHead;
    while(pHead != NULL)
    {
        Next = pHead->Rom;
        if(Next != NULL)
        {
            pHead->pNext->Rom = Next->pNext;
            pHead = pHead->pNext->pNext;
        }
    }
    pHead = *ppHead;
    Copy = pHead->pNext;
    while(pHead != NULL)
    {
        Next = pHead->pNext->pNext;
        if(Next != NULL)
        {
            Copy->pNext = Next->pNext;
        }
        else
        {
            Copy->pNext = NULL;
        }
        pHead->pNext = Next;
        pHead = pHead->pNext;
    }
}
*/
int main()
{
    SList *pHead;
    SList *ptwo = NULL;
    SList *pNode = NULL;
    SList *pNode2 = NULL;
    SList *pCP = NULL;
    SList *meet = NULL;
    SList *circle = NULL;
    int c = 0;
    //SList *merge;
    //初始化头部
    //交集并集指针变量
    //SList *intersection;
    //SList *Union;
    Init(&pHead);
    //尾部插入
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 6);
    SListPushBack(&pHead, 9);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 8);
    SListPushBack(&pHead, 5);
    //头部插入
    //SListPushFront(&pHead, 5);
    //尾删
    //SListPopBack(&pHead);
    //头删
    //SListPopFront(&pHead);
    //在哪个数前插入
    //SListInsert(&pHead, 5, 4);
    //按值删除
    //SListDel(&pHead, 6);
    //按值删除所有
    //SListRemoveAll(&pHead, 2);
    //查找
    //pNode = SListFind(pHead, 6);
    //printf("%d\n",pNode->data);
    //销毁
    //SListDestroy(&pHead);
    //删除一个无头单链表的非尾节点（不能遍历链表）
    //DelSList(&pHead,1);
    //在无头单链表的一个节点前插入一个节点（不能遍历链表）
    //InsertNoFirstNode(&pNode, 9);
    //翻转链表
    //SListRever(&pHead);
    //单链表实现约瑟夫环
    SListJosephCircle(&pHead,3);
    //逆向打印
    //PrintFail(pHead);
    //printf("\n");
    //排序链表
    //SListSort(&pHead);
    //输出
    //Print(pHead);
    //链表二
    SListPushBack(&ptwo, 2);
    SListPushBack(&ptwo, 4);
    SListPushBack(&ptwo, 7);
    SListPushBack(&ptwo, 5);
    SListPushBack(&ptwo, 3);
    SListPushBack(&ptwo, 1);

    //连接两个链表
    //pNode = SListFind(ptwo, 7);
    //pNode2 = SListFind(pHead, 6);
    //pNode->pNext = pNode2;
    //制造一个链表环，如果链表带环，则打印链表会出现死循环。
    pNode = SListFind(ptwo, 7);
    pNode2 = SListFind(ptwo, 1);
    pNode2->pNext = pNode;
    //Print(ptwo);

    //计算相遇点
    meet = SListmeet(ptwo);
    if(meet != NULL)
    {
        //printf("是带环的,相遇点的值为%d\n",meet->data);
    }
    //计算环的入口
    circle = SListCircle(ptwo, meet);
    //printf("环入口处的值为%d\n",circle->data);
    //环的长度
    c = SListlen(meet);
    //printf("环的长度为%d\n",c);

    //合并有序链表
    //merge = SListmerge(&pHead, &ptwo);
    //Print(merge);
    //交集
    //intersection = SListintersection(&pHead, &ptwo);
    //Print(intersection);
    //并集
    //Union = SListUnion(&pHead, &ptwo);
    //Print(Union);
    //两个链表是否相交，求交点
    //pCP = SListIsintersect(pHead, ptwo);
    //printf("相交点的值为%d\n", pCP->data);

    //删除倒数第K个节点
    //SListDelK(&ptwo, 6);
    //Print(ptwo);
    //输出
    //Print(pHead);
    return 0;
}
qq_1246829716
关注
专栏目录
数据结构-链表练习
qq_45814762的博客
11-16 734
再学习链表之后，一定要做题巩固，下面是关于链表比较常见的一些题目，上题目 1. 将两个升序链表合并为⼀个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输⼊：1->2->4, 1->3->4 输出：1->1->2->3->4->4 实现思想： 首先确定解题的数据结构：这里使用单链表比较快速 假设我们把两个链表分别称作链表a和链表b。从链表头开始比较，链表a和链表b都是有序递增的，所以比较链表a和链表b的第一个元素的.
链表经典练习题
2302_81016149的博客
05-01 916
本篇文章到这里就结束了，如果有不理解的题目，可私信或在评论区留下问题，记得一定要练习，这是非常重要的。再强调：大部分题目解法只为了抛砖引玉。希望对大家有所启发。完！
链表相关练习题以及题解
2302_81342533的博客
05-01 1040
学习完了链表结构，不妨多加练习熟系这种数据结构。所以本篇论文列举出了一些和链表相关的练习题，并描述解题思路，相信对能够令读者对链表这种结构的掌握更加得心应手。
环形链表相关练习
qq_56663697的博客
08-31 159
文章目录判断链表是否为环形链表寻找环形链表的结点 判断链表是否为环形链表 题目简介 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返回 false 。 LeetCode 141 解题
链表相关练习题
学习C++的小陈同学
04-04 125
对一些较为入门的链表编程题进行整理，方便今后复习
C语言之链表练习题
weixin_46305053的博客
12-06 3617
本关需要你设计一个程序，实现单链表的逆置。单链表的逆置分为两种方法：头插法和就地逆置法，这两种方法虽然都能够达到逆置的效果，但还是有着不小的差别。头插法逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。就地逆置法先假定有一个函数，可以将以为头结点的单链表逆序，并返回新的头结点。利用这个函数对问题进行求解：将链表分为当前表头结点和其余部分，递归的过程就是，先将表头结点从链表中拆出来，然后对其余部
数据结构——链表（练习题）
LGFaiJC的博客
03-28 2091
这道题我们的思路是分别找出长的链表与短的链表节点个数然后用长的节点数减去短的节点数得到的数就是长的链表比短的链表多出的节点个数然后创建两个指针long，short，long先走多出的个数然后再一起走当long与short指向的next相等时就找到了相交节点。让我们来看看这道题，我的思路是快慢指针，类似追击问题，我们创建两个指针一个指针以一次两个节点的速度走下去，一个指针一次一个节点走下去，如果是有环的链表那么指针一定会相交，如果不是环形链表那么快的会遇到NULL。大家好，我是小锋我们继续来学习链表。
链表专项练习 LeetCode
weixin_46047677的博客
09-28 227
链表专项练习
链表的练习
奋斗的龙猫的博客
09-13 414
文章目录回文链表重排链表排序的循环链表 回文链表 给定一个链表的 头节点 head ，请判断其是否为回文链表。 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 示例 1： 输入: head = [1,2,3,3,2,1] 输出: true 示例 2： 输入: head = [1,2] 输出: fasle 提示： 链表 L 的长度范围为 [1, 105] 0 <= node.val <= 9 进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 来源：力扣（L
Java链表练习题
tdongmu的博客
11-15 454
题目 1.逆序输出链表 1->2->3->4->5 print() 5 4 3 2 1 2.逆置链表 1->2->3->4->5 reverse() 5->4->3->2->1 3.查找单链表中倒数第K个元素 4.合并两个有序的单链表，保证合并后的依然有序 5.不允许遍历链表, 在 pos之前插入 6.找两条相交链表的相交节点 7.判断链表是否有环，有环输出环的入口节点，无环返回null 题目分析与实现 1.使
链表相关练习.c
01-31
链表相关练习.c
16种链表的练习
08-17
16种链表的练习 1.c 有头 无序 不循环 单向 2.c 有头 有序 不循环 单向 3.c 无头 无序 不循环 单向 4.c 无头 有序 不循环 单向 5.c 有头 无序 循环 单向 6.c 有头 有序 循环 单向 7.c 无头 无序 循环 单向 ...
基础链表练习（附详细注释）
04-08
在这个“基础链表练习”中，我们将探讨如何创建一个带头结点的字符串链表，以及如何对这个链表进行操作。下面将详细阐述相关知识点。 首先，我们来了解**单链表**的基本概念。单链表由一系列节点组成，每个节点包含...
Java算法练习-环形链表插值练习题
10-01
java学习
链表应用练习
01-10
本次的链表应用练习主要围绕学生信息管理展开，涉及链表的基本操作，包括创建、查询、统计和遍历等。 ### 链表的创建 在给定的代码中，`creatlist`函数实现了链表的创建。该函数首先初始化链表头节点`L`，然后根据...
输入a,b,c三个值，输出其中最大值。
BoKe
03-20 9833
接收三个数值并输出其中最大值 接收三个数值，并输出最大值 #include &amp;lt;stdio.h&amp;gt; int main() { int max(int x, int y, int z);//定义一个需要被调用的函数 int a,b,c,e; //定义需要接收并输出的变量 scanf(&quot;%d,%d,%d&quot;,&amp;amp;a,&amp;amp;b,&am
const作用
BoKe
09-24 6774
1. 修饰变量 具有常属性，可以在定义数组的时候用该变量定义，每次取值从寄存器中取，在编译过后，直接将对应的值，替换到当前变量的位置。与之相对的是volatile。被这个关键字修饰的话，代表告诉了编译器，这个变量时随时可能被修改的。防止编译器优化，每次读取该值时，从内存中读取。而不是从编译器优化的寄存器中读取。C++中，被const修饰的变量，会在编译期间将对应的变量，直接替换为该变量的值。但是...
时间复杂度与空间复杂度
BoKe
05-23 4220
时间复杂度 算法的时间复杂度描述了一个程序该算法的运行时间，是一个关于代表算法输入值的字符串的长度的函数，相当于计算一个程序总共执行了多少次，这个计算次数的表达式，就是该程序的时间复杂。用大O符号表示。不包含函数的低阶和首项系数，使用这种方式时，时间复杂度可以被称为是渐进的。 空间复杂度 空间复杂度是指一个算法在运行过程中占用临时存储空间大小的量度。一般是指这个程序运行期间最多能用多少个...
迷宫问题--压栈、回溯、全部路径、最短路径
BoKe
06-08 2706
迷宫问题 用循环模拟压栈来实现迷宫问题 我们可以用一个二维数组（N*N）来表示迷宫，1表示路，0表示墙，我们把下方当成迷宫入口，出口为数组右方，此迷宫有两个出口。 需要建立一个结构体arg用来存放关于迷宫（二维数组）的信息。也就是存二维数组的两个下标 然后创建关于用来压栈的结构体 迷宫每个节点都有4个方向可以探寻。碰到墙壁（0）或者边界则此路不通 传迷宫的入口进去也就是数组gMaze[...
c语言双向链表的练习
最新发布
10-18
在C语言中，双向链表是一种数据结构，每个节点包含两个指针，一个指向前一个节点，另一个指向后一个节点。这使得可以方便地从头到尾遍历列表，也可以很容易地在任意位置插入和删除节点。以下是创建和操作双向链表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值