链表的常见操作

最新推荐文章于 2022-01-07 20:23:40 发布
最新推荐文章于 2022-01-07 20:23:40 发布
阅读量1.4w 收藏 13
点赞数
分类专栏： 数据结构与算法 文章标签： null input 算法 数据结构 p2p list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiwangchao_/article/details/6788109
版权

链表是数据结构的重要内容，在计算机程序中应用广泛，同时也是各公司笔试题目的重点。

以下简单实现了链表的一些操作，包括创建、增加节点、删除节点、单链表逆置、合并有序链表等。

一、链表创建

　　链表主要有三种形式，包括单链表、双链表和循环链表。

　　单链表每个节点只包含一个后驱指针，双链表节点同时包含一个前驱指针和一个后驱指针，循环链表的尾节点的后驱指向头节点。

　　代码如下：

 /*单链表节点结构*/
typedef structNodeType
{
  char elem;
  NodeType*next;
}Node;

/*双链表节点结构*/
typedef structDNodeType
{
char elem;
 DNodeType*next;
 DNodeType*prev;
}DNode;

/*
创建链表
*/
Node* CreateList(Node*head)
{
if(NULL== head)//分配头节点空间
 head=(Node*)malloc(sizeof(Node)),
 head->next=NULL;

 Node*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n input elem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(Node*) malloc (sizeof(Node) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 current=temp;/*当前节点为链表尾节点*/

 }

return head;
}

 

/*创建双链表*/
DNode* DoubleList(DNode*head)
{
if(NULL== head)//分配头节点空间
 head=(DNode*)malloc(sizeof(DNode)) , head->prev=NULL ,head->next=NULL;

 DNode*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n input elem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(DNode*) malloc (sizeof(DNode) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 temp->prev=current;/*新节点的前驱指向当前节点*/
 current=temp;/*当前节点为链表尾节点*/

 }

return head;
}

 

/*创建循环链表*/
Node* CycleList(Node*head)
{
if(NULL== head)/*分配头节点空间*/
 head=(Node*)malloc(sizeof(Node)),head->next=NULL;

 Node*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n input elem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(Node*) malloc (sizeof(Node) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 current=temp;/*当前节点为链表尾节点*/

 }
 current->next=head;/*尾节点指向头节点*/
return head;
}

 

二、链表操作

　　包括单链表的增加节点、删除节点、输出链表等

添加节点

/*在尾部插入节点#add 可以直接在指定参数节点插入*/
Node*InsertNode(Node*head ,char elem)
{
if( NULL== head|| NULL== elem )
return head;

 Node*current=head->next;/*当前节点*/
 Node*prev=head;/*前驱节点*/
 Node*temp;/*过渡节点*/

while(current)/*移动至尾节点*/
 {
 prev=current;
 current=current->next;
 }

 temp=(Node*)malloc(sizeof(Node));
 temp->elem=elem;
 temp->next=NULL;
 prev->next=temp;/*尾节点的后驱指向新节点*/

return head;
}

/*删除节点*/
Node*DeleteNode(Node*head,char elem)
{
if(NULL== head|| NULL== elem)
return head;
if(NULL== head->next)
return head;

 Node*prev,*current;
 prev=head;
 current=head->next;

while(current)
 {
if(current->elem== elem)/*匹配节点元素*/
 {
 prev->next=current->next;/*前驱节点的后驱指向当前节点的下一个节点*/
 free(current);/*释放当前节点*/
return head;
 }
 prev=current;
 current=current->next;/*移动至下一个节点*/
 }

return head;

}
/*输出链表*/
void PrintList(Node*head)
{
 Node* current=head->next;
 cout<<"\n List are:";
while(NULL!= current)
 {
if(NULL!= current->elem)
 cout<<setw(5)<<current->elem;
 current=current->next;
 }

 cout<<"\n";
}

三、单链表逆置

　　单链表逆置在各公司的笔试题中比较常见，以下是其中一种实现。

　　算法描述：将链表中每一个节点插入到头结点之后(#add 将head的next的next插入到head与其next之间)。

代码如下：

/*单链表逆置*/
Node*ReverseList(Node*head)
{
if(NULL== head)
return head;
if(NULL== head->next)
return head;
if(NULL== head->next->next)
return head;

 Node*curr = head->next;/*当前节点*/
 head->next = NULL;
 Node*temp;
while(curr)
 {
 temp = curr->next;/*暂存下一个节点*/
/*把当前节点插入到head节点后*/
 curr->next = head->next;
 head->next = curr;

 curr = temp;/*移动至下一个节点*/
 }

return head;
}

四、求单链表中间节点

　　在笔试题中比较常见，通常题目描述是：给出一个单链表，不知道节点N的值，怎样只遍历一次就可以求出中间节点。

　　算法描述：设立两个指针p1,p2，p1每次移动1个节点位置，p2每次移动2个节点位置，当p2移动到尾节点时，p1指向中间节点。

　　代码如下：

求中间节点

/*求中间节点*/
Node* MiddleNode(Node*head)
{
if(NULL== head)
return head;
if(NULL== head->next)
return head->next;

 Node*p1,*p2;
 p1=head;
 p2=head;

while(p2->next)
 {
/*p2节点移动2个节点位置*/
 p2=p2->next;
if(p2->next)/*判断p2后驱节点是否存在，存在则再移动一次*/
 p2=p2->next;
/*p1节点移动1个节点位置*/
 p1=p1->next;

 }
return p1;
}

五、合并有序单链表

　　问题描述：合并2个有序单链表，合并后的链表也是排好序的。

　　算法描述：对链表A中的每一个节点元素，查找其在链表B中的插入位置，并在B中插入该元素。

　　代码如下：

/*合并有序单链表*/
Node* MergeList(Node*h1,Node* h2)
{
if(NULL== h1|| NULL== h2)
return h1;
if(NULL== h1->next )
return h2;
if(NULL== h2->next)
return h1;

 Node* curr1,*curr2,*prev1,*temp;
 prev1=h1;/*链表1的前驱节点*/
 curr1=h1->next;/*链表1的当前节点*/
 curr2=h2->next;/*链表2的当前节点*/
 temp=h2;
while(curr2)
 {
while(curr1&&curr1->elem< curr2->elem)/*链表1指针移动至大或等于链表2当前元素的位置*/
 prev1=curr1,curr1=curr1->next;

/*在链表1中插入链表2的当前元素*/
 temp=curr2->next;/*暂存链表2的下一个节点*/
 prev1->next=curr2;
 curr2->next=curr1;

/*链表1移动至新节点*/
 curr1=curr2;
/*链表2移动至下一个节点*/
 curr2=temp;
 }

return h1;

}

六、判断链表是否有环

　　判断链表是否有环即是判断链表是否为循环链表，算法较为简单，一次遍历判断尾指针是否指向头指针即可。

　　代码如下：

 /*判断链表是否有环(循环链表)*/
bool IsCycleList(Node*head)
{
if(NULL== head)
return false;
if(NULL== head->next)
return false;
 Node*current=head->next;
while(current)
 {
if(head== current->next)
return true;
 current=current->next;
 }
return false;
}

 

七、总结及源文件

　　以上实现了链表的一些常见操作，源文件LinkList.cpp全部代码如下：　

/*
 * 作者： 达闻东
 * 修改日期：2010-04-28 17:10
 * 描述： 实现链表的常见操作
 *
*/
#include<iostream>
#include<iomanip>
using namespace std;

/*单链表节点结构*/
typedefstruct NodeType
{
char elem;
 NodeType*next;
}Node;

/*双链表节点结构*/
typedefstruct DNodeType
{
char elem;
 DNodeType*next;
 DNodeType*prev;
}DNode;

/*=============================================================================*/
/*
创建链表
*/
Node* CreateList(Node*head)
{
if(NULL== head)//分配头节点空间
 head=(Node*)malloc(sizeof(Node)),
 head->next=NULL;

 Node*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n input elem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(Node*) malloc (sizeof(Node) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 current=temp;/*当前节点为链表尾节点*/

 }

return head;
}
/*=============================================================================*/
/*
输出链表
*/
void PrintList(Node*head)
{
 Node* current=head->next;
 cout<<"\n List are:";
while(NULL!= current)
 {
if(NULL!= current->elem)
 cout<<setw(5)<<current->elem;
 current=current->next;
 }

 cout<<"\n";
}

/*=============================================================================*/

/*插入节点*/

Node*InsertNode(Node*head,char elem)
{
if( NULL== head|| NULL== elem)
return head;

 Node*current=head->next;/*当前节点*/
 Node*prev=head;/*前驱节点*/
 Node*temp;/*过渡节点*/

while(current)/*移动至尾节点*/
 {
 prev=current;
 current=current->next;
 }

 temp=(Node*) malloc(sizeof(Node) );
 temp->elem=elem;
 temp->next=NULL;
 prev->next=temp;/*尾节点的后驱指向新节点*/

return head;

}
/*=============================================================================*/

/*删除节点*/
Node*DeleteNode(Node*head,char elem)
{
if(NULL== head|| NULL== elem)
return head;
if(NULL== head->next)
return head;

 Node*prev,*current;
 prev=head;
 current=head->next;

while(current)
 {
if(current->elem== elem)/*匹配节点元素*/
 {
 prev->next=current->next;/*前驱节点的后驱指向当前节点的下一个节点*/
 free(current);/*释放当前节点*/
return head;
 }
 prev=current;
 current=current->next;/*移动至下一个节点*/
 }

return head;

}

/*=============================================================================*/


/*单链表逆置*/
Node*ReverseList(Node*head)
{
if(NULL== head)
return head;
if(NULL== head->next)
return head;
if(NULL== head->next->next)
return head;

 Node*curr=head->next;/*当前节点*/
 head->next=NULL;
 Node*temp;

while(curr)
 {
 temp=curr->next;/*暂存下一个节点*/
/*把当前节点插入到head节点后*/
 curr->next=head->next;
 head->next=curr;

 curr=temp;/*移动至下一个节点*/
 }

return head;

}

/*=============================================================================*/

/*求中间节点*/
Node* MiddleNode(Node*head)
{
if(NULL== head)
return head;
if(NULL== head->next)
return head->next;

 Node*p1,*p2;
 p1=head;
 p2=head;

while(p2->next)
 {
/*p2节点移动2个节点位置*/
 p2=p2->next;
if(p2->next)/*判断p2后驱节点是否存在，存在则再移动一次*/
 p2=p2->next;
/*p1节点移动1个节点位置*/
 p1=p1->next;

 }
return p1;

}


/*=============================================================================*/

/*合并有序单链表*/
Node* MergeList(Node* h1,Node* h2)
{
if(NULL== h1|| NULL== h2)
return h1;
if(NULL== h1->next)
return h2;
if(NULL== h2->next)
return h1;

Node* curr1,*curr2,*prev1,*temp;
 prev1=h1;/*链表1的前驱节点*/
 curr1=h1->next;/*链表1的当前节点*/
 curr2=h2->next;/*链表2的当前节点*/
 temp=h2;
while(curr2)
 {
while(curr1&& curr1->elem< curr2->elem)/*链表1指针移动至大或等于链表2当前元素的位置*/
 prev1=curr1,curr1=curr1->next;

/*在链表1中插入链表2的当前元素*/
 temp=curr2->next;/*暂存链表2的下一个节点*/
 prev1->next=curr2;
 curr2->next=curr1;

/*链表1移动至新节点*/
 curr1=curr2;
/*链表2移动至下一个节点*/
 curr2=temp;
 }

return h1;
}
/*=============================================================================*/

/*创建双链表*/
DNode* DoubleList(DNode*head)
{
if(NULL== head)//分配头节点空间
 head=(DNode*)malloc(sizeof(DNode)) ,head->prev=NULL , head->next=NULL;

 DNode*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n inputelem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(DNode*) malloc (sizeof(DNode) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 temp->prev=current;/*新节点的前驱指向当前节点*/
 current=temp;/*当前节点为链表尾节点*/

 }
return head;
}

/*=============================================================================*/
/*输出双链表*/
void PrintDoubleList(DNode*head)
{
if(NULL== head)
return;

 DNode* p;
 p=head;
 cout<<"\n DoubleListare:";
while(p->next)
 {
 p=p->next;
if(p->elem)
 cout<<setw(5)<<p->elem;

 }

 cout<<"\n DoubleListare:";
while(p->prev)
 {
if(p->elem)
 cout<<setw(5)<<p->elem;
 p=p->prev;
 }

}

/*=============================================================================*/
/*创建循环链表*/
Node* CycleList(Node*head)
{
if(NULL== head)/*分配头节点空间*/
 head=(Node*)malloc(sizeof(Node)),head->next=NULL;

 Node*current=head ,*temp;
char ch;

while(1)
 {
 cout<<"\n inputelem:";
 cin>>ch;
if('#' == ch)/*#结束输入*/
break;
 temp=(Node*) malloc (sizeof(Node) );
 temp->elem=ch;
 temp->next=NULL;
 current->next=temp;/*当前节点的后驱指向新节点*/
 current=temp;/*当前节点为链表尾节点*/

 }
 current->next=head;/*尾节点指向头节点*/
return head;
}
/*=============================================================================*/

/*判断链表是否有环(循环链表)*/
bool IsCycleList(Node*head)
{
if(NULL== head)
return false;
if(NULL== head->next)
return false;
 Node*current=head->next;
while(current)
 {
if(head== current->next)
return true;
 current=current->next;
 }
return false;
}
int main()
{
 Node* head,*p;
 Node* head2,*head3;
 DNode* dHead;
char ch;
 head= NULL;
 head2=NULL;
 head3=NULL;
 dHead=NULL;

//head=(Node*)malloc ( sizeof( Node) );
//head->next= NULL;

//创建单链表
 head=CreateList(head);
 PrintList(head);

 head2=CreateList(head2);
 PrintList(head2);

//插入节点
  cout<<"\n input elem toinsert:";
 cin>>ch;
 InsertNode(head,ch);
 PrintList(head);

//删除节点
  cout<<"\n input elem todelete:";
 cin>>ch;
 DeleteNode(head,ch);
 PrintList(head);

//单链表逆置
  head=ReverseList(head);
 cout<<"\n Reversed !";
 PrintList(head);

//求中间节点
 p=MiddleNode(head);
 cout<<"\n Middle Nodeis:";
 cout<<p->elem<<endl;

//合并有序单链表
 MergeList(head,head2);
 cout<<"\n Merged!";
 PrintList(head);

//创建双链表
 dHead=DoubleList(dHead);
 PrintDoubleList(dHead);

/*创建循环链表并判断是否有环*/
 head3=CycleList(head3);
 cout<<IsCycleList(head3);
return 0;
}

链表常用操作汇总
qq_44271654的博客
04-22 626
链表是比较常用的数据结构 以下是链表常用操作的7种，注释中介绍了不同操作的时间复杂度，记住这些常用操作，写代码时将会更加顺手。 # 作者：zff # 日期：2022/4/22 # 目的：链表常用操作 from collections import deque print('--------1、创建链表---------') linkedlist=deque() print('--------2、添加元素---------') #Time Complexity:O(1) linkedlist.append
深入理解链表（SList）操作
最新发布
在不断学习中
10-09 1311
学习链表之前，先让我们来思考一个问题：为什么有了顺序表，还需要有链表这样的数据结构呢？顺序表存在的一些问题：顺序表在中间/头部的插入删除，要挪动很多数据，时间复杂度为O(N)，效率太低了。增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。增容一般是一次增长2倍，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间SeqList。为了更好的解决上述问题，引入了链表。//定义单链表节点。
链表的基本操作
热门推荐
conanswp的专栏
04-09 9万+
链表的基本操作：内容包括链表的创建，增加、删除节点，链表的逆序、排序和销毁等。
链表的操作
欢迎来到Sylinx_yqg的博客
11-05 465
/**********************************************链表的操作 BY YQG.06.3.6***********************************************/#include"stdio.h"#include"stdlib.h"#include"string.h"#ifndef FALSE#define FALSE
Java实现链表的常见操作算法详解
08-25
本篇文章将深入探讨如何在Java中实现单链表的常见操作。 首先，我们需要创建一个表示链表节点的类`Node`。`Node`类通常包含两个属性：`data`用于存储数据，`next`用于存储指向下一个节点的引用。如下所示： ```...
数据结构中链表及常见操作.docx
04-01
链表的常见用途在于处理需要频繁添加、删除和遍历数据的情况，但较少涉及随机检索。例如，在实现动态数组、队列、栈等数据结构时，链表往往是一个很好的选择。 链表与数组的主要区别在于： 1. 存储方式：数组的元素...
lianbiao.rar_链表基本操作_链表操作
09-24
在链表的头部、尾部或指定位置插入节点是常见的操作。在头部插入节点只需修改头节点，而在尾部插入需要遍历链表找到最后一个节点。例如，在链表头部插入节点的函数可以这样实现： ```c void insertAtHead...
数据结构中链表及常见操作.pdf
04-01
链表的常见用途包括需要频繁添加或删除元素的情况，因为这些操作在链表上执行非常高效。然而，如果频繁需要访问特定位置的元素，数组可能更为合适，因为数组提供了随机访问的能力。 链表与数组的主要区别： 1. ...
链表常见操作：逆置(反转)
CCPP Blog
05-20 1万+
链表中的一个很常见的操作是：链表的逆置，也叫链表的反转。 如：1->3->5->7->9 反转后是 9->7->5->3->1
链表常见操作
码农在途的博客
03-02 587
链表常见类型 每一种新数据结构的出现都是为了解决原有数据结构的不足。链表的出现正是为了补充数组只能连续存储的不足。这种离散存储的方式自然携带了动态存储的特性。 单链表 单链表 是链表中最为常见的链表形式，链表中只有一个指向下一结点的指针。链表中的最后一个结点通常指向 NULL，表示链表的结束。 //Definition for singly-linked list. struct ListNod...
链表——单链表常见的五种操作
我的博客
05-31 560
带头链表，单链表的常见操作
数据结构与算法 — 初识链表、链表的常见操作及实现
m0_59897687的博客
01-07 1002
目录 一、初识链表 二、封装链表结构 三、链表常见操作及实现 1.链表中常见的操作 2.append()方法 3.toString()方法 4.insert()方法 5.get()方法 6.indexOf()方法 7.update()方法 8.removeAt()方法 9.remove()方法 10.isEmpty()方法 11.size()方法 一、初识链表 链表和数组一样，可以用于存储一系列的元素，但是链表和数...
链表的常见问题
李孟的博客
07-18 1887
链表指针转动，很容易转晕，介绍其中有几个常见的技巧。 一.指针/引用含义 指针/引用，实际上都是存储所指对象内存。 将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。 二.指针丢失和内存泄漏 插入节点时，注意操作顺序。 删除节点时，注意释放空间。 三.哨兵 哨兵结点的链表叫做带头链表，这样节省判断head == null 四.边界条件 如果链表为空时，代码是否能正常工作？ 如果链表只包含一个结点时，代码是否能
C语言链表操作详解
链表是一种在程序设计中常见的数据结构，它不同于数组，不连续存储元素，而是通过指针链接各个节点。在C语言中，链表的实现通常涉及到结构体和指针的使用。本摘要将深入探讨链表的基本概念、创建方法、操作以及如何...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值