单链表入门（二）

最新推荐文章于 2020-03-14 17:47:07 发布
最新推荐文章于 2020-03-14 17:47:07 发布
阅读量423 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longintchar/article/details/78697310
版权

上篇博文，介绍了线性表、单链表等概念。这篇博文，我们就写代码来实现带头结点的非循环单链表。

1.结点的定义

typedef int element_t;

struct node
{
    element_t data;    //数据域
    struct node *next; //指针域
};

typedef struct node node_t;

2.初始化

void list_init(node_t *head)
{
    assert(head!=NULL);
    head->next = NULL;
}

head是头结点的地址，下文同。

3.求链表的长度

/* 求链表中元素的个数，为空则返回0 */
int list_length(node_t *head)
{
    assert(head!=NULL);

    int count = 0;
    while(head->next != NULL)
    {
        head = head->next;
        ++count;
    }
    return count;
}

4.判断链表是否为空

/* 判断链表是否为空， 为空返回1，不为空返回0 */
int list_is_empty(node_t *head)
{
    assert(head!=NULL); 
    return(head->next == NULL);
}

5.插入结点

/* 把新结点插入到某个结点的后面，此函数主要被其他函数调用 */
void insert_node(node_t *prev, node_t *new_node)
{
    assert(prev!=NULL);
    assert(new_node!=NULL);

    new_node->next = prev->next;//图中第一步
    prev->next = new_node; //图中第二步
}

这个函数表示把新结点new_node插入到结点prev的后面。
对于初学者，可能不好理解，请看示意图：

这里写图片描述

这里写图片描述

/* 已知新结点的地址，把新结点插入链表头 */
void list_insert_head(node_t *head, node_t *new_node)
{
    insert_node(head,new_node);
}

这种插入方法叫“头插法”。

/*  返回链表最后一个结点的地址，若链表为空，则返回头结点的地址 */
node_t *list_get_last(node_t *head) 
{
    assert(head!=NULL);

    while(head->next!=NULL)
        head = head->next;
    return head; 
}
/* 已知新结点的地址，把新结点插入链表尾 */
void list_insert_tail(node_t *head,node_t *new_node) 
{
    node_t *prev = list_get_last(head);
    insert_node(prev,new_node);
}

这种插入方法叫“尾插法”。

/* 向链表表头插入值为x的结点，成功返回0，失败返回-1 */
int insert_element_head(node_t *head, element_t x)
{
    assert(head!=NULL);

    node_t *new_node = (node_t *)malloc(sizeof(node_t));
    if(new_node==NULL)
    {
        printf("malloc failed\n");
        return -1;
    }
    new_node->data = x;
    list_insert_head(head,new_node);
    return 0;

}
/* 向链表末尾添加值为x的结点，成功返回0，失败返回-1 */
int insert_element_tail(node_t *head, element_t x)
{
    assert(head!=NULL);

    node_t *new_node = (node_t *)malloc(sizeof(node_t));
    if(new_node==NULL)
    {
        printf("malloc failed\n");
        return -1;
    }
    new_node->data = x;
    list_insert_tail(head,new_node);
    return 0;

}
/*  返回第pos个结点的前一个结点的地址，失败则返回NULL */
node_t* get_pos_prev_addr(node_t *head, int pos)
{
    assert(head!=NULL);
    if(list_is_empty(head))
    {
        printf("the list is empty, get failed\n");
        return NULL;
    }

    int length = list_length(head);
    if( (pos<1) || (pos>length) )
    {
        printf("pos is out of range\n");
        return NULL;
    }

    int count = 0;
    node_t *cur = head->next;
    node_t *prev = head;
    while(cur != NULL)
    {
        ++count;
        if(count == pos)
            return prev;

        prev = cur;
        cur = cur->next;
    }
}

/* 在pos位置插入新元素x，例如pos=3,则新元素在第3个位置.操作成功返回0，失败返回负数 */
int insert_element_to_pos(node_t *head, element_t x, int pos)
{
    assert(head!=NULL);

    int length = list_length(head);
    if(length==0)
    {
        printf("the list is empty, insert failed\n");
        return -1;
    }
    if( (pos<1) || (pos >length) )
    {
        printf("pos is out of range\n");
        return -2;
    }

    node_t *new_node = (node_t *)malloc(sizeof(node_t));
    if(new_node==NULL)
    {
        printf("malloc failed\n");
        return -3;
    }
    new_node->data = x;
    node_t *prev = get_pos_prev_addr(head,pos);
    insert_node(prev,new_node);

    return 0;
}

6.链表的遍历和安全遍历

/* 链表的遍历, todo参数由用户传入 */
void list_for_each(node_t *head, void(*todo)(node_t *node))
{
    assert(head != NULL);
    assert(todo != NULL);

    node_t *temp = head->next;
    while(temp != NULL)
    {
        todo(temp);
        temp = temp->next;
    }
}

/* 链表的安全遍历 */
void list_for_each_safe(node_t *head, void(*todo)(node_t *node))
{
    assert(head != NULL);
    assert(todo != NULL);

    node_t *cur = head->next;
    node_t *next;
    while(cur != NULL)
    {
        next = cur->next;
        todo(cur);
        cur = next;
    }
}

7.链表的清空

void list_clear(node_t *head)
{
    void(*todo)(node_t *node) = (void(*)(node_t *))free;
    list_for_each_safe(head,todo);
    list_init(head);
}

(void(*)(node_t *))free表示把free进行强制类型转换，转换成void(*)(node_t *)类型的指针。
此函数执行后，所有结点的空间被释放，只剩下头结点，成为一个空链表。

8.链表的销毁

void list_destroy(node_t *head)
{
    list_clear(head);
    free(head);
}

此函数执行后，所有结点的空间被释放，包括头结点。销毁后，链表就不复存在了。

9.链表的创建

链表的创建有很多种方法，可以头插，也可以尾插，这里仅举一例。

/* 从控制台创建链表，输入负数则停止。成功则返回头结点的地址，失败则返回NULL*/
node_t *list_create(void)
{
    node_t *head = (node_t *)malloc(sizeof(node_t));
    if(head==NULL)
    {
        printf("malloc failed\n");
        return NULL;
    }

    list_init(head); // 初始化头结点

    int data;
    printf("please input the number, negative will quite\n");
    scanf("%d", &data);

    while(data>=0)
    {
        node_t *new_node = (node_t *)malloc(sizeof(node_t));
        if(new_node==NULL)
        {
            printf("malloc failed\n");
            list_destroy(head);  //释放空间
            return NULL;
        }
        new_node->data = data;
        list_insert_head(head,new_node); //这句话也可以换成 list_insert_tail(head,new_node);

        printf("please input the number, negative will quite\n");
        scanf("%d", &data);
    }

    return head;
}

10.返回某个结点的地址或者值

/* 返回第pos个结点的地址（从1开始数），失败则返回NULL */

node_t* get_pos_addr(node_t *head, int pos)
{
    assert(head!=NULL);

    int length = list_length(head); 
    if(length==0)
    {
        printf("the list is empty, get failed\n");
        return NULL;
    }   
    if( (pos<1) || (pos>length) )
    {
        printf("pos is out of range\n");
        return NULL;
    }

    int count = 0;
    node_t *cur = head->next;
    while(cur != NULL)
    {
        ++count;
        if(count == pos)
        {
            return cur;
        }

        cur = cur->next;
    }
}

/* 返回第pos个结点的值（由输出型参数value指示），成功返回值为0，失败返回值为-1 */
int get_pos_element(node_t *head, int pos, element_t *value)
{
    node_t *p_node = get_pos_addr(head,pos);
    if(p_node)
    {
        *value = p_node->data;
        return 0;
    }
    else
    {
        return -1; //failed
    }

}

需要强调的是，参数value是输出型参数，第pos个结点的值由此指针指向。

11.查找

/* 查找具有给定值的第一个元素，成功则返回该结点的地址，失败返回NULL*/
node_t *find_element_pos(node_t *head, element_t x)
{
    assert(head!=NULL);
    if(list_is_empty(head))
        return NULL;

    node_t *temp = head->next;
    while(temp!=NULL)
    {
        if(temp->data == x)
            return temp;

        temp = temp->next;
    }

    return NULL;
}
/* 查找具有给定值的第一个元素，成功则返回该结点的前一个结点的地址，失败返回NULL*/
node_t *find_element_prev_pos(node_t *head, element_t x)
{
    assert(head!=NULL);
    if(list_is_empty(head))
        return NULL;

    node_t *temp = head->next;
    node_t *prev = head;
    while(temp!=NULL)
    {
        if(temp->data == x)
            return prev;

        prev = temp;
        temp = temp->next;

    }

    return NULL;
}

12.修改结点的值

/*  把第pos个结点的值修改为x,成功则返回0，失败返回-1 */
int modify_element(node_t *head, int pos, element_t x)
{
    node_t *p_node = get_pos_addr(head,pos);
    if(p_node)
    {
        p_node->data = x;
        return 0;
    }
    else
    {
        return -1; //failed
    }

}

13.删除结点

/* 已知某结点的地址为prev，删除它后面的那个结点, 此函数主要被其他函数调用 */
void delete_post_node(node_t *prev)
{
    assert(prev->next != NULL);

    node_t *node_del = prev->next;
    prev->next = node_del->next;
    free(node_del);
}

/* 删除第pos个结点，此结点的值由value指向。删除成功返回0，失败返回-1 */
int delete_pos_node(node_t *head, int pos, element_t *value)
{

    int length = list_length(head); 
    if(length==0)
    {
        printf("the list is empty, get failed\n");
        return -1;
    }
    if( (pos<1) || (pos >length) )
    {
        printf("pos is out of range\n");
        return -2;
    }

    node_t *prev = get_pos_prev_addr(head,pos);
    *value = prev->next->data;
    delete_post_node(prev);
    return 0;
}

/* 删除表头结点，此结点的值由value指向。删除成功返回0，失败返回-1 */
int delete_from_head(node_t *head, element_t *value)
{
    return delete_pos_node(head,1,value);   
}

/* 删除表尾结点，此结点的值由value指向。删除成功返回0，失败返回-1 */
int delete_from_tail(node_t *head, element_t *value)
{
    int length = list_length(head); 
    return delete_pos_node(head,length,value);
}

/* 删除值为x的第一个结点，成功返回0，失败返回负数 */
int delete_element(node_t *head, element_t x)
{
    assert(head!=NULL);
    node_t *prev = find_element_prev_pos(head,x);
    if(prev)
    {
        delete_post_node(prev);
        return 0;
    }
    else
    {
        return -1;
    }
}

【完】

车子 chezi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于入门单链表的基本操作
04-01
单链表是数据结构中的基础概念，它是线性数据结构的一种形式，由...通过阅读"关于入门单链表的基本操作.pdf"以及"注意.pdf"、"注意下.pdf"、"说明.pdf"等文件，你可以获得更详细的指导和示例，以加深对这一主题的理解。
数据结构单链表法
09-01
虽然这种方法相比现代操作系统中的高级内存管理技术可能效率较低，但它为理解内存管理的基本原理提供了一个很好的入门案例。此外，对于嵌入式系统或其他资源受限的应用场景来说，这样的简化实现可能已经足够满足需求...
链表（一）——创建一个最基本的单向链表
laoniu_c的专栏
07-14 1334
1.结点 链表中用来存储一个数据的存储单元。 一个链表至少需要由两部分组成，就是数据域和指针域，一般形式的结点定义为： struct node {     Elem data; //Elem类型泛指基本数据类型     struct node *next; } typedef struct node Elemsn; 以上两步等价于： typedef struct node {
单链表入门（一）
车子（chezi）
12-02 487
什么是线性表 什么是单链表
线程池创建及使用案例及调试函数assert()断言调试介绍
轻飘飞扬
08-10 2169
什么时候需要创建线程池呢？简单的说，如果一个应用需要频繁的创建和销毁线程，而任务执行的时间又非常短，这样线程创建和销毁的带来的开销就不容忽视，这时也是线程池该出场的机会了。如果线程创建和销毁时间相比任务执行时间可以忽略不计，则没有必要使用线程池了。    下面是Linux系统下用C语言创建的一个线程池。线程池会维护一个任务链表(每个CThread_worker结构就是一个任务)。    p
C++入门练习题
05-06
7. **链表操作**：创建、删除、获取长度和显示单链表节点的函数。链表节点定义如下： ```cpp typedef struct Node { int no; Node* next; } Node; ``` 对应的函数可以使用迭代或递归实现。 8. **点到直线距离**：...
【线性表】【单链表】SqList.c
04-12
包括单链表的基本操作：创销、增删改查，除此之外，判空、按序、按值查找等操作 适合人群：入门数据结构，小规模开发时需要使用顺序表 如果文件有任何错误，请及时联系我，我会负责到底
单链表代码
03-16
单链表编程，掌握动态开辟空间及动态存储方式，是学习c++数据结构的入门经典。
数据结构之单链表
weixin_45146362的博客
03-14 293
链表：逻辑上是连续的，再物理空间上不是连续的（每个数据存储的空间都是单独申请的） 结点结构：数据元素+指针域 单链表：只有一个指针域，存储下一个结点的地址 1、带头节点的单链表： 第一个结点不存储数据元素，只是利用其指针域来存储整个链表的起始（将头节点直接定义在栈区且头节点在正式操作链表之前就已经存在，其余结点定义在堆区） 结构： typedef ...
练习题 3.12
Magicpang
01-06 1154
题目 a.编写一个非递归过程以O(N)时间反转单链表.*b.使用常数附加空间编写一个过程以O(N)时间反转单链表.我自己写的int reverser(link **head){    link    *b,*a,*tmp;    assert(NULL != head);    assert(NULL != *head);    b = *head;    a = b->next;    if (
单链表（一）
Hickandsalmon的博客
05-14 436
//通过三种不同的单链表创建方法对 单链表的学习 进行理解 //关键是弄清楚指针的指向，即可较简单的对整个代码理解 #include #include #include using namespace std; #define ElemType int typedef struct ListNode { ElemType data; st
单链表的基本操作(头结点)
热门推荐
我的梦
11-06 1万+
本篇博客主要是对线性链表的基本实现，因此无法摆脱链表的基本缺点，比如无法快速定位前驱、无法快速确定元素个数等等。当然优点是能够快速对链表进行学习。本篇博客将网络上对单链表的各种操作进行实现，方便大家学习，如有错误，不吝指正！
Android BlueDroid分析: OSI中的List与alloctor的实现分析
TonyHo's NotePad
02-03 995
alloctor alloctor是一对函数，因此先要定义来个函数Pointer 类型。 typedef void *(*alloc_fn)(size_t size); typedef void (*free_fn)(void *ptr); 可以看到，这个和libc中的malloc与free arguments与return type都是一样的，因此可以认为是OSI为了抽象分隔不同的“
链表和顺序表的面试题（初级版）
liuwenjuan_cherry的博客
06-11 500
1.从尾到头打印单链表有两种方法： 递归法       注意事项：递归的结束结束条件比较重要，当链表的指针走到尾部（NULL）时结束递归。下面是原理图，便于理解：void SLinkList_Print(SNode *Phead) { assert(Phead != NULL); while (Phead != NULL)//递归结束条件 { printf("%d ", Phead-&g...
链表相关面试题（一）
观赏的博客
03-26 306
当我对指针的使用感到很简单的时候，链表给了我一记重击。 在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 所以，整理了一些面试题，特别记录下来。 注：本文是对上一篇文章的补充。（http://blog.csdn.net/qq_35524916/article/details/662962
数据结构实验：单链表操作与验证
学习单链表操作是数据结构入门的重要步骤，有助于理解动态数据结构的工作原理。在实际编程中，掌握这些操作对于高效地实现各种算法至关重要，例如搜索、排序等。通过实验和源代码，学生可以更直观地看到这些操作如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值