单链表的操作

最新推荐文章于 2024-09-11 20:39:26 发布
最新推荐文章于 2024-09-11 20:39:26 发布
阅读量382 收藏 3
点赞数 4
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52417518/article/details/139402231
版权

【1】概念

  1. 单向链表：简称单链表 。当前结点可以找到后一个结点，但是后一个结点无法找到当前结点。

  1. 链表的头结点：放在第一个有效结点之前，其数据域一般没有意义，或者存放链表长度。
    1. 头结点不是链表的必要元素
    2. 目的：为了操作统一和方便设立的，有了头结点后，在第一个元素前插入数据和删除第一个结点，就与其他结点操作一致了。
  2. 链表的头指针：指向链表第一个结点的指针。
    1. 头指针是链表的必要元素，只有知道头指针，才能找到链表。
    2. 若有头结点，则头指针指向头结点。

【2】操作单链表

1、单链表的初始化函数

注意：单链表的头结点存储这单链表的有效长度，由于单链表是数据结点的时候，单链表数据域存储数据，由此，单链表的结点是头结点还是数据结点，都是其中一种，所以在定义存储单链表结点的数据体时，使用union（联合体）定义数据域

​
/*
  4  * function:   创建一个空的单链表                                                                                     
  5  * @param [ in] 
  6  * @param [out] 
  7  * @return 返回单链表的头节点
  8  */
  9 linklist *linklist_init(void){
 10     linklist* head = (linklist*)malloc(sizeof(linklist));
 11     if(NULL == head){
 12         printf("头结点创建失败\n");
 13     }
 14     head->next = NULL;
 15     head->data.size = 0;      //链表的有效长度赋值为０
 16     return head;
 17 }

2、单链表的头插函数

 /*
  * function:    单链表的头插函数                                  
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 void linklist_headadd(linklist* list, datatype e){
     linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
     if(NULL == pnew_node){
         printf("申请新节点失败\n");
         return;
     }
     pnew_node->next = NULL;
     pnew_node->data.element = e;
     list->data.size++;
     pnew_node->next = list->next;
     list->next = pnew_node;
 }

3、单链表的尾插函数

在进行尾插时，我们不能直接找到尾结点，每次插入都需要循环遍历找到单链表的尾结点，时间复杂度O(n)

/*
 * function:    单链表中插入数据：尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linklist_tailadd(linklist* head, datatype e){
    linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
    if(NULL == pnew_node){
        printf("申请结点失败\n");
        return;
    }
    linklist* tail = head;
    for(; tail->next != NULL; tail=tail->next);
    pnew_node->next = NULL;
    pnew_node->data.element = e;
    tail->next = pnew_node;
    tail = pnew_node;
    head->data.size++;
}

4、单链表的遍历函数

当链表为空的时候，这是遍历单链表就没哟意义，遍历就是循环打印，直到遍历指针p指向空

                                     
/*
 * function:    遍历单链表
    linklist* pnode;
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linklist_traverse(linklist* head){
    if(linklist_isempty(head)){
        printf("单链表为空\n");
        return;
    }
    linklist* p = head->next;
    for(;p != NULL; p = p->next){
        printf(":%d\n", p->data.element);
    }
}

5、单链表的判空

由于在创建单链表时，创建了头结点，所以当头结点的next为NULL时，此时单链表为空。

/*
 * function:    单链表判空
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int linklist_isempty(linklist* list){
    return list->next == NULL;
}

6、单链表的删除结点  头删

在删除结点时，要将头结点存储的有效数据长度减一

/*  
 * function:    单链表删除节点 头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype linklist_headdel(linklist* list){
    if(linklist_isempty(list)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    linklist* pnode = list->next;   //待删除结点
    int res = pnode->data.element;
    list->next = pnode->next;
    pnode->next = NULL;
    list->data.size--;         //单链表有效数据-1
    free(pnode);
    return res;

7、单链表的删除结点  尾删

要尾删除结点，找到尾结点是无法就删除的，我们需要找到尾结点的前驱结点，通过前驱结点对尾结点进行删除。所以我们需要两个指针，一个遍历指针遍历单链表，找到尾结点，另一个遍历指针的前驱结点，到找到尾结点时，就知道其前驱

/*                                                                            
 * function:   单链表删除尾结点 
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype linklist_taildel(linklist* head){
    if(linklist_isempty(head)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    int res;
    linklist* pretail = head;
    linklist* tail = pretail->next;
    for(; tail->next != NULL; tail = tail->next, pretail = pretail->next);
    pretail->next = NULL;
    res = tail->data.element;
    head->data.size--;
    free(tail);
    return res;
}

8、单链表的按位置插入

找到插入位置的前驱结点，当要插入结点的位置为n时，到n-1的时后就是插入位置的前驱结点。

（前置++，先加一，然后在返回其值）

/*
 * function:    按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linklist_insertIndex(linklist* head, datatype e, int index){
    if(index < 1 || index > head->data.size + 1){  //要添加的位置超过了单链表的有效长度加１
        printf("插入位置不合法\n");
        return;
    }
    linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
    pnew_node->data.element = e;
    linklist* p = head;   //插入位置前驱结点
    while(--index){       //找到插入位置前驱结点
        p = p->next;
    }
    pnew_node->next = p->next;
    p->next = pnew_node;
    head->data.size++;
}

9、单链表的按位置删除

同按位置插入逻辑相同，需要找到删除位置的前驱结点

/*
 * function:   单链表删除尾结点 
 * @param [ in] 
 * @param [out] 
 * @return                                                                 
 */
datatype linklist_taildel(linklist* head){
    if(linklist_isempty(head)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    int res;
    linklist* pretail = head;
    linklist* tail = pretail->next;
    for(; tail->next != NULL; tail = tail->next, pretail = pretail->next);
    pretail->next = NULL;
    res = tail->data.element;
    head->data.size--;
    free(tail);
    return res;

【3】单链表总代码

   1.  linklist.c

#include "linklist.h"

/*
 * function:   创建一个空的单链表
 * @param [ in] 
 * @param [out] 
 * @return 返回单链表的头节点
 */
linklist *linklist_init(void){
    linklist* head = (linklist*)malloc(sizeof(linklist));
    if(NULL == head){
        printf("头结点创建失败\n");
    }
    head->next = NULL;
    head->data.size = 0;      //链表的有效长度赋值为０
    return head;
}

/*
* function:    单链表的头插函数
   //linklist_traverse(phead);
* @param [ in] 
* @param [out] 
* @return      
*/
void linklist_headadd(linklist* list, datatype e){
   linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
   if(NULL == pnew_node){
       printf("申请新节点失败\n");
       return;
   }
   pnew_node->next = NULL;
   pnew_node->data.element = e;
   list->data.size++;
   pnew_node->next = list->next;
   list->next = pnew_node;
}

/*
 * function:    单链表中插入数据：尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linklist_tailadd(linklist* head, datatype e){
    linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
    if(NULL == pnew_node){
        printf("申请结点失败\n");
        return;
    }
    linklist* tail = head;
    for(; tail->next != NULL; tail=tail->next);
    pnew_node->next = NULL;
    pnew_node->data.element = e;
    tail->next = pnew_node;
    tail = pnew_node;
    head->data.size++;
}

/*
 * function:    遍历单链表
    linklist* pnode;
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void linklist_traverse(linklist* head){
    if(linklist_isempty(head)){
        printf("单链表为空\n");
        return;
    }
    linklist* p = head->next;
    for(;p != NULL; p = p->next){
        printf(":%d\n", p->data.element);
    }

}

/*
 * function:    单链表判空
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int linklist_isempty(linklist* list){
    return list->next == NULL;
}

/*                                                     
 * function:    单链表删除节点 头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype linklist_headdel(linklist* list){
    if(linklist_isempty(list)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    linklist* pnode = list->next;   //待删除结点
    int res = pnode->data.element;
    list->next = pnode->next;
    pnode->next = NULL;
    list->data.size--;         //单链表有效数据-1
    free(pnode);
    return res;
}

datatype linklist_taildel(linklist* head){
    if(linklist_isempty(head)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    int res;
    linklist* pretail = head;
    //linklist_traverse(phead);
    linklist* tail = pretail->next;
    for(; tail->next != NULL; tail = tail->next, pretail = pretail->next);
    pretail->next = NULL;
    res = tail->data.element;
    head->data.size--;
    free(tail);
    return res;                                                                 
}

 /*
  * function:    按位置插入
  * @param [ in] 
  * @param [out] 
  * @return                                                                                  
  */
 void linklist_insertIndex(linklist* head, datatype e, int index){
     if(index < 1 || index > head->data.size + 1){  //要添加的位置超过了单链表的有效长度加１
         printf("插入位置不合法\n");
         return;
     }
     linklist* pnew_node = (linklist*)malloc(sizeof(linklist));
     pnew_node->data.element = e;
     linklist* p = head;   //插入位置前驱结点
     while(--index){       //找到插入位置前驱结点
         p = p->next;
     }
     pnew_node->next = p->next;
     p->next = pnew_node;
     head->data.size++;
 }

/*
 * function:    按位置删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype linklist_Indexdel(linklist* head, int index){
    if(linklist_isempty(head)){
        printf("单链表为空，不能删除结点\n");
        return -1;
    }
    if(index < 1 ||index > head->data.size)   //要删除的位置超过了单链表的有效长度
    {
        printf("单链表插入位置不合法\n");
        return -2;
    }
    linklist* p = head;
    while(--index){
        p = p->next;
    }
    linklist* temp = p->next;
    datatype val = temp->data.element;
    p->next = temp->next;
    free(temp);
    head->data.size--;
    return val;
}

2. linklist.h

 #ifndef __LINKLIST_H__
 #define __LINKLIST_H__
 
 #include <stdio.h>
 #include <stdlib.h>
 
 typedef int datatype;
 
 
 union dataNode{
     int size;   //头结点是存储单链表长度
     datatype element;  //当结点为有效结点时，存储数据  
 };
 
 typedef struct node{
     struct node* next;    //指针域：存储下一个节点的首地址
     union dataNode data;
 }linklist;
                                                                                 
 linklist* linklist_init();                   //初始化单链表
 void linklist_headadd(linklist*, datatype);      //单链表添加元素
 void linklist_tailadd(linklist*, datatype);   //尾插法
 int linklist_isempty(linklist*);             //单链表判空
 datatype linklist_headdel(linklist*);            //单链表元素的删除
 datatype linklist_taildel(linklist*);         //尾删
 void linklist_traverse(linklist*);           //单链表遍历
 void linklist_insertIndex(linklist*, datatype, int);  //按位置插入
 datatype linklist_Indexdel(linklist*, int);  //按位置删除
 #endif

3. main.c

#include <stdio.h>
#include "linklist.h"

int main(int argc, const char *argv[])
{
    linklist* phead = linklist_init();



    //头插向单链表中添加元素
    linklist_headadd(phead, 1);
    linklist_headadd(phead, 2);
    linklist_headadd(phead, 3);
    linklist_headadd(phead, 4);
    //找到尾结点
    linklist_tailadd(phead,  10);
    //printf("size=%d\n", phead->data.size);

    //printf("val=%d\n", phead->next->data.element);
    //printf("del:%d\n", linklist_headdel(phead));
    //printf("del:%d\n", linklist_headdel(phead));
    //printf("del:%d\n", linklist_headdel(phead));
    //printf("del:%d\n", linklist_headdel(phead));

    //linklist_traverse(phead);
    //尾删除
    //printf("tail del:%d\n",linklist_taildel(phead));
    //printf("tail del:%d\n",linklist_taildel(phead));
    //printf("tail del:%d\n",linklist_taildel(phead));

    //按位置删除
    //printf("del 3:%d\n", linklist_Indexdel(phead, 5));
    //printf("del 3:%d\n", linklist_Indexdel(phead, 0));           
    //printf("size=%d\n", phead->data.size);

    //按位置插入
    linklist_insertIndex(phead, 20, 3);
    linklist_insertIndex(phead, 21, 7);
    //linklist_insertIndex(phead, 22, 9);  //插入位置不合法
    linklist_insertIndex(phead, 66, 1);


    linklist_traverse(phead);

    return 0;
}

“favor
关注
python单链表操作_单链表的基本操作(python)
weixin_42515380的博客
01-29 623
用python实现单链表的增删改查#!/usr/bin/python#coding: utf-8class Node(object):"数据域"def __init__(self, data, next = 0):self.data = dataself.next = nextclass LinkList(object):"处理类"def __init__(self):"head用来指向Node类...
单链表操作实例
whcs47的博客
03-03 819
单链表 查看题解 查看答案 题目描述 Time Limit: 1000 ms Memory Limit: 256 mb 设节点定义如下 struct Node { int Element; // 节点中的元素为整数类型 struct Node * Next; // 指向下一个节点 }; 从键盘输入5个整数，将这些整数插入到一个链表中，并按从小到大次序排列，最后输出这些整数。 输入输出格式 输入描述...
单链表操作
daza6336的博客
03-29 159
单链表操作 1.单链表的创建代码 posted on 2010-03-29 23:04过河的小兵 阅读(...) 评论(...) 编辑 收藏 ...
不带头结点的单链表操作
qq_40819191的博客
06-22 1563
不带头结点的单链表操作，包括插入、遍历、统计结点数等，要求写出数据结构算法思想及C语言实现函数 本文为博主原创文章，未经博主允许不得转载。 版权为陈博超所有，第一次于2021年06月22日发表于BLOG上 本BLOG上原创文章未经本人许可，不得用于商业用途。转载请经允许后注明出处，否则保留追究法律责任的权利。 * 算法如下： //不带头结点的单链表操作 #include<stdio.h> #include<malloc.h> typedef int DataType; ty
用C语言实现单链表操作
xuzhougeng blog
02-02 6627
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
c语言单链表操作实验,单链表的基本操作实验报告.doc
weixin_31635001的博客
05-25 1680
单链表的基本操作实验报告课程名称 数据结构与算法 成绩评定实验项目名称 单链表的基本操作 指导教师学生姓名 沈丽桃 学号 专业 10教育技术实验项目类型 验证 实验地点 科B305 实验时间年 月 日实验目的：实现线性链表的创建、查找、插入、删除与输出。基本原理：单链表的基本操作 “Please...
单链表基本操作
热门推荐
Sti1lWater的博客
12-24 1万+
单链表的基本操作
单链表的基本操作
黄超的博客
03-16 2744
概念：链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。结构：链表是有各个节点通过指针连接在一起的，每个节点分为数据域和指针域，每个节点的指针域指向下一个节点的地址，最后一个节点的指针域为空。逻辑结构如下图所示物理结构：逻辑结构看起来是连续的，但是由于链表的节点是在堆上开辟的，地址可能连续，也可能不连续。
C++递归实现不带头节点的单链表操作
henry594xiaoli的博客
07-17 3574
有一个不带头结点的单链表： 递归实现以下操作(强调：所有操作必须用递归完成）。 1，插入数据：13，15，8，4，8，3，4，8(可以用递归一次完成，也可以用递归将一个一维数组一个一个的尾部插入) 2，正向输出所有节点值 3，逆向输出所有节点值 4，输出单链表中数据结点个数 5，输出第k个节点的值（k由用户输入，要能给出错误情况） 6，在第k个位置上插入e元素。（k和e由用户输入，要能给出错误情况）...
c语言单链表存储字符串,请高手指点：以字符串为数据的单链表操作
weixin_39682940的博客
05-17 1049
请高手指点：以字符串为数据的单链表操作#include #include #define null 0typedef struct node{char *data;struct node *next;}linkstrnode;typedef linkstrnode *linkstring;main(){linkstring head;char *t;printf("\n please input ...
单链表操作基本运算_单链表的基本操作_
10-03
这个压缩包文件“单链表操作基本运算”包含了关于如何在编程中实现单链表基本操作的详细内容，特别是插入和删除操作。 单链表的插入操作通常分为头插法和尾插法。头插法是在链表的开头添加新节点，这需要更新头节点...
数据结构--单链表操作--实验报告.doc
07-11
在本实验中，我们关注的是单链表的创建、查找、插入和合并等基本操作。实验的目标是通过Visual C++编程语言来熟悉程序设计，并掌握单链表的操作。 1. **单链表的创建**： 创建单链表通常从一个空链表开始，然后...
C语言实现单链表，单链表操作
02-06
单链表操作：1.创建单链表 2.遍历单链表 3.获取单链表的长度 4.判断单链表是否为空 5.获取节点 6.在尾部插入指定元素 7.在指定位置插入指定元素 8.在头部插入指定元素 9.在尾部删除元素 10.删除所有元素 11.删除指定...
单链表操作算法合集
03-11
代码中包含单链表的常用操作，主要实现以下六个算法： 1.单链表的就地反转 2.链表相交或求公共起始节点 3.求链表倒数第n个节点 4.删除单个节点 5.判断链表是否有环 6.将2个递增的链表合并为递减链表 并全部调试通过...
14_L3缓存友好的数据结构
刘炫320的博客
09-11 640
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
21_动态规划与数据结构结合
刘炫320的博客
09-11 493
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 565
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
从头开始嵌入式第三十八天（数据结构 双向链表）
最新发布
qq_64792908的博客
09-11 629
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
单链表操作：插入与删除
"这篇资料主要介绍了单链表的基本操作，包括如何创建、插入、删除以及显示单链表。文中以带头结点的单链表为例，通过结构体A和结构体B来描述链表节点的数据结构，并展示了具体的代码实现过程。" 在计算机科学中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值