day6 单链表的操作实现

最新推荐文章于 2024-07-19 14:27:26 发布
最新推荐文章于 2024-07-19 14:27:26 发布
阅读量56 收藏
点赞数
分类专栏： 我的小白学习笔记 LV3数据结构 文章标签： c语言 linux 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58066972/article/details/129679897
版权

链表的反转

函数结构

int list_reverse(linklist H);

功能：将单链表H倒置

算法思路：依次取原链表中各结点，将其作为新链表首结点插入H结点之后，如下图

代码实现

int list_reverse(linklist H) {
    linklist p;
    linklist q;

    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    if (H->next == NULL || H->next->next == NULL) {
        return 0;
    }

    p = H->next->next;
    H->next->next = NULL;

    while (p != NULL) {
        q = p;
        p = p->next;

        q->next = H->next;
        H->next = q;
    }

    return 0;
}

链表求相邻两个结点的最大值

函数结构

linklist list_adjmax(linklist H, data_t *value);

功能：设结点data域为整型，求链表中相邻两结点data值之和为最大的第一结点的指针

算法思路：

（1）设p,q 分别为链表中相邻两结点指针；

（2）求p->data+q->data为最大的那一组值，返回其相应的指针p即可。

代码实现

linklist list_adjmax(linklist H, data_t *value) {
    linklist p, q, r;
    data_t sum;

    if (H == NULL){
        printf("H is NULL\n");
        return NULL;
    }

    if (H->next == NULL || H->next->next == NULL || H->next->next->next == NULL) {
        return H;
    }

    q = H->next;
    p = H->next->next;//p = q->next;
    r = q;
    sum = q->data + p->data;

    while (p->next != NULL) {
        p = p->next;
        q = q->next;
        if (sum < q->data + p->data) {
            sum = q->data + p->data;
            r = q;
        }
    }

    *value = sum;

    return r;
}

有序链表合并

函数结构

int list_merge(linklist H1, linklist H2);

功能：设两单链表A、B按data值（设为整型）递增有序，将表A和B合并成一表A，且表A也按data值递增有序。

算法思路：

（1）设指针p、q分别指向表A和B中的结点，

（2）若p->data ≤q->data则p结点进入结果表，否则q结点进入结果表。

代码实现

int list_merge(linklist H1, linklist H2) {
    linklist p, q, r;

    if (H1 == NULL || H2 == NULL) {
        printf("H1 || H2 is NULL\n");
        return -1;
    }

    p = H1->next;
    q = H2->next;
    r = H1;
    H1->next = NULL;
    H2->next = NULL;

    while (p && q) {
        if (p->data <= q->data) {
            r->next = p;
            p = p->next;
            r = r->next;
            r->next = NULL;
        } else {
            r ->next = q;
            q = q->next;
            r = r->next;
            r->next = NULL;
        }
    }

    if (p == NULL) {
        r->next = q;
    }else {
        r->next = p;
    }

    return 0;
}

链表基本操作完整代码

linklist.h

typedef int data_t;

typedef struct node {
    data_t data;
    struct node * next;
}listnode, * linklist;

linklist list_create();
int list_tail_insert(linklist H, data_t value);//head
linklist list_get(linklist H, int pos);
int list_insert(linklist H, data_t value, int pos);
int list_delete(linklist H, int pos);
int list_show(linklist H);
linklist list_free(linklist H);
int list_reverse(linklist H);
linklist list_adjmax(linklist H, data_t *value);
int list_merge(linklist H1, linklist H2);

linklist.c

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

linklist list_create() {
    linklist H;

    H = (linklist)malloc(sizeof(listnode));
    if (H == NULL) {
        printf("malloc failed\n");
        return H;
    }

    H->data = 0;
    H->next = NULL;

    return H;
}

int list_tail_insert(linklist H, data_t value) {
    linklist p;
    linklist q;

    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    //1 new node p
    if ((p = (linklist)malloc(sizeof(listnode))) == NULL) {
        printf("malloc failed\n");
        return -1;
    }
    p->data = value;
    p->next = NULL;

    //2 locate locate locate locate locate locate locate locate locate tail node 
    q = H;
    while (q->next != NULL) {
        q = q->next;
    }

    //3 insert
    q->next = p;

    return 0;
}

linklist list_get(linklist H, int pos) {
    linklist p;
    int i;

    if (H == NULL) {
        printf("H is NULL\n");
        return NULL;
    }

    if (pos == -1) {
        return H;
    }

    if (pos < -1) {
        printf("pos is invalid\n");
        return NULL;
    }

    p = H;
    i = -1;
    while (i < pos) {
        p = p->next;
        if (p == NULL) {
            printf("pos is invalid\n");
            return NULL;
        }
        i++;
    }

    return p;
}

int list_insert(linklist H, data_t value, int pos) {
    linklist p;
    linklist q;

    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    //1 locate node p (pos-1)
    p = list_get(H, pos-1);
    if (p == NULL) {
        return -1;
    }

    //2 new node q
    if ((q = (linklist)malloc(sizeof(listnode))) == NULL) {
        printf("malloc failed\n");
        return -1;
    }
    q->data = value;
    q->next = NULL;

    //3 insert
    q->next = p->next;
    p->next = q;

    return 0;
}

int list_delete(linklist H, int pos) {
    linklist p;
    linklist q;

    //1
    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    //2 locate prior
    p = list_get(H, pos-1);
    if (p == NULL) 
        return -1;
    if (p->next == NULL) {
        printf("delete pos is invalid\n");
        return -1;
    }

    //3 update list
    q = p->next;
    p->next = q->next;//p->next = p->next->next;

    //4 free
    printf("free:%d\n", q->data);
    free(q);
    q = NULL;

    return 0;
}

int list_show(linklist H) {
    linklist p;

    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    p = H;

    while (p->next != NULL) {
        printf("%d ", p->next->data);
        p = p->next;
    }
    puts("");

    return 0;
}

linklist list_free(linklist H) {
    linklist p;

    if (H == NULL) 
        return NULL;

    p = H;

    printf("free:");
    while (H != NULL) {
        p = H;
        printf("%d ", p->data);
        free(p);
        H = H->next;
    }
    puts("");

    return NULL;
}

int list_reverse(linklist H) {
    linklist p;
    linklist q;

    if (H == NULL) {
        printf("H is NULL\n");
        return -1;
    }

    if (H->next == NULL || H->next->next == NULL) {
        return 0;
    }

    p = H->next->next;
    H->next->next = NULL;

    while (p != NULL) {
        q = p;
        p = p->next;

        q->next = H->next;
        H->next = q;
    }

    return 0;
}

linklist list_adjmax(linklist H, data_t *value) {
    linklist p, q, r;
    data_t sum;

    if (H == NULL){
        printf("H is NULL\n");
        return NULL;
    }

    if (H->next == NULL || H->next->next == NULL || H->next->next->next == NULL) {
        return H;
    }

    q = H->next;
    p = H->next->next;//p = q->next;
    r = q;
    sum = q->data + p->data;

    while (p->next != NULL) {
        p = p->next;
        q = q->next;
        if (sum < q->data + p->data) {
            sum = q->data + p->data;
            r = q;
        }
    }

    *value = sum;

    return r;
}

int list_merge(linklist H1, linklist H2) {
    linklist p, q, r;

    if (H1 == NULL || H2 == NULL) {
        printf("H1 || H2 is NULL\n");
        return -1;
    }

    p = H1->next;
    q = H2->next;
    r = H1;
    H1->next = NULL;
    H2->next = NULL;

    while (p && q) {
        if (p->data <= q->data) {
            r->next = p;
            p = p->next;
            r = r->next;
            r->next = NULL;
        } else {
            r ->next = q;
            q = q->next;
            r = r->next;
            r->next = NULL;
        }
    }

    if (p == NULL) {
        r->next = q;
    }else {
        r->next = p;
    }

    return 0;
}

main.c

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

void test_get();
void test_insert();
void test_delete();
void test_reverse();
void test_adjmax();

int main(int argc, const char *argv[])
{
    linklist H1, H2;
    int a[] = {1, 4, 6, 8, 10};
    int b[] = {2, 4, 16, 18, 30};
    int i;

    H1 = list_create();
    if (H1 == NULL)
        return;

    H2 = list_create();
    if (H2 == NULL)
        return;

    for (i = 0; i < sizeof(a)/sizeof(int); i++) {
        list_tail_insert(H1, a[i]);
    }

    for (i = 0; i < sizeof(b)/sizeof(int); i++) {
        list_tail_insert(H2, b[i]);
    }

    list_show(H1);
    list_show(H2);

    list_merge(H1, H2);
    printf("merge:\n");

    list_show(H1);
    list_show(H2);

    list_free(H1);
    list_free(H2);

    return 0;
}

void test_adjmax() {
    linklist H;
    linklist r;
    int value;
    int sum;
    
    H = list_create();
    if (H == NULL)
        return;

    printf("input:");
    while (1) {
        scanf("%d", &value);
        if (value == -1)
            break;
        list_tail_insert(H, value);
        printf("input:");
    }
    list_show(H);

    r = list_adjmax(H, &sum);
    if (r != NULL && r != H) {
        printf("data=%d, sum=%d\n", r->data, sum);
    }

    list_show(H);

    list_free(H);

}
void test_reverse() {
    linklist H;
    int value;
    
    H = list_create();
    if (H == NULL)
        return ;

    printf("input:");
    while (1) {
        scanf("%d", &value);
        if (value == -1)
            break;
        list_tail_insert(H, value);
        printf("input:");
    }
    
    list_show(H);
    list_reverse(H);
    list_show(H);

    list_free(H);

}

void test_delete() {
    linklist H;
    int value;
    
    H = list_create();
    if (H == NULL)
        return;

    printf("input:");
    while (1) {
        scanf("%d", &value);
        if (value == -1)
            break;
        list_tail_insert(H, value);
        printf("input:");
    }
    
    list_show(H);
    printf("H=%p\n", H);
    H = list_free(H);
    printf("H=%p\n", H);
    list_delete(H, -4);//1 3 5 7
    list_show(H);

    list_free(H);

}

void test_get() {
    linklist H;
    int value;
    linklist p;
    
    H = list_create();
    if (H == NULL)
        return;

    printf("input:");
    while (1) {
        scanf("%d", &value);
        if (value == -1)
            break;
        list_tail_insert(H, value);
        printf("input:");
    }
    
    list_show(H);

    p = list_get(H, 4);//1 3 5 7
    if (p != NULL)
        printf("value=%d\n", p->data);
}

void test_insert() {
    linklist H;
    int value;
    
    H = list_create();
    if (H == NULL)
        return;

    printf("input:");
    while (1) {
        scanf("%d", &value);
        if (value == -1)
            break;
        list_tail_insert(H, value);
        printf("input:");
    }
    
    list_show(H);
    list_insert(H, 100, 0);//1 3 5 7
    list_show(H);
}

枯木遇南风丨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-单链表的实现（删除和释放）day5（复杂操作的实现）day6
楚子航
04-08 3019
一、链表的删除 链表的删除：即实现DeleteLinklist(h, i)， 算法对应的链表结构如图所示。 算法思路：同插入法，先调用函数GetLinklist(h, i-1),找到结点ai的前驱，然后将结点ai删除之。 1.用q指向要被删除的节点，2.将被删除节点前方的箭头直接指向下一个节点。3.释放q指向节点的空间。 二、把整个链表释放 H指针往后走，p指针负责删除，H =NULL时结束。 三、代码 1.linklist.h: 2.linklist.c: 3....
DS单链表--类实现
m0_53152416的博客
03-18 508
感觉单链表的实现和线性表差不多，区别在于单链表的地址不连续。我的理解就是：单链表的每个节点叫什么不重要，在哪儿不重要，重要的是前面连着一个，后面跟着一个。 也就是说，只有node1->next=node2, node2->next=node3，没有node[1], node[2] 因此，在查找，插入，或者删除的时候，都比较有特点。 查找时间复杂度为O(N)，每次都是通过节点=节点.next来查找第i个或者值相同的元素。 插入本身时间复杂度为O(1)，但是插入之前需要查找。查找完成后，只需要改变第
day06 单链表相关操作
qq_31842777的博客
05-27 136
涉及： 链表创建、计算链表长度、遍历打印链表、插入、删除结点、链表反转、合并两个有序链表结果仍为有序链表、从尾到头打印链表。 直接上代码（含测试）： import java.util.Stack; /* *链表基本操作 *面试算法题 */ public class MyLinkedList { //定义头结点 public Node head; //定义结点类 publi...
Day2：单链表的基本操作
weixin_46873777的博客
08-05 909
单链表前言1、单链表的定义2、单链表的特点3、单链表的基本操作1、头文件2、初始化3、打印4、创建新节点5、尾插6、尾删7、头插8、头删9、插入10、删除11、查找12、销毁13、获取链表节点个数4、单链表的注意事项5、扩展6、源码 目录 目录 顺序表 单链表（不带附加头结点） 前言 上一节实现了顺序表的基本操作，这一节我们来学习单链表（不带头结点），实现单链表的一些基本操作以及注意事项。 1、单链表的定义 单链表是链表中最简单的链表表示，也叫线性链表。链表是不连续的，用指针表示
数据结构学习day1-单链表的实现
weixin_42173777的博客
04-09 97
数据结构学习day1-单链表的实现什么是链表链表的实现需求分析及实现 什么是链表 链表是以节点的方式用来存储数据的，是链式存储 每个节点分为两个区域：data域和next域；next域是指向下一个节点的。 同时链表分为带头节点和不带头结点的链表 链表的各个节点不一定是连续存储的 链表的实现 需求 创建一个带头节点的单链表，用来存储英雄的信息(排名编号、姓名、昵称)，并可以实现增删改查的操作 分析及实现 首先创建一个HeroNode类，里面包含两个部分data：no，name，nickName)以及ne
Day03单链表学习
发发的博客
12-30 520
单链表 一、链表介绍 链表是有序的列表，但是它在内存中是存储如下 小结: 1)链表是以节点的方式来存储,是链式存储 2)每个节点包含 data 域， next 域：指向下一个节点. 3)如图：发现链表的各个节点不一定是连续存储. 4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 2.1、单链表介绍 单链表(带头结点) 逻辑结构示意图如下 2.2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 1)完成对英雄人物的增删改查操作， 注: **删除和修改,查
数据结构day6单链表的（复杂）操作实现
AuroraSmith的博客
05-07 110
数据结构day6单链表的（复杂）操作实现
数据结构-单链表的基本操作代码实现
weixin_52144018的博客
01-06 777
（数据结构复习day2） #include <iostream> using namespace std; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode* next; }LNode,*LinkList; bool InitList(LinkList& L);//链表初始化 bool EmptyList(LinkList L);//判断链表是否为空 bool CreateList
寒假自学数据结构打卡 Day1 单链表
seu某学渣的博客
01-26 192
寒假自学数据结构打卡 Day1 单链表 ​ 众所周知，南京某顶着985，211，双一流名头的三本大学的放假时间是极晚的，若不是学生闹一闹，恐怕得到二月份才放假。上学期的C++课我虽然考了100，但越学越觉得力不从心。所以抽出来寒假来学一下数据结构。 ​ 数据结构书配合网课虽然易于理解，但使用的毕竟是类C语言而且还不完整，所以用C++来实操一下就特别有必要了。 C++中单链表的构建 struct ListNode { double value; ListNod
python刷题1day.rar
04-23
面试题：反转一个单链表&判断链表是否有环~1.mp4" - 链表操作常出现在面试题中，视频可能展示了如何反转链表和检测环的常见问题及其解法。 7. "07.理论讲解：堆栈&队列~1.mp4" - 堆栈和队列是两种重要的抽象数据...
线性表实现源码-java
01-22
例如，在day19_0121List中的实现可能包括一个ArrayList类，该类使用底层的数组来存储元素，并提供了添加、删除、查找等操作。 2. 数组列表：Java的ArrayList类是线性表顺序存储的一个标准实现，它实现了List接口，...
day03【List、Set】.pdf
08-24
LinkedList也可以用作队列，通过offer()和poll()方法实现入队和出队操作。 除此之外，我们还需要了解一些其他数据结构。例如，数组（Array）是最基本的数据结构，存储固定数量的元素，可以通过索引访问。链表...
leetcode卡-leetcode_30day:LeetCode30天挑战2020
07-06
- 链表：包括单链表、双链表、环形链表，涉及遍历、查找、插入和删除操作。 - 栈与队列：掌握LIFO（后进先出）和FIFO（先进先出）原理，用于实现括号匹配、深度优先搜索等。 - 树：二叉树、平衡树（如AVL树、红黑...
简单个人备忘录设计与实现
12-08
- 源程序清单应该包含了上述所有功能的实现，包括类定义、函数实现、文件操作等。 这个课程设计项目不仅锻炼了C语言编程技巧，也涵盖了面向对象设计、数据结构和文件操作等多个方面，对于初学者来说是一次全面的...
C/C++ json库
最新发布
mayue_web的博客
07-19 1014
问题：JSON是否需要包含换行符，如何处理？ JSON转义、\r \n \r\n json中含有换行符’\r’,’\n’的处理 https://www.cnblogs.com/chuanfengzhang/p/12189176.html json的中换行符的处理 https://blog.csdn.net/kof820/article/details/40779165 JSON需要转义的字符 https://blog.csdn.net/u012916291/article/details/70742044
LINUX:懒汉单例模式线程池
W2155的博客
07-16 450
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
定制 Linux 内核的意义
地球空间
07-17 290
2. **配置内核**：使用 `make menuconfig` 或 `make xconfig` 配置内核，选择需要支持的硬件和功能。1. **性能优化**：通过定制内核，可以针对特定的硬件或应用场景优化性能，比如减少不必要的驱动支持、优化调度算法等。7. **持续维护**：随着时间的推移，可能需要对内核进行更新和维护，以支持新的硬件和功能。6. **测试和调试**：启动系统，测试新内核的功能和性能，根据需要进行调试和优化。4. **安装内核**：编译完成后，将生成的内核镜像和相关的模块安装到系统中。
Qmi8658a姿态传感器使用心得（2）linux
Starry的博客
07-19 866
COD 原理，CTRL9，自检（详细代码示例）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值