LINKLIST

已于 2023-09-20 15:11:40 修改
阅读量52 收藏
点赞数
文章标签： 数据结构 c++
于 2023-09-14 15:29:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63957897/article/details/132874703
版权

目录

单链表

typedef int Elemtype;

typedef struct LinkNode{
    Elemtype data;
    struct LinkNode * next;
}LinkNode,*LinkList;

头指针和头节点

skip

头插法

#include <iostream>

typedef int Elemtype;

typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

void insert(LinkList L, int enterList[], int listLength) {
    int i = 0;
    while (i < listLength) {
        LinkNode* pNode = (LinkNode*)malloc(sizeof(LinkNode));
        pNode->data = enterList[i];
        // 插入一个数据结点时，将插入节点的指针改成插入位置的后继
        pNode->next = L->next;
        L->next = pNode;
        i++;
    }
}

LinkNode* create(int enterList[], int listLength) {
    LinkNode* L = NULL;
    L = (LinkNode*)malloc(sizeof(LinkNode));
    L->next = NULL; // 创建了一个只带头节点的空链表
    insert(L, enterList, listLength);
    return L; // 返回头结点的地址，等于返回了整个链表的信息
}

int main() {
    int enterList[] = {1, 2, 3, 4, 5};
    int listLength = sizeof(enterList) / sizeof(enterList[0]);

    LinkNode* L = create(enterList, listLength);
    
    // 遍历链表并输出元素
    std::cout << "链表元素: ";
    LinkNode* current = L->next; // 跳过头节点
    while (current != NULL) {
        std::cout << current->data << " ";
        current = current->next;
    }
    
    // 释放链表的内存
    while (current) {
        LinkNode* temp = current;
        current = current->next;
        free(temp);
    }
    free(L);
    
    return 0;
}

尾插法

#include <stdio.h>
#include <stdlib.h>

typedef int Elemtype;

typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

void create(LinkList &L, int enterList[], int length) {
    L = (LinkNode *) malloc(sizeof(LinkNode));
    L->next = NULL;
    LinkNode *pTail = L;
    int i = 0;
    while (i < length) {
        LinkNode *pNode = (LinkNode *) malloc(sizeof(LinkNode));
        pNode->data = enterList[i];
        pNode->next = pTail->next; // 先将插入结点指针域修改为pTail的后继
        pTail->next = pNode; // 尾结点pTail的后继更新为pNode
        pTail = pNode; // 此时pnode为最后一个结点，更新ptail指针，使其指向新的尾结点
        ++i;
    }
}

void printLinkList(LinkList L) {
    LinkNode *pNode = L->next;
    while (NULL != pNode) {
        printf("%d ", pNode->data);
        pNode = pNode->next;
    }
    printf("\n");
}

int main() {
    LinkList myList;
    int data[] = {1, 2, 3, 4, 5};
    int length = sizeof(data) / sizeof(data[0]);

    create(myList, data, length);

    printf("Created Linked List: ");
    printLinkList(myList);

    return 0;
}

单链表递归

#include <stdio.h>
#include <stdlib.h>
#include <limits.h> // 为了使用INT_MIN常量

typedef int Elemtype;

typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

// getMax函数的定义
int getMax(LinkNode *pCur) {
    if (NULL == pCur) {
        return INT_MIN; // 使用INT_MIN来表示负无穷
    }
    int temp = getMax(pCur->next);
    return temp > pCur->data ? temp : pCur->data;
}

// getNodesNum函数的定义
int getNodesNum(LinkNode *pCur) {
    if (NULL == pCur) {
        return 0;
    }
    return 1 + getNodesNum(pCur->next);
}

// getAvg函数的定义，接受节点数量作为参数
double getAvg(LinkNode *pCur, int num) {
    if (NULL == pCur || num == 0) {
        return 0.0; // 如果链表为空或者节点数量为0，返回0.0
    }
    return (double)pCur->data / num + getAvg(pCur->next, num);
}

// 创建链表函数
LinkList createLinkedList(int data[], int length) {
    LinkList myList = (LinkNode *)malloc(sizeof(LinkNode));
    myList->next = NULL;
    LinkNode *pTail = myList;
    
    for (int i = 0; i < length; ++i) {
        LinkNode *pNode = (LinkNode *)malloc(sizeof(LinkNode));
        pNode->data = data[i];
        pNode->next = pTail->next;
        pTail->next = pNode;
        pTail = pNode;
    }
    
    return myList;
}

// 释放链表内存
void freeLinkedList(LinkList myList) {
    LinkNode *pNode = myList;
    while (pNode != NULL) {
        LinkNode *temp = pNode;
        pNode = pNode->next;
        free(temp);
    }
}

int main() {
    int data[] = {1, 2, 3, 4, 5};
    int length = sizeof(data) / sizeof(data[0]);

    // 创建链表
    LinkList myList = createLinkedList(data, length);

    // 计算链表中的最大值
    int max = getMax(myList->next);
    printf("链表中的最大值: %d\n", max);

    // 计算链表中的节点数量
    int nodeCount = getNodesNum(myList->next);
    printf("链表中的节点数量: %d\n", nodeCount);

    // 计算链表中节点数据的平均值
    double avg = getAvg(myList->next, nodeCount);
    printf("链表中节点数据的平均值: %lf\n", avg);

    // 释放链表内存
    freeLinkedList(myList);

    return 0;
}

返回第i个元素

【test】

typedef int Elemtype;
typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

void getIth(LinkList L,int ith,Elemtype e){
    int count = 0;
    LinkNode * pCur = L->next;//从第一个数据节点开始访问
    while(pCur !=NULL){
        count+=1;
        if(count==ith){
            return pCur;
        }
        pCur=pCur->next;
    }
    return NULL;
    
}


int main(){
    int enterList[] = {1,2,3,4,5};
    int listLength = 5;
    LinkList L =create(enterList,listLength);
    LinkNode*pNode = getIth(L,3);
    if(pNode!=NULL){
        printf("%d\n",pNode->data);
    }
    print(L);


}

第i个结点前插入

typedef int Elemtype;
typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

void insertIth(LinkList L,int ith,Elemtype e){
    int count = 0;
    LinkNode * preCur = L;//第一个数据节点的前驱
    LinkNode * pCur = L->next;//从第一个数据节点开始访问
    while(pCur !=NULL){
        count+=1;
        if(count==ith){
            LinkNode * pNode = (LinkNode *)malloc(sizeof(LinkNode));
            pNode->data = e;
            pNode->next = preCur->next;
            preCur->next = pNode;
            break;
        }
        preCur= pCur;
        pCur = pCur->next;
    }
    return NULL;
    
}


int main(){
    int enterList[] = {1,2,3,4,5};
    int listLength = 5;
    LinkList L =create(enterList,listLength);
    print(L);
    insertIth(L,3,8);
    print(L);


}

查找倒数第m个节点

typedef int Elemtype;
typedef struct LinkNode {
    Elemtype data;
    struct LinkNode* next;
} LinkNode, *LinkList;

void getData(int m,LinkList L){
    //访问链表第m+1个节点
    LinkList pCur = L->next;
    int count = 0;
    while(pCur != NULL){
        ++count;
        if(count==m+1){
            break;
        }
        pCur= pCur->next;
    }
    //两指针同时移动查找相对位置的节点
    LinkNode* pNode = L->next;
    while(pCur!=NULL){
        pNode= pNode->next;
        pCur= pCur->next;
    }
    printf("%d",pNode->data);

}

查找第j+len个结点

LinkNode* getPre(int ith,LinkList L){
    LinkNode* preCur = L;
    LinkNode pCur = L->next;
    int count = 0;
    while(pCur!=NULL){
        ++count;
        if(count==ith){
            return preCur;
        }
        preCur= pCur;
        pCur=pCur->next;
    }

}


void oper(LinkList &La,LinkList &Lb,int j,int len){
    LinkNode* pLa = (LinkNode*)malloc(sizeof(LinkNode));
    pLa->next = La;
    La = pLa;

    LinkNode* pLb = (LinkNode*)malloc(sizeof(LinkNode));
    pLb->next = Lb;
    Lb = pLb;
    LinkNode* preJthLa = getPre(j,La);
    LinkNode* preJLenLa = getPre(j+len-1,La);
    LinkNode* preJthLb = getPre(j,Lb);

    LinkNode* pNode = preJLenLa->next->next;

    preJLenLa->next->next= preJLenLb->next;
    preJthLb->next = preJthLa ->next;
    preJLenLa->next= pNode;

    print(La);
    print(Lb);


}

前一半，后一半

int isSym(LinkList L,int n){
    LinkNode* pCur = L->next;
    int count= 0;
    while(pCur!=NULL){
        ++count;
        if(n/2==count){
            break;
        }
        pCur = pcur->next;
    }
    LinkNode* pLast= NULL;

    if(n%2!=0){
        pLast =pCur->next->next;
    }
    else{
        pLast =pCur->next;
    }
    pCur=L->next;
    while(pLast!=NULL){
        if(pCur->data != pLast->data){
            return 0;
        }
        pCur=pCur->next;
        pLast= pLast->next;
    }
    return 1;
}
丰川祥子
关注
LinkList.cpp
01-22
该代码是单链表和其基本操作，如链表的创建与销毁；链表的插入、删除、查询等操作，查询可按元素查询也可指定位置；还有判断空表及表长等操作。
手写linklist demo
08-21
在本“手写linklist demo”中，我们将深入理解链表的原理，并通过编写代码来实现一个简单的链表示例。下面将详细讨论链表的基本概念、结构以及如何实现。 链表是一种线性数据结构，与数组不同，它不连续存储元素。...
linkList
weixin_39191862的博客
12-06 697
linkList
LinkList
chen_zan_yu_的博客
01-08 591
LinkList.c  /*************************************** * author: * mail: * desc:链表的线性实现函数 * * **************************************/ #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include ...
linklist特点
Smile Wang
07-29 567
Linklist
yancuidandan的专栏
12-05 1010
#ifndef Linklist_H //避免重复包含Linklist.h头文件 #define Linklist_H template //定义单链表的结点 struct Node { DataType data; Node *next; }; template //类Li
Lnode和*linklist
qq_63781908的博客
05-01 400
struct Lnode *next是因为单链表的指针域，指向的是和当前节点一样的数据类型，也是一个有着两部分（指针域和数据域）的结点，所以也定义为struct Lnode类型的数据，并且这个数据是指针类型的，所以前边加*。比如，linklist l，那么l是单链表的头指针（为什么是指针，因为linklist本身带有*）。而lnode *p，p指的是单链表中某个结点的指针。ps:elemtype data这里，data的数据类型待用户自己定义，可以是之前说过的图书类型Book，也可以是int等等。
（图解）解析链表中的LinkList *L, LinkList L和LinkList &L，结构体指针和指向结构体指针的指针的区别
在夜里行走的博客
10-13 7714
解析LinkList L和LinkList *L，结构体指针和指向结构体指针的指针
02、单链表LinkList
大王怕我去巡山
12-11 1568
LinkList.h #pragma once typedef int DataType; typedef struct Node { DataType data; struct Node* next; }ListNode,*LinkList; /* 定义方式: 线性表的链式存储，是采用一组任意的存储单元存放线性表的元素 除了存储元素本身的信息外，还要存储一个指示其直接后继元素的信息(直接后继元素的地址)。 这两个部分构成的存储结构称为节点（node）。即节点包含两个域：数据域和指针域。 通过指针
C++Linklist
bangdian1728的博客
07-10 622
#if 1 #ifndef _LINKLIST_H_ #define _LINKLIST_H_ #include <iterator> #pragma warning (disable : 26495) template<typename T> class linklist{ public: using uint = unsi...
linklist问题汇总
skunswjtu的博客
03-25 369
1.左神视频中，有一个将linklist分为荷兰国旗样式的方法：其中最后部分的串联方法，经过验证，可变为下面形式： 2.在不用hashmap将linklist复制的方法中，最后拆分两链表要用如下方法，要不然会导致空指针错误。（一定不能出现null.next的情况！！！！！） ...
ArrayList、LinkList区别
苏打水解渴的博客
09-09 1139
文章目录ArrayList和LinkList对比存储结构查询效率删除添加元素效率内存利用 ArrayList和LinkList对比 ArrayList LinkList 数据结构 可变数组 双向链表 线程安全 不安全 不安全 查询效率 高 低 删除添加元素效率 低 高 内存利用 低 高 存储结构 ArrayList采用可变数组的数据结构，每次元素操作之前就会检...
linklist_linklist_
10-04
在本示例中，"linklist_linklist_" 提供了一个链表的实现，包括了对链表的基本操作。这个程序可以作为学习数据结构的实践案例。 链表与数组不同，它不连续存储数据，而是通过节点之间的引用（或称为指针）来连接...
LinkList.c
10-03
LinkList.c
C#数据结构之单链表(LinkList)实例详解
01-20
本文实例讲述了C#数据结构之单链表(LinkList)实现方法。分享给大家供大家参考，具体如下： 这里我们来看下“单链表(LinkList)”。在上一篇《C#数据结构之顺序表(SeqList)实例详解》的最后，我们指出了：顺序表要求...
数据结构编程实践20讲(Python版)—06二叉搜索树
最新发布
AnFany
10-08 1142
数据结构编程实践20讲(Python版)—06二叉搜索树
每日学习一个数据结构-树
wendao76的专栏
10-03 1157
树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。在非空树中，有且仅有一个特定的节点被称为根（root），其余节点可分为m（m>0）个互不相交的有限集T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且被称为根的子树（Subtree）。访问时机：三种遍历方式的主要区别在于访问根节点的时机不同。在前序遍历中，根节点在左、右子节点之前被访问；在中序遍历中，根节点在左、右子节点之间被访问；在后序遍历中，根节点在左、右子节点之后被访问。应用场景。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1284
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
m0_46676283的博客
10-08 311
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
Java实现双向链表LinkList
LinkList的实现 LinkList是一种常用的数据结构，在Java中可以使用双向链表来实现。下面是LinkList的实现细节： **LinkList的定义** LinkList是一个泛型类，使用两个指针header和last来指向链表的头节点和尾节点。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值