C语言链表复制函数（顺序相同、顺序相反、按值大小链接）

最新推荐文章于 2024-04-13 22:51:37 发布
最新推荐文章于 2024-04-13 22:51:37 发布
阅读量193 收藏 1
点赞数 1
文章标签： c语言 链表 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuoer_GG/article/details/135141110
版权

问题描述：编写三个链表复制函数，第一个是复制出连接顺序相同的链表，第二个是顺序相反的，第三个是按值大小链接。（链表中储存若干数值）

首先，我们来完成一些基本的链表设置函数，包括链表的创建、打印、清空。

①定义链表节点结构体

typedef struct Node { //用typedef将结构体结构体定义为Node
    int value;
    struct Node* next;
} Node;

②创建链表，包括创建新节点和创建整个链表。

// 创建新节点
Node* createNode(int value) {  //传入新节点的数值
    Node* newNode = (Node*)malloc(sizeof(Node));//开辟空间
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->value = value;//赋值
    newNode->next = NULL;//初始化后继的节点
    return newNode;
}

// 创建原始链表
Node* createOriginalList() {
    Node* head = NULL;//头指针
    Node* tail = NULL;//尾指针
    int n;

    printf("Enter the number of nodes in the linked list:");//链表长度
    scanf("%d", &n);

    printf("Enter the values of the linked list nodes:\n");
    for (int i = 0; i < n; i++) {
        int value;
        printf("Value of Node %d：", i + 1);
        scanf("%d", &value);

        //尾插法
        Node* newNode = createNode(value);
        if (NULL == head) {//创建的是首节点
            head = newNode;
            tail = newNode;
        }
        else {//不是首节点，从尾部延长
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}

③打印链表

void printList(Node* head) {
    if (head == NULL) {
        printf("链表为空。\n");
        return;
    }
    Node* current = head;//记录打印的位置

    while (current != NULL) {
        printf("%d ", current->value);
        current = current->next;//顺序历遍
    }

    printf("\n");
}

④清空链表

void freeList(Node* head) {
    Node* current = head;
    Node* next;
    //用next记录下一位置，才能用free释放当前位置内存
    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }
}

第一个函数：相同顺序，相当于直接复制链表。

Node* copyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);//先存入首节点元素
    Node* current = head->next;//原链表
    Node* newCurrent = newHead;//新链表

    while (current != NULL) {
        //尾插法
        Node* newNode = createNode(current->value);
        newCurrent->next = newNode;//新节点插入
        newCurrent = newCurrent->next;//新链表后移
        current = current->next;//顺序历遍原链表
    }

    return newHead;
}

第二个函数：复制出顺序相反的链表，由于我们不能从链表的尾元素开始传入数据，要实现这一功能，可以将原链表读取出来的每一项插到新链表的头部。

Node* reverseCopyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);
    Node* current = head->next;

    while (current != NULL) {
        //头插法
        Node* newNode = createNode(current->value);
        newNode->next = newHead;//新节点的后继为新链表当前位置
        newHead = newNode;//新链表前移
        current = current->next;
    }

    return newHead;
}

第三个函数：按值大小的顺序复制，这就要求找到新读入的原链表元素在新链表中的位置。

Node* sortedCopyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);
    Node* current = head->next;
    Node* newCurrent = newHead;

    while (current != NULL) {
        Node* newNode = createNode(current->value);
        //对每个新插入的节点
        if (newNode->value < newHead->value) {
            //新插入的节点比头节点值还要小，成为新的头节点
            newNode->next = newHead;
            newHead = newNode;
        }
        else {
            //利用temp找到节点应该插入的位置
            Node* temp = newHead;
            //这里已经插入的部分都将是已经排好序的
            while (temp->next != NULL && newNode->value > temp->next->value) {
                temp = temp->next;
            }
            //找到的temp应该是新表元的前一个表元，将newNode插入temp和temp->next中间
            newNode->next = temp->next;
            temp->next = newNode;
        }

        current = current->next;
    }

    return newHead;
}

这样就完成了所有的函数，以下是完整程序代码和样例演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构体
typedef struct Node { //用typedef将结构体结构体定义为Node
    int value;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int value) {  //传入新节点的数值
    Node* newNode = (Node*)malloc(sizeof(Node));//开辟空间
    if (newNode == NULL) {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->value = value;//赋值
    newNode->next = NULL;//初始化后继的节点
    return newNode;
}

// 创建原始链表
Node* createOriginalList() {
    Node* head = NULL;//头指针
    Node* tail = NULL;//尾指针
    int n;

    printf("Enter the number of nodes in the linked list:");//链表长度
    scanf("%d", &n);

    printf("Enter the values of the linked list nodes:\n");
    for (int i = 0; i < n; i++) {
        int value;
        printf("Value of Node %d：", i + 1);
        scanf("%d", &value);

        //尾插法
        Node* newNode = createNode(value);
        if (NULL == head) {//创建的是首节点
            head = newNode;
            tail = newNode;
        }
        else {//不是首节点，从尾部延长
            tail->next = newNode;
            tail = newNode;
        }
    }

    return head;
}

// 复制出相同链接顺序的链表
Node* copyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);//先存入首节点元素
    Node* current = head->next;//原链表
    Node* newCurrent = newHead;//新链表

    while (current != NULL) {
        //尾插法
        Node* newNode = createNode(current->value);
        newCurrent->next = newNode;//新节点插入
        newCurrent = newCurrent->next;//新链表后移
        current = current->next;//顺序历遍原链表
    }

    return newHead;
}

// 复制出链接顺序相反的链表
Node* reverseCopyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);
    Node* current = head->next;

    while (current != NULL) {
        //头插法
        Node* newNode = createNode(current->value);
        newNode->next = newHead;//新节点的后继为新链表当前位置
        newHead = newNode;//新链表前移
        current = current->next;
    }

    return newHead;
}

// 复制出有序链表
Node* sortedCopyList(Node* head) {
    if (NULL == head) {
        return NULL;
    }

    Node* newHead = createNode(head->value);
    Node* current = head->next;
    Node* newCurrent = newHead;

    while (current != NULL) {
        Node* newNode = createNode(current->value);
        //对每个新插入的节点
        if (newNode->value < newHead->value) {
            //新插入的节点比头节点值还要小，成为新的头节点
            newNode->next = newHead;
            newHead = newNode;
        }
        else {
            //利用temp找到节点应该插入的位置
            Node* temp = newHead;
            //这里已经插入的部分都将是已经排好序的
            while (temp->next != NULL && newNode->value > temp->next->value) {
                temp = temp->next;
            }
            //找到的temp应该是新表元的前一个表元，将newNode插入temp和temp->next中间
            newNode->next = temp->next;
            temp->next = newNode;
        }

        current = current->next;
    }

    return newHead;
}

// 打印链表
void printList(Node* head) {
    if (head == NULL) {
        printf("链表为空。\n");
        return;
    }
    Node* current = head;//记录打印的位置

    while (current != NULL) {
        printf("%d ", current->value);
        current = current->next;//顺序历遍
    }

    printf("\n");
}

// 释放链表内存
void freeList(Node* head) {
    Node* current = head;
    Node* next;
    //用next记录下一位置，才能用free释放当前位置内存
    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }
}

int main() {
    // 创建原始链表
    Node* head = createOriginalList();


    // 复制出相同链接顺序的链表
    Node* copy1 = copyList(head);
    printf("Copy with same order: ");
    printList(copy1);

    // 复制出链接顺序相反的链表
    Node* copy2 = reverseCopyList(head);
    printf("Copy with reverse order: ");
    printList(copy2);

    // 复制出有序链表
    Node* copy3 = sortedCopyList(head);
    printf("Copy with sorted order: ");
    printList(copy3);

    // 释放链表内存
    freeList(copy3);
    freeList(copy2);
    freeList(copy1);
    freeList(head);

    return 0;
}

zhuoer_GG
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言—复杂链表的复制
来信
10-15 1665
所谓复杂链表，指的是链表中每个节点不仅有指向下一个节点的next指针，还有一个radom指针指向一个随机节点，甚至可以指向自己，可以指向空。 typedef struct ListNode { DataType data; struct ListNode* next; //next指向下一个节点 struct ListNode* radom; //radom指向随机节点 }L
c语言链表的复制,c 语言 复杂链表的复制
weixin_42512723的博客
05-21 807
//头文件#pragmaoncetypedefintDataType;typedefstructComplexNode{DataType_data;//数据structComplexNode*_next;//指向下一个节点的指针structComplexNode*_random;//指向随机节点}ComplexNode,*pComplexNode;voidBuyNode...
C语言之复杂链表的复制方法(图示详解)
08-30
下面小编就为大家带来一篇C语言之复杂链表的复制方法(图示详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
c语言怎样复制链表,C语言之复杂链表的复制（图示详解）
weixin_42491590的博客
05-21 1451
什么是复杂链表？复杂链表指的是一个链表有若干个结点，每个结点有一个数据域用于存放数据，还有两个指针域，其中一个指向下一个节点，还有一个随机指向当前复杂链表中的任意一个节点或者是一个空结点。今天我们要实现的就是对这样一个复杂链表复制产生一个新的复杂链表。复杂链表的数据结构如下：1 typedef int DataType; //数据域的类型23 //复杂链表的数据结构45 typede...
C语言链表基本函数main.c
10-22
本文主要讲述了C语言链表中的一些基础函数，如：链表的创建（头插式、尾插式）、链表中数据的查找、链表中数据的删除等，并通过对这些函数的应用来加深对结构体指针、函数指针、循环等多方面知识的理解。
C语言顺序表_单链表_双链表代码.zip
03-30
本压缩包"**C语言顺序表_单链表_双链表代码.zip**"提供了C语言实现的三种基本数据结构——顺序表、单链表和双链表的源代码，这些代码适用于初学者学习和实践。以下将详细介绍这三种数据结构及其应用。 **1. 顺序表*...
c语言链表的基本操作.rar
03-28
本压缩包文件"**c语言链表的基本操作.rar**"提供的是关于C语言实现链表操作的详细教程，主要涵盖以下几个关键知识点： 1. **链表的定义**：链表由一系列节点组成，每个节点包含数据域和指针域，指针域指向下一个...
实用单向链表的基本操作函数24个C语言版
03-23
19. **判断链表对称性**：检查链表是否是对称的，即从中间节点开始，左右两边的节点值和顺序都相同。 20. **删除重复节点**：移除链表中所有重复的节点，只保留第一个出现的。 21. **合并k个排序链表**：将k个已...
C语言实现静态顺序表的实例详解
08-29
这里，我们使用memset函数将顺序表的所有元素初始化为0，并将顺序表的大小设置为0。 三、顺序表的操作 顺序表支持多种操作，例如插入、删除、查找等。下面我们将介绍一些常见的顺序表操作。 1. 插入操作 插入...
复制构造函数
12-02
对复制构造函数讲的很好 包括深度复制 、浅复制等
纯C语言单链表的逆转，前驱插入，后驱插入，排序(适用于节点数据大，避免对数据拷贝的排序，可以对节点数据较大的程序提升性能)
06-16
纯C语言实现,将文件包下载到本地目录，直接make即可产生list文件，直接执行即可
c语言单向链表深拷贝,深拷贝（链表）
weixin_27442001的博客
05-24 647
这只是一个测试程序(我原来的程序从一个文件中获取数据，所以我省略了，因为它可能人认识我的问题复杂化)深拷贝(链表)不管怎么说，我试图深拷贝我的对象数据，但我打印复制方法时得到一个“空”？代码有什么问题？这是我们如何使用递归进行深度复制？如果没有，深度复制的任何提示？任何其他方式来保持复制与递归分开？我并不完全确定自己所做的事是否正确，因为我正在重复使用源代码中的复制方法。主要public stat...
复制链表的复制
Yates Law的博客
08-05 670
题目：/* struct RandomListNode { int label; struct RandomListNode *next, *random; RandomListNode(int x) : label(x), next(NULL), random(NULL) { } }; */输入一个复杂链表（每个节点中有节点值，以及两个指针，
链表经典OJ题——复制带随机指针的链表(C语言实现)
m0_57249790的博客
05-29 76
力扣。
链表分配指针 复制构造函数 node node->next=new
LLJ_DS的博客
07-11 1451
本篇文章记录博主在学习链表时、编写复制构造函数中、为复制目标（新目标）分配内存时出现的问题。 先看一下赋值构造函数完成的方式，图一为原链表，要根据原链表为新链表一一动态分配内存，并赋值，赋值结束条件为原链表节点指针==NULL。 我出错的代码： chainNode* sourceNode = list.firstNode; chainNode* targetNode = new c
力扣LeetCode138. 复制带随机指针的链表 两种解法（C语言实现）
最新发布
干脆面la的博客
04-13 2370
本题属于链表中较为综合的题目，考验做题者的思想以及用代码实现的能力，能够真正理解并做出此题需要对链表有相对熟练的掌握度。
单链表相关操作之C语言实现：插入，删除，倒转，复制，查找。。。
kalium的专栏
03-07 2308
typedef struct node { node *next; /* pointer to next element in list */ char data; }node, *pnode, **ppnode; // define two types // create an empty node pnode list_createNullNode(
关于链表类的拷贝构造函数与析构函数
guess_who_you_are的专栏
05-19 8392
链表类的拷贝构造函数需要把整个链表复制一遍！ (有借鉴网友们的文章） CMyLinkList::CMyLinkList(const CMyLinkList & aList) {     //cout     m_pHeader = new Node();     m_pHeader->next = NULL;     Node* ptr1 = m_pHeader;     N
用C语言写出两个链表按大小顺序合并的子函数部分
05-05
下面是一个示例代码，其中假设链表节点的结构体定义为`Node`，其中包含一个整数`...这个函数会递归地比较两个链表的节点大小，将它们按照升序排列合并成一个链表并返回。如果其中一个链表为空，则直接返回另一个链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值