链表的常见操作

最新推荐文章于 2023-11-08 12:48:11 发布
最新推荐文章于 2023-11-08 12:48:11 发布
阅读量826 收藏
点赞数
分类专栏： 链表 windows编程 linux 文章标签： 链表 算法 应用
windows编程 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
linux
2 篇文章 0 订阅
订阅专栏
链表
1 篇文章 0 订阅
订阅专栏

链表的常见操作


 

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

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

 

一、链表创建

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

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

　　代码如下：

 

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


/*双链表节点结构*/
typedef struct 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;
}


/*创建双链表*/
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;
}

 

二、链表操作

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


/*插入节点*/

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";
}


三、单链表逆置

　　单链表逆置在各公司的笔试题中比较常见，以下是其中一种实现。
　　算法描述：将链表中每一个节点插入到头结点之后。
　　代码如下： 

/*单链表逆置*/
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)
returnfalse;
if(NULL == head->next)
returnfalse;
    Node *current=head->next;
while(current)
    {
if(head == current->next)
returntrue;
        current=current->next;
    }
returnfalse;
}

 


 

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


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

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


/*双链表节点结构*/
typedef struct 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 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;
}


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

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

    }

    cout<<"\n DoubleList are:";
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 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;
}
/*=============================================================================*/

/*判断链表是否有环(循环链表)*/
bool IsCycleList(Node *head)
{
if(NULL== head)
returnfalse;
if(NULL == head->next)
returnfalse;
    Node *current=head->next;
while(current)
    {
if(head == current->next)
returntrue;
        current=current->next;
    }
returnfalse;
}
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 to insert:";
    cin>>ch;
    InsertNode(head,ch);
    PrintList(head);


//删除节点

    cout<<"\n input elem to delete:";
    cin>>ch;
    DeleteNode(head,ch);
    PrintList(head);

//单链表逆置

    head=ReverseList(head);
    cout<<"\n Reversed !";
    PrintList(head);

//求中间节点

    p=MiddleNode(head);
    cout<<"\n Middle Node is:";
    cout<<p->elem<<endl;

//合并有序单链表

    MergeList(head,head2);
    cout<<"\n Merged!";
    PrintList(head);

//创建双链表

    dHead=DoubleList(dHead);
    PrintDoubleList(dHead);

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



孤飞俊驰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的基本操作
zk031的博客
09-01 339
C/C++ 首先，用结构体创建节点 struct ListNode { int val; ListNode* next; };一、初始化操作 第1种，不返回的情况 void InitList1(ListNode **L) { *L =(ListNode*)malloc(sizeof(ListNode)); (*L)->next=NULL; } 第2种，不返回的情况
浅谈“C语言链表的使用及其注意事项”
超级霸霸强的博客
10-29 762
C语言中链表的使用 什么是链表？ 在C语言中，我们无法使用向C++中的STL标准库中的vector等动态数组，但是我们可以用maclloc不断地申请在空间上不连续的内存段供我们使用，我们想“如果将这些零零散散的内存段通过一定方式连接起来，是不是可以当作连续的存储空间使用呢？”，此时“链表”的概念就问世了，我们所用的数组在内存空间上是连续的： 这种内存空间的申请方式非常有利于我们顺序访问，可问题来了“哪有那么多连续的存储空间供我们使用呢？”，因此，我们的链表采用如下方式来将零零散散的内存段整合.
数据结构
011eH
08-03 72
队列 public class ArrayQueue { private int head; private int tail; private final int[] nums; private final int maxSize; public ArrayQueue(int maxSize) { this.maxSize = maxSize + 1; nums = new int[this.maxSize]; }
【理解链表指针赋值】链表中cur-＞next = cur-＞next-＞next-＞next与cur =cur-＞next-＞next的区别
最新发布
Law of Conservation of Eudaemonia
11-08 1060
对cur赋值不会改变原本的链表排布，对cur->next或cur->next->next等等赋值可能会改变链表排布。
Java实现链表的常见操作算法详解
08-25
主要介绍了Java实现链表的常见操作算法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C语言单链表常见操作汇总
09-04
本文总结了C语言单链表的常见操作，主要包括创建单链表、求单链表的长度、查找前驱结点、删除结点值为x的元素、将表中的元素逆置、对单链表排序、删除相同元素、在升序链表中插入新的元素等操作。 创建单链表： 在...
C++中链表操作实例分析
08-30
在C++中，链表是一种常见的重要数据结构。它是动态地进行存储分配的一种结构，可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。 链表中的每一个元素称为...
深入理解链表的各类操作详解
01-20
链表概述链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为...
数据结构中链表及常见操作.docx
04-01
链表的常见用途在于处理需要频繁添加、删除和遍历数据的情况，但较少涉及随机检索。例如，在实现动态数组、队列、栈等数据结构时，链表往往是一个很好的选择。 链表与数组的主要区别在于： 1. 存储方式：数组的元素...
单链表的反转
m0_73744158的博客
04-09 147
让pcurrent的指向由前向后变为由后向前，这样就可以指出来。
c语言单链表双向链表区别,数据结构之链表篇(单链表，循环链表，双向链表)C语言版...
weixin_29358811的博客
05-21 452
1.链表链表是线性表的一种，由一系列节点(结点)组成，每个节点包含一个数据域和一个指向下一个节点的指针域。链表结构可以克服数组需要预先知道数据大小的缺点，而且插入和删除元素很方便，但是失去数组随机读取的优点。链表有很多种不同类型：单向链表，双向链表和循环链表。在链表中第一个节点叫头节点(如果有头节点)头节点不存放有效信息，是为了方便链表的删除和插入操作，第一个有效节点叫首节点，最后一个节点叫尾节点...
206. 反转链表（简单 链表 递归）
weixin_43942435的博客
01-05 440
206. 反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] 提示： 链表中节点的数目范围是 [0, 5000] -5000 <= Node.val <= 5000 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/rev
链表各类操作详解
ajwh64482的博客
07-07 965
链表概述　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素...
合并两个无序链表
shangshanzixu的博客
04-07 3287
楼主昨天看到阿里的一道算法题是只使用O(1)的额外空间，合并两个无序链表。乍一看有点奇怪，一般都是双指针算法合并两个有序链表，后面思考过后除了不能像数组能够随机访问链表的每个元素外合并两个有序链表实际上就是先对每个链表进行排序，然后将两个有序链表合并起来。也就是分为两步。 对两个链表分别排序 将两个有序链表合并起来 然后楼主看了一下网上的其他帖子，大部分都是使用选择啊、冒泡啊这种O(n^2)的算法。这效率实在太低了。尽管链表确实不像数组那样访问元素方便，但是通过快慢指针我们页能很快的就找到我们链表中指定的
链表的问题，ListNode问题
weixin_30773135的博客
05-21 5226
算法面试，有关ListNode的问题 class ListNode{ 　ListNode *next; 　int val; 　ListNode(int x): val(x){}}; 在面试的时候，怎么快速想到解题的思路呢？ 主要的问题，在于当链表开始的怎么判断，在链表结束的怎么判断？ 可以试一试定义一个假的头节点，不是指针类型，new出一个新的节点。这在数据结构课上，一开始就有的。 ...
k个一组翻转链表(迭代法、递归法)
weixin_61898526的博客
04-20 819
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。 示例 1： 输入：head = [1,2,3,4,5], k = 2 输出：[2,1,4,3,5] 示例 2： 输入：head = [1,2,3,4,5], k = 3 输出：[3,2,1,4,5] ...
链表的操作
05-25
链表是一种常见的线性数据结构，它由一系列节点...除了基本操作外，还有其他一些常见的操作，例如翻转链表、合并两个有序链表等。需要注意的是，在进行链表操作时，一定要注意指针的变化，以避免出现空指针异常等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值