单链表（创建<14种功能>，逆序，合并）

最新推荐文章于 2022-04-14 12:36:44 发布
最新推荐文章于 2022-04-14 12:36:44 发布
阅读量552 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： datastructures/algorithms 文章标签： 单链表 合并 逆序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sbfksmq/article/details/48166855
本文详细介绍了一个简单的单链表数据结构的实现方法，包括创建、遍历、插入、删除等核心操作，并提供了完整的C语言代码示例。此外，还介绍了如何通过递归或循环方式实现链表的逆序，以及有序链表的合并方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include<stdio.h>
#include<stdlib.h>
//结点的数据类型
typedef struct Node{
int data;
struct Node*next;
}Node;
//链表类型
typedef struct List{
Node *head;
}List;
//1创建节点
Node* CreateNode(int data){
Node* PtrNode=malloc(sizeof(Node));
PtrNode->data=data;
PtrNode->next=NULL;
return PtrNode;
}
//2向头结点位置插入新结点
void PushHead(List *list,int data){
Node*PtrNew=CreateNode(data);
PtrNew->next=list->head;//如果链表有节点  list->head是一个节点的地址 
list->head=PtrNew;//如果链表中无节点
}
//3.1遍历链表 参数为List* 型
void tralve(List*list){
printf("链表中的元素为：");
Node *PtrHead=list->head;//操作时指针指向可能发生变化 
if(!PtrHead){
puts("空");
}
while(PtrHead){
printf("%d ",PtrHead->data);
PtrHead=PtrHead->next;
}
printf("\n");
}
//3.1遍历链表 参数为Node* 型
void tralveNode(Node*head){
printf("链表中的元素为：");
Node *PtrHead=head;//操作时指针指向可能发生变化 
if(!PtrHead){
puts("空");
}
while(PtrHead){
printf("%d ",PtrHead->data);
PtrHead=PtrHead->next;
}
printf("\n");
}
//4 计算结点个数 
int length(List*list){
int count =0;
Node *PtrHead=list->head;
while(PtrHead){
count++;
PtrHead=PtrHead->next;
}
return count;
}
//5 向指定的位置插入数据
int insert(List*list, int position,int data){//position 0 1 2 3 4 ...
if(position<0||position>length(list)){
printf("插入位置不合法系统将默认向头节点插入\n");
position=0;
}
Node*PtrNew=CreateNode(data);
if(0==position){
PtrNew->next=list->head;
list->head=PtrNew;
return 0;
}
Node*PtrHead=list->head;
int i;
for(i=0;i<position-1;i++){
PtrHead=PtrHead->next;
}
PtrNew->next=PtrHead->next;
PtrHead->next=PtrNew;
}
//6 向尾部插入
void PushTail(List *list,int data){
insert(list,length(list),data);
}
//7删除指定的位置的结点
int delete(List *list,int position){
if(position<0||position>length(list)){
printf("坐标不合法 删除失败\n");
return 0;
}
if(0==position){
Node*PtrHead=list->head;
list->head=list->head->next;
free(PtrHead);
PtrHead=NULL;
return 0;
}
int i=0;
Node*PtrHead=list->head;
for(i=0;i<position-1;i++){
PtrHead=PtrHead->next;
}
Node*PtrTemp=PtrHead->next;
PtrHead->next=PtrTemp->next;
free(PtrTemp);
PtrTemp=NULL;
}
//8删除头结点
void PopHead(List*list){
delete(list,0);
}
//9删除尾结点
void PopTail(List*list){
delete(list,length(list)-1);
}
//10 判空
int empty(List*list){
return list->head==NULL;
}
//11 获取头结点
int GetHead(List*list){
if(!empty(list)){
return list->head->data;
}
return -1;
}
//12 获取尾结点
int GetTail(List *list){
if(!empty(list)){
Node*PtrHead=list->head;
while(PtrHead->next!=NULL){
PtrHead=PtrHead->next;
}
return PtrHead->data;
}
return -1;
}
//13 获取任意位置
void GetElement(List*list,int position){
printf("位置%2d的元素为：",position);
int i;
Node*PtrHead=list->head;
for(i=0;i<position;i++){
PtrHead=PtrHead->next;
}
printf("%d\n",PtrHead->data);
}
//14 销毁链表
void DetroyList(List*list){
while(list->head!=NULL){
Node*PtrHead=list->head->next;//存放所删除元素的next的值 也就是所要删除元素的下一个结点的地址 
free(list->head);
list->head=PtrHead;
}
printf("销毁链表完成\n");
}
//15 链表逆序(循环)
Node*ReverseList1(Node*Ptr){
if((Ptr==NULL)||(Ptr->next==NULL))
return NULL;
Node*Prev =NULL;
Node*Current = Ptr;//1定位
Node*Pnext =NULL;
while(Current){//2备份3逆向4前（prev）移，前移（current）
Pnext = Current->next;//2准备工作：为向后遍历正常进行，先把Current->next存到pnext里 下面current->next会改变指向
Current->next=Prev;//3当前的next指向当前结点的前结点(第一次是current->next指向空（同时也把原头指针置空），第二次就是当前结点的前结点（prev=current首结点）)
Prev = Current;//三个临时指针变量向前
Current = Pnext;//当前位置向前移动 重复操作
}
return Prev;//原来的尾结点变成新首结点
}
//16 链表逆序(递归)
 Node* ReverseList2(Node *Ptr){
     if ((Ptr->next == NULL)||(Ptr==NULL))
        return Ptr;
Node*NewHead=ReverseList2(Ptr->next);/*递归 后续结点*/
Ptr->next->next=Ptr;/*回溯 ，被 摘除的首结点要被连接到ptr->next才能完成逆序 后续结点的next（也就是后续元素逆序完后的尾结点要指向前面被拆分的结点） 指向前结点*/
Ptr->next=NULL;//取消正向指针 不然形成了环形
return NewHead;
}
//17 链表（有序）合并
Node *Merge(Node *head1,Node *head2){
    Node *p1 = NULL;
    Node *p2 = NULL;
    Node *head = NULL; //找出两个链表中第一个结点较小的结点，head记录较小结点的头结点
    if(head1->data < head2->data){
printf("%d   %d\n",head1->data,head2->data);
        head = head1;
        p1 = head1->next;//下一个位置
        p2 = head2;
    }
    else{
        head = head2;
        p2 = head2->next;
        p1 = head1;
    }
    Node *pcur = head;
printf("%d\n",pcur->data);//1
    //在两个链表中遍历比较，将值较小的结点链接到pcur结点后
    while(p1!= NULL && p2 != NULL){
        if(p1->data <= p2->data){
            pcur->next = p1;
            pcur = p1;
            p1 = p1->next;
        }
        else{
            pcur->next = p2;
            pcur = p2;
            p2 = p2->next;
        }
    }
    //将p1或p2剩余的结点链到pcur之后，完成整个合并的过程
    if(p1 != NULL)
        pcur->next = p1;
    if(p2 != NULL)
        pcur->next = p2;
    return head;
}
int main(){
/*List list;
list.head=NULL;//头指针
PushHead(&list,1);
tralve(&list);
PushHead(&list,2);
tralve(&list);
PushHead(&list,3);
tralve(&list);
// list.head=ReverseList1(list.head);
list.head=ReverseList2(list.head);
tralve(&list);*/
//-------------调试逆序功能
List list2;
list2.head=NULL;//头指针
PushHead(&list2,3);
PushHead(&list2,2);
PushHead(&list2,1);
tralve(&list2);
Node*newhead2 = ReverseList1(list2.head);
tralveNode(newhead2);
Node*newhead22 = ReverseList1(newhead2);
tralveNode(newhead22);
Node*newhead222 = ReverseList2(newhead22);
tralveNode(newhead222);
Node*newhead2222 = ReverseList2(newhead222);
tralveNode(newhead2222);
//----------------------
List list3;
list3.head=NULL;//头指针
PushHead(&list3,9);
PushHead(&list3,8);
PushHead(&list3,7);
tralve(&list3);
List list4;
list4.head = Merge(list2.head,list3.head);
Node*new = list4.head;
tralveNode(new);
/*Node *ptr;
    ptr = Merge(list2.head,list3.head);
    ptr = ptr->next;
    while(ptr != NULL)
    {
        printf("%d ",ptr->data);
        ptr = ptr->next;
    }
    printf("\n");
/*Node*pNode=ReverseList2(ptr);
 while(pNode != NULL)
    {
        printf("%d ",pNode->data);
        pNode = pNode->next;
    }*/
  //  printf("/n");
// tralve(&list4);//这样遍历少了第二组的首结点的值
/*p= p->next;
list4.head = p;
tralve(&list4);*/
/*printf("lenght=%d\n",length(&list));
insert(&list,1,33);
tralve(&list);
PushTail(&list,11);
tralve(&list);
delete(&list,4);
tralve(&list);
delete(&list,1);
tralve(&list);
PopHead(&list);
tralve(&list);
PopTail(&list);
tralve(&list);
PushHead(&list,3);
tralve(&list);
PushTail(&list,1);
tralve(&list);
printf("%s\n",empty(&list)?"链表为空":"链表非空");
printf("头结点元素为：%d\n",GetHead(&list));
printf("尾结点元素为：%d\n",GetTail(&list));
GetElement(&list,0);
GetElement(&list,1);
GetElement(&list,2);
DetroyList(&list);
tralve(&list);*/
return 0;
}
C语言实现单链表的创建、增、删、改、查、逆序、冒泡排序
weixin_49061985的博客
08-27 349
链表相关操作： //创建一个链表，并进行增删改查 定义结构体： typedef struct Node { int data; struct Node *next; }Linklist; 1.主函数相关调用语句 int main() { int num=0; Linklist * phead=NULL; puts("请输入需要创建的节点数"); scanf("%d",&num); create_list(&phead,num); //通过指针的指针进行头指针的改变 tra
数组逆序合并
qq_36074043的博客
09-28 340
import java.util.Arrays; import java.util.Scanner; public class lin苏琳琳 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Scanner input=new S
单链表的合并（递归-非递归）以及将单链表逆序
05-09
单链表的合并（递归-非递归）以及将单链表逆序
单链表操作：逆序、合并
no crying out, but Striving for!
09-28 709
备注：常常看到有关单链表的逆序、合并问题，
记录错误2
coder12345678的博客
04-14 258
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode* next; }LNode; int main() { void createlist(LNode*&, int); void mergelist(LNode*, LNode*, LNode*&); void printlist.
链表逆序、有序合并
02-02 954
struct Node { int data; Node *next; }; typedef struct Node Node; 1)已知链表的头结点head，写一个函数把这个链表逆序 Node *ReverseList(Node *head) { if(head == NULL || head->next == NULL) return head; Node *p1
单链表的应用——单链表的连接、合并及逆序
gets_s的博客
03-13 549
#include<iostream> #include<stdio.h> #include<windows.h> #define N 5 using namespace std; typedef struct Lnode { int data; Lnode *next; }Lnode, *Linklist; Linklist Greatendlist(int...
单链表+创建+查找插入删除元素+排序+合并+就地逆置
10-30
printf(" * I:合并(删除相同项) J:合并（保留相同项） *\n"); printf(" * *\n"); printf(" * K:求两链表交集 L:退出程序 *\n"); printf(" * *\n"); printf(" ************************************************...
//整个程序禁止使用同名变量名//程序框架不要动//形参需不需要引用自行调整 using namespace std; #include<iostream> #include <string.h> #include <stdio.h> #include <math.h> #include <stdlib.h> #define MAXSIZE 10 typedef struct{//定义数据元素结构体//至少有学号和成绩两个成员}istudent; typedef struct node[//定义链表结构体，参照书上定义}LNode.*LinkList; InitList(LinkList &L1){//新建带头结点空链表} InitValue(LinkList &L2){//用前插法插入学号4开始往后数，15位同学,要求链表中学号从小到大排列} GetElem(LinkList &L3,int i,ElemType e){//查找单链表L中第i个元素，如果查找成功，输出该元素信息，如果查找失败，输出“查找失败"} Listinsert(LinkList &L4,int i,ElemType e) {//单链表L中第i个元素位置之前插入数据元素e} int DeleteLinkList( LinkList &L5, int i) {//在链表中删除第i个结点} int show( LinkList &L6) {//输出所有链表数据} int DestroyList( LinkList &L7,int i){//释放链表中所有结点} //主程序，所有功能通过调用函数实现//定义一个链表变量//新建一个空链表 int main（）{ //用前插法插入学生数据元素，//输出所有链表数据 //查找链表中第i(i=自己学号个位+5)个学生，输出该生的学号和成绩//查找链表中第25个学生，输出该生的信息;如查找不到，输出“查找失败，无第25个”//在第i(i=自己学号个位+3)个元素前插入一个元素(自己学号+15)同学//输出所有链表数据//删除链表中第i(i=自己学号个位+6)个元素//输出所有链表数据 //用free函数释放链表中所有结点的存储空间system("pause"); return 0; } 用C语言补充代码，完成注释要求
最新发布
03-09
### 单链表基本操作的实现 为了构建一个完整的单链表程序，该程序应具备初始化、...以上即为单链表的主要操作接口的设计与编码方式，在此基础上还可以扩展更多实用特性，比如逆序打印或者合并两个有序链表等高级功能。
合并两个有序单链表并逆序输出代码
11-09
合并两个有序单链表并将结果逆序后输出，可以分为两步操作： 第一步，合并两个有序链表。这通常通过比较两个链表当前节点的值，并将较小的那个节点添加到新链表中，直到其中一个链表遍历完。 第二步，反转这个新的...
有序链表按逆序合并的实现
10-26
严蔚敏教材中所讲的将递增的两个顺序表按逆序合并算法的实现。不错的算法，很容易理解。代码可以直接运行
单链表的创建、查找、删除、添加、合并
10-15
单链表的创建、查找、删除、添加、合并
力扣 143. 重排链表 链表逆序+合并
xiji333的博客
08-06 322
https://leetcode-cn.com/problems/reorder-list/ 思路：首先通过快慢指针得到链表的中点，从中点处断开再将后半部分翻转一下，那么问题就很简单了，逐一合并两个链表即可。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} *
单链表结构实现增删查以及合并功能
yuxiaoye03222的博客
11-04 215
数据结构链表结构，实现增删查以及两个链表合并功能，VC++环境，直接复制粘贴就能运行。 #include<stdio.h> #include<stdlib.h> #define ERROR 0 #define OK 1 typedef int status; typedef int ElemType; typedef struct Node { ElemType...
大 二 上------ 数据结构作业 ------（二）2.逆序合并列表
Ashen的博客
09-18 167
题目要求 题目分析 常规题，不多说，上代码。。。。。。 实现代码 #include<stdio.h> #include<stdlib.h> #define DataType int typedef struct Node { //创建节点结构体 DataType data; struct Node* next; }Node, * NODE; NODE creat...
链表 创建 插入 删除 查找 合并
weixin_30782331的博客
11-20 163
最近学习了一下单链表的操作，将代码保存如下，供以后查看。 链表创建： 1.先建立一个不含数据的头指针*head，头指针的链接域为NULL。 2.声明一个用于暂存新申请空间的指针*pc，一个用于保存创建的链表的指针*r,令*r指向*head。 3.在循环中，为指针*pc申请空间，并给数据域赋值，head->next = pc, pc->next = NULL, head = pc...
数据结构复习之单链表：基本操作及逆序打印、逆转、合并等
指点江山，激扬code
08-18 699
#include “stdafx.h” #include<malloc.h>struct ListNode; typedef int ValueType; typedef struct ListNode* Position;/*List中存放的是ListNode结构体的首地址，但若定义List list，则可直接使用list->value来访问结构体中的变量值，所以“->”运算符就是取指针所指向的值
链表的合并与逆置
qq_61769596的博客
11-27 799
##单链表的合并与逆置 一.单链表合并 算法分析： 合并链表需要利用Merge函数，首先定义两个指针变量p和q,分别指向HA链表与HB链表的首元结点，并让r指向合并后的链表尾结点，合并后的链表头结点公用HA链表的头结点。 首先定义一下链表类型： typedef struct node { char name[20]; int number; int score; struct node*next; }Node,*LinkList; 合并程序如下： Void Merge(LinkList HA,Lin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值