【数据结构】单链表

已于 2023-01-17 12:54:23 修改
阅读量885 收藏 20
点赞数 34
分类专栏： 数据结构 文章标签： 链表 数据结构 Powered by 金山文档
于 2023-01-14 19:43:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59954106/article/details/128649383
版权

1.链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

2. 链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了

3. 单链表的实现

首先在VS里面的源文件建立test.c和SList.c,在头文件里面建立SList.h

SList.h:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDataType;
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;
}SLTNode;

3.1 打印

SList.h:

void SListPrint(SLTNode* phead);//打印

SList.c:

#include "SList.h"
void SListPrint(SLTNode* phead)
{
    SLTNode* cur = phead;
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

3.2 申请结点

SList.h:

SLTNode* BuyListNode(SLTDataType x);//动态申请结点

SList.c:

SLTNode* BuyListNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    newnode->data = x;
    newnode->next = NULL;
    return newnode;
}

3.3 尾插

SList.h:

void SListPushBack(SLTNode** pphead, SLTDataType x);//尾插

SList.c:

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);

    assert(*pphead != NULL);
    
    //找到尾结点
    SLTNode* tail = *pphead;
    while (tail->next != NULL)
    {
         tail = tail->next;
    }
    tail->next = newnode;
}

test.c:

#include "SList.h"
void TestSList1()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
}
int main()
{
    TestSList1();
    return 0;
}

运行结果：

3.4 头插

SList.h:

void SListPushFront(SLTNode** pphead, SLTDataType x);//头插

SList.c:

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newcode = BuyListNode(x);
    newcode->next = *pphead;
    *pphead = newcode;
}

test.c:

#include "SList.h"
void TestSList1()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListPushFront(&plist, 1);
    SListPushFront(&plist, 2);
    SListPushFront(&plist, 3);
    SListPrint(plist);
}
int main()
{
    TestSList1();
    return 0;
}

运行结果：

3.5 尾删

SList.h:

void SLisePopBack(SLTNode** pphead);//尾删

SList.c:

void SLisePopBack(SLTNode** pphead)
{
    assert(*pphead != NULL);
    SLTNode* prev = NULL;
    SLTNode* tail = *pphead;
    while (tail->next != NULL)
    {
        prev = tail;
        tail = tail->next;
    }
    free(tail);
    tail = NULL;
    prev->next = NULL;//一定要置空
}

test.c:

#include "SList.h"
void TestSList1()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListPushFront(&plist, 1);
    SListPushFront(&plist, 2);
    SListPushFront(&plist, 3);
    SListPrint(plist);
    SLisePopBack(&plist);
    SListPrint(plist);
}
int main()
{
    TestSList1();
    return 0;
}

运行结果：

3.6 头删

SList.h:

void SListPopFront(SLTNode** pphead);//头删

SList.c:

void SListPopFront(SLTNode** pphead)
{
    assert(*pphead != NULL);
    SLTNode* next = (*pphead)->next;
    free(*pphead);
    *pphead = next;
}

test.c:

#include "SList.h"
void TestSList1()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListPushFront(&plist, 1);
    SListPushFront(&plist, 2);
    SListPushFront(&plist, 3);
    SListPrint(plist);
    SLisePopBack(&plist);
    SListPrint(plist);
    SListPopFront(&plist);
    SListPrint(plist);
}
int main()
{
    TestSList1();
    return 0;
}

运行结果：

3.7 查找

SList.h:

SLTNode* SListFind(SLTNode* phead, SLTDataType x);//查找

SList.c:

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
    SLTNode* cur = phead;
    while (cur)
    {
        if (cur->data == x)
        {
            return cur;
        }
        else
        {
            cur = cur->next;
        }
    }
    return NULL;
}

test.c:

#include "SList.h"
void TestSList2()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPushBack(&plist, 2);
    //Find接口有两个作用
    //1.找    2.修改
    SLTNode* pos = SListFind(plist, 2);
    int i = 1;
    while (pos)
    {
        printf("第%d个pos结点：%p->%d\n", i++, pos, pos->data);
        pos = SListFind(pos->next, 2);
    }
}
int main()
{
    TestSList2();
    return 0;
}

3.8 插入

3.8.1 前插

SList.h:

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//前插

SList.c:

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);
    //相当于头插
    if (*pphead == pos)
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
    else
    {
        //找到pos前一个位置
        SLTNode* posPrew = *pphead;
        while (posPrew->next != pos)
        {
            posPrew = posPrew->next;
        }
        posPrew->next = newnode;
        newnode->next = pos;
    }
}

test.c:

#include "SList.h"
void TestSList3()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SLTNode* pos = SListFind(plist, 2);
    if (pos)
    {
        SListInsert(&plist, pos,20);
    }
    SListPrint(plist);
}
int main()
{
    TestSList3();
    return 0;
}

运行结果：

3.8.2 后插

c++的STL库支持后插，一般我们单链表使用的都是后插。其次前插有一定的效率损失，而后插就没有损失。

SList.h:

void SListInsertAfter(SLTNode* pos, SLTDataType x);//后插

SList.c:

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);
    newnode->next = pos->next;
    pos->next = newnode;
}

test.c:

#include "SList.h"
void TestSList4()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListInsertAfter(plist->next, 20);
    SListPrint(plist);
}
int main()
{
    TestSList4();
    return 0;
}

运行结果：

3.9删除

SList.h:

void SListErase(SLTNode** pphead, SLTNode* pos);//删除

SList.c:

void SListErase(SLTNode** pphead, SLTNode* pos)
{
    //头删，也可直接调用SListPopFront接口
    if (*pphead == pos)
    {
        *pphead = pos->next;
        free(pos);
        pos = NULL;//也可以不置空
    }
    else
    {
        SLTNode* prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
        pos = NULL;//也可以不置空
    }
}

test.c:

#include "SList.h"
void TestSList4()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListInsertAfter(plist->next, 20);
    SListPrint(plist);
    SListErase(&plist, plist->next->next);
    SListPrint(plist);
}
int main()
{
    TestSList4();
    return 0;
}

3.10 销毁

SList.h:

void SListDestory(SLTNode** pphead);//销毁

SList.c:

void SListDestory(SLTNode** pphead)
{
    assert(pphead);
    SLTNode* cur = *pphead;
    while (cur)
    {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

4.完整代码展示

SList.h:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDataType;
typedef struct SListNode
{
    SLTDataType data;
    struct SListNode* next;
}SLTNode;
void SListPrint(SLTNode* phead);//打印
SLTNode* BuyListNode(SLTDataType x);//动态申请结点
void SListPushBack(SLTNode** pphead, SLTDataType x);//尾插
void SListPushFront(SLTNode** pphead, SLTDataType x);//头插
void SLisePopBack(SLTNode** pphead);//尾删
void SListPopFront(SLTNode** pphead);//头删
SLTNode* SListFind(SLTNode* phead, SLTDataType x);//查找
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//前插
void SListInsertAfter(SLTNode* pos, SLTDataType x);//后插
void SListErase(SLTNode** pphead, SLTNode* pos);//删除
void SListDestory(SLTNode** pphead);//销毁

SList.c:

#include "SList.h"
void SListPrint(SLTNode* phead)
{
    SLTNode* cur = phead;
    while (cur != NULL)
    {
        printf("%d->", cur->data);
        cur = cur->next;
    }
    printf("NULL\n");
}

SLTNode* BuyListNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    newnode->data = x;
    newnode->next = NULL;
    return newnode;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);
    if (*pphead == NULL)
    {
        *pphead = newnode;
    }
    else
    {
        //找到尾结点
        SLTNode* tail = *pphead;
        while (tail->next != NULL)
        {
            tail = tail->next;
        }
        tail->next = newnode;
    }
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
    SLTNode* newcode = BuyListNode(x);
    newcode->next = *pphead;
    *pphead = newcode;
}

void SLisePopBack(SLTNode** pphead)
{
    SLTNode* prev = NULL;
    SLTNode* tail = *pphead;
    while (tail->next != NULL)
    {
        prev = tail;
        tail = tail->next;
    }
    free(tail);
    tail = NULL;
    prev->next = NULL;
}

void SListPopFront(SLTNode** pphead)
{
    assert(*pphead != NULL);
    SLTNode* next = (*pphead)->next;
    free(*pphead);
    *pphead = next;
}

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
    SLTNode* cur = phead;
    while (cur)
    {
        if (cur->data == x)
        {
            return cur;
        }
        else
        {
            cur = cur->next;
        }
    }
    return NULL;
}

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);
    if (*pphead == pos)
    {
        newnode->next = *pphead;
        *pphead = newnode;
    }
    else
    {
        //找到pos前一个位置
        SLTNode* posPrew = *pphead;
        while (posPrew->next != pos)
        {
            posPrew = posPrew->next;
        }
        posPrew->next = newnode;
        newnode->next = pos;
    }
}

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
    SLTNode* newnode = BuyListNode(x);
    newnode->next = pos->next;
    pos->next = newnode;
}

void SListErase(SLTNode** pphead, SLTNode* pos)
{
    //头删，也可直接调用SListPopFront接口
    if (*pphead == pos)
    {
        *pphead = pos->next;
        free(pos);
        pos = NULL;//也可以不置空
    }
    else
    {
        SLTNode* prev = *pphead;
        while (prev->next != pos)
        {
            prev = prev->next;
        }
        prev->next = pos->next;
        free(pos);
        pos = NULL;//也可以不置空
    }
}

void SListDestory(SLTNode** pphead)
{
    assert(pphead);
    SLTNode* cur = *pphead;
    while (cur)
    {
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

test.c:

#include "SList.h"
void TestSList1()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListPushFront(&plist, 1);
    SListPushFront(&plist, 2);
    SListPushFront(&plist, 3);
    SListPrint(plist);
    SLisePopBack(&plist);
    SListPrint(plist);
    SListPopFront(&plist);
    SListPrint(plist);
}
void TestSList2()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPushBack(&plist, 2);
    //Find接口有两个作用
    //1.找    2.修改
    SLTNode* pos = SListFind(plist, 2);
    int i = 1;
    while (pos)
    {
        printf("第%d个pos结点：%p->%d\n", i++, pos, pos->data);
        pos = SListFind(pos->next, 2);
    }
}
void TestSList3()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SLTNode* pos = SListFind(plist, 2);
    if (pos)
    {
        SListInsert(&plist, pos,20);
    }
    SListPrint(plist);
}
void TestSList4()
{
    SLTNode* plist = NULL;
    SListPushBack(&plist, 1);
    SListPushBack(&plist, 2);
    SListPushBack(&plist, 3);
    SListPrint(plist);
    SListInsertAfter(plist->next, 20);
    SListPrint(plist);
    SListErase(&plist, plist->next->next);
    SListPrint(plist);
}
int main()
{
    //TestSList1();
    //TestSList2();
    //TestSList3();
    TestSList4();
    return 0;
}

5.链表OJ 题

5.1 移除链表元素

删除链表中等于给定值 val 的所有节点。

链接：https://leetcode.cn/problems/remove-linked-list-elements/description/

struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* prev=NULL,*cur=head;
    while(cur)
    {
        if(cur->val==val)
        {
            if(cur==head)
            {
                //头删或者中间删除
                head=cur->next;
                free(cur);
                cur=head;
            }
            else
            {
                prev->next=cur->next;
                free(cur);
                cur=prev->next;
            }
        }
        else
        {
            //迭代向后走
            prev=cur;
            cur=cur->next;
        }
    }
    return head;
}

5.2 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

链接：https://leetcode.cn/problems/reverse-linked-list/description/

法一：画图+调试

struct ListNode* reverseList(struct ListNode* head){
    if(head==NULL)
    {
        return NULL;
    }
    struct ListNode* n1,*n2,*n3;
    n1=NULL;
    n2=head;
    n3=head->next;
    while(n2)
    {
       //核心逻辑
       n2->next=n1;
       //迭代
       n1=n2;
       n2=n3;
       if(n3!=NULL)
          n3=n3->next;
    }
    return n1;
}

法二：头插法

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* cur=head;
    struct ListNode* newhead=NULL;
    while(cur)
    {
        struct ListNode* next =cur->next;
        //头插
        cur->next=newhead;
        //迭代
        newhead=cur;
        cur=next;
    }
    return newhead;
}

5.3 链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

链接：https://leetcode.cn/problems/middle-of-the-linked-list/description/

//步幅法
struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow=head,*fast=head;
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

5.4 链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

链接：https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

 //千分尺法
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* fast=pListHead,*slow=pListHead;
    while(k--)
    {
        if ((fast==NULL)) {
            return  NULL;
        }
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return  slow;;
}

5.5 合并链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

链接：https://leetcode.cn/problems/merge-two-sorted-lists/description/

思路：依次比较链表中的结点，每次取小的结点，尾插到新链表即可

法一：

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    //如果链表为空，返回另一个
    if(l1==NULL)
    {
        return l2;
    }
    if(l2==NULL)
    {
        return l1;
    }

    struct ListNode* head=NULL,*tail=NULL;
    //先取小的做第一个
    if(l1->val<l2->val)
    {
        head=tail=l1;
        l1=l1->next;
    }
    else
    {
        head=tail=l2;
        l2=l2->next;
    }
    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            tail->next=l1;
            tail=l1;
            l1=l1->next;
        }
        else
        {
            tail->next=l2;
            tail=l2;
            l2=l2->next;
        }
    }
    if(l1)
    {
        tail->next=l1;
    }
    if(l2)
    {
        tail->next=l2;
    }
    return head;
}

法二：哨兵结点法

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    //如果链表为空，返回另一个
    if(l1==NULL)
    {
        return l2;
    }
    if(l2==NULL)
    {
        return l1;
    }

    struct ListNode* head=NULL,*tail=NULL;
    //哨兵位的头结点
    head=tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            tail->next=l1;
            tail=l1;
            l1=l1->next;
        }
        else
        {
            tail->next=l2;
            tail=l2;
            l2=l2->next;
        }
    }
    if(l1)
    {
        tail->next=l1;
    }
    if(l2)
    {
        tail->next=l2;
    }
    struct ListNode* list = head->next;
    free(head);
    return list;
}

5.6 链表分割

现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

链接：https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* lessHead,*lessTail,*greaterHead,*greaterTail;

        //开一个哨兵位头结点，方便尾插
        lessHead=lessTail=(struct ListNode*)malloc((sizeof(struct ListNode)));
        lessTail->next=NULL;
        greaterHead=greaterTail=(struct ListNode*)malloc((sizeof(struct ListNode)));
        greaterTail->next=NULL;

        struct ListNode* cur=pHead;
        while(cur)
        {
            if(cur->val<x)
            {
                lessTail->next=cur;
                lessTail=cur;
            }
            else 
            {
                greaterTail->next=cur;
                greaterTail=cur;
            }
            cur=cur->next;
        }
        
        lessTail->next=greaterHead->next;
        greaterTail->next=NULL;//易丢
        
        struct ListNode* newHead=lessHead->next;
        free(lessHead);
        free(greaterHead);
        
        return  newHead;
    }
};

5.7 链表的回文结构

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

链接：https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId=49&&tqId=29370&rp=1&ru=/activity/oj&qru=/ta/2016test/question-ranking

struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* cur = head;
    struct ListNode* newhead = NULL;
    while (cur) {
        struct ListNode* next = cur->next;
        //头插
        cur->next = newhead;
        //迭代
        newhead = cur;
        cur = next;
    }
    return newhead;
}

class PalindromeList {
  public:
    bool chkPalindrome(ListNode* A) {
        struct ListNode* mid=middleNode(A);
        struct ListNode* rHead=reverseList(mid);

        struct ListNode* curA=A;
        struct ListNode* curR=rHead;
        while(curA&&curR)
        {
            if(curA->val!=curR->val)
            {
                return false;
            }
            else
            {
                curA=curA->next;
                curR=curR->next;
            }
        }
        return  true;
    }
};

5.8 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/description/

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* tailA=headA;
    struct ListNode* tailB=headB;
    int lenA=1;
    while(tailA->next)
    {
        lenA++;
        tailA=tailA->next;
    }
    int lenB=1;
    while(tailB->next)
    {
        lenB++;
        tailB=tailB->next;
    }

    //不相交
    if(tailA!=tailB)
    {
        return NULL;
    }

    int gap=abs(lenA-lenB);
    //长的先走，之后再同时走
    struct ListNode* longList=headA;
    struct ListNode* shortList=headB;
    if(lenA<lenB)
    {
        shortList=headA;
        longList=headB;
    }
    while(gap--)
    {
        longList=longList->next;
    }
    while(longList!=shortList)
    {
        longList=longList->next;
        shortList=shortList->next;
    }
    return longList;
}

「已注销」
关注
  • 34
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 42
    评论
专栏目录
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构 单链表 约瑟夫问题
08-27
数据结构 单链表 约瑟夫问题
常见的链表题目
guoyiqi
08-25 124
一些常见的单链表题目，总结思路和实现代码。 1.单链表的反序 2.给单链表建环 3.检测单链表是否有环 4.给单链表解环 5.检测两条链表是否相交 6.不输入头节点，删除单链表的指定节点（只给定待删除节点指针） 1.单链表的反序 //逆转链表，并返回逆转后的头节点 node* reverse(node *head) { if(head == NULL || he...
单链表大全
jinghang2000的博客
12-29 307
一.单链表的定义 1.什么是单链表： 每个节点除了存储数据元素，还要存储指向下一个节点的指针 （优点：不要求大片连续空间，改变容量方便 缺点：不可随机存储，要消耗一定空间存放指针） 2.代码定义一个单链表 #include <stdio.h> //不带头节点 写代码更麻烦 typedef struct LNode { int data; //数据域 可以用其他数据类型 struct LNode *next; }LNode, *LinkList; //LinkList
[数据结构]链表之单链表（详解）
热门推荐
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 4546
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构(单链表)
q270384247的博客
02-19 122
数据结构(单链表) 1.简介: 你可以把链表看成是一条链子,一环扣一环,必须通过上一个节点找到下一个节点next 2.单向链表的每一个节点都包含一个数据和一个指向下一个节点的地址值(头结点和未节点除外,头结点没有数据只有一个地址值,尾节点的next地址值是空的,最后面因为没有数据了),链表图片 3,应用场景 高速缓存的应用,用链表存储数据极快! 因为你们知道链表的插入和删除是很快的,但是查询很慢...
数据结构单链表——建立单链表
wifi_824的博客
08-24 2814
0.建立单链表前的工作。1.头插法建立单链表。2.尾插法建立单链表。
数据结构单链表插入和删除操作
weixin_45349814的博客
04-22 8021
单链表的创建及插入删除操作
数据结构单链表实现通讯录
polkmn666的博客
09-27 1万+
1.功能介绍 基于上一篇对单链表的基本操作的了解，为了巩固相关知识点，于是用单链表写了一个通讯录作为巩固和加深对相关知识点的理解。基本的原理都是对单链表基本操作的应用。主要实现了一下几个简单的功能。 初始化通讯录 建立通讯录（头插法和尾插法） 删除联系人 修改联系人 查找联系人 插入联系人信息(前插法和后插法) 遍历通讯录 清空通讯录 在建立通讯录和插入联系人信息时，会对ID进行判断，重复则提示重新输入，在插入联系人时若输入的插入位置错误，会提示是否将新联系人插入到通讯录最后面。 2.具体实现 功能就
数据结构单链表最大值
m0_63142359的博客
10-24 1391
数据结构单链表最大值
数据结构单链表的创建以及简单操作
Makeitok_的博客
07-29 8828
数据结构初学-单链表的创建以及简单操作
数据结构单链表
01-08
数据结构的一些讲解，供学习者参考，也顺带作为复习需要源代码的欢迎下载，免积分，共同学习，家下来每天都会分享一篇，持续一个星期
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
数据结构之B树
嫦娥妹妹等等我的博客
06-16 330
**节点的大小**：每个节点至少有 `t - 1` 个键值（除根节点外），最多有 `2t - 1` 个键值。1. **高效的磁盘读取**：由于每个节点包含多个键值和指针，B树减少了磁盘I/O操作的次数，提高了查找和更新的效率。- **数据库系统**：B树及其变种（如B+树、B*树）广泛用于数据库索引结构，支持快速的数据插入、删除和查询。- 每个节点最多有 `2t - 1` 个键值和 `2t` 个子节点指针，其中 `t` 是B树的最小度数。- **平衡性**：B树是一棵平衡树，所有叶子节点位于同一层。
数据结构：冒泡排序，选择排序，插入排序，希尔排序的实现分析
Zhihuiguoz的博客
06-16 688
这篇博客主要介绍了一些基本的排序算法，从算法思想，算法步骤，动图演示，代码实现，复杂度分析，稳定性分析这几个方面详细的介绍了冒泡排序，选择排序，插入排序，希尔排序的运用。并对其进行了优化实现，简单易懂，很好上手。
排序——希尔排序
2301_80662872的博客
06-16 384
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
北航第六次数据结构与程序设计作业（查找与排序）选填题
最新发布
zxy13149285776的博客
06-16 542
但是我们可以根据满二叉树h=log（n+1）大概估计一下，如果是三层的满二叉树，那么n为7，如果是4层的满二叉树，则n为15。的次数，而不是18交换的次数，18先和10比较，发现18比10大。从arr[1]到arr[n-1]，如果本身就递增，那么每个元素只跟自己的直接前驱元素比较一次就行，那么比较了n-1次。发生冲突，说明余数一致，说明能整除，放眼观去，63,9,45都能整除，因此3个和18冲突。看好了，是在序列中的位置，不是下标，位置从1开始，下标从0开始。若查找一个不存在的元素，说明进行了深度次比较。
c语言数据结构单链表长度
03-27
C语言数据结构单链表长度可以通过遍历单链表来计算。具体实现方法如下： 1. 定义一个变量count，用于记录单链表长度，初始值为0。 2. 从单链表的头节点开始，依次遍历单链表的每个节点，每遍历一个节点，count的值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 42
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值