链表的常见操作

最新推荐文章于 2023-11-08 12:48:11 发布
最新推荐文章于 2023-11-08 12:48:11 发布
阅读量602 收藏
点赞数
文章标签： 学习链表的必须品

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

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

 

一、链表创建

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

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

　　代码如下：

 

/*单链表节点结构*/
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)
        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全部代码如下：　
LinkList.cpp 

/*
 * 作者：     达闻东
 * 修改日期： 2010-04-28 17:10
 * 描述：     实现链表的常见操作
 * 
 */
#include<iostream>
#include<iomanip>
using namespace 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)
        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 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);
    return 0;
}
PerryXiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现链表的常见操作算法详解
08-25
本篇文章将深入探讨如何在Java中实现单链表的常见操作。 首先，我们需要创建一个表示链表节点的类`Node`。`Node`类通常包含两个属性：`data`用于存储数据，`next`用于存储指向下一个节点的引用。如下所示： ```...
链表基本操作
12-08
4. **算法效率**：链表的操作涉及到时间复杂度和空间复杂度的考虑，如查找操作的时间复杂度为O(n)，而插入和删除操作在链表头部的时间复杂度为O(1)，在中间或尾部则为O(n)。 综上所述，链表的基本操作涵盖了链表的...
链表的基本操作
zk031的博客
09-01 348
C/C++ 首先，用结构体创建节点 struct ListNode { int val; ListNode* next; };一、初始化操作 第1种，不返回的情况 void InitList1(ListNode **L) { *L =(ListNode*)malloc(sizeof(ListNode)); (*L)->next=NULL; } 第2种，不返回的情况
【理解链表指针赋值】链表中cur-＞next = cur-＞next-＞next-＞next与cur =cur-＞next-＞next的区别
最新发布
Law of Conservation of Eudaemonia
11-08 1148
对cur赋值不会改变原本的链表排布，对cur->next或cur->next->next等等赋值可能会改变链表排布。
深入理解数据结构—简单链表
seek97的博客
07-30 472
（1）简单链表结构 #include <iostream> #include <string> using namespace std; typedef int Etype; // 自定义链表的数据元素为整数。 //定义数据元素节点结构 typedef struct ChainNode { Etype data; // 存放结点的数据元素。 ChainNode* next; // 指向下一个结点的指针。 }; //ChainNode* p
lianbiao.rar_链表基本操作_链表操作
09-24
在链表的头部、尾部或指定位置插入节点是常见的操作。在头部插入节点只需修改头节点，而在尾部插入需要遍历链表找到最后一个节点。例如，在链表头部插入节点的函数可以这样实现： ```c void insertAtHead...
python操作链表的示例代码
12-16
在Python编程中，链表是一种常见的数据结构，用于存储一系列有序的数据。链表与数组不同，数组中的元素在内存中是连续存储的，而链表的每个节点包含数据和指向下一个节点的引用，使得节点可以在内存中任意位置。本文...
链表的各种操作
06-15
反转链表是另一种常见操作，它可以改变链表中节点的顺序。这可以通过迭代或递归方式实现，迭代方法需要维护三个指针：前一个节点、当前节点和下一个节点；递归方法则将链表的头部和尾部互换，然后对子链表进行递归...
单链表的反转
m0_73744158的博客
04-09 151
让pcurrent的指向由前向后变为由后向前，这样就可以指出来。
c语言单链表双向链表区别,数据结构之链表篇(单链表，循环链表，双向链表)C语言版...
weixin_29358811的博客
05-21 464
1.链表链表是线性表的一种，由一系列节点(结点)组成，每个节点包含一个数据域和一个指向下一个节点的指针域。链表结构可以克服数组需要预先知道数据大小的缺点，而且插入和删除元素很方便，但是失去数组随机读取的优点。链表有很多种不同类型：单向链表，双向链表和循环链表。在链表中第一个节点叫头节点(如果有头节点)头节点不存放有效信息，是为了方便链表的删除和插入操作，第一个有效节点叫首节点，最后一个节点叫尾节点...
数据结构-单链表操作
有朋自远方来，不亦乐乎。
07-27 1248
注意步骤（2）（3）的顺序不能颠倒，否则会导致插入位置后的部分链表丢失。（2）将新结点的next指针指向插入位置后的结点。（3）将插入位置前的节点指针next指向新的结点。（2）手动释放掉结点，回收被结点占用的存储空间。插入位置一共分三种，分别是头部插入、中间插入和尾部插入。先找到目标位置再更改结点的数据域。（1）创建一个新的要插入的结点。（1）将结点从链表中摘下。...
单链表的基本操作
qq_55299368的博客
07-27 629
如果指定节点是头节点，让新节点的后继节点设置为头节点，即new->next=head;如果删除的节点不是头节点，则通过判断头节点下一个节点是否是我们需要找的删除的节点（通过p->next->data==data来判断）；如果指定节点不是头节点，则通过判断头节点下一个节点是否是否我们需要找的指定节点（通过p->next->data==data来判断）；链表的最后一个节点是没有后继节点；如果删除的节点是头节点，让头节点直接指向第二个节点，即head=head->next;...
current() ，next()，key()等数组指针函数
chenhualeguan的专栏
10-31 1129
current() ，next()，key()等数组指针函数
数据结构-单链表
blank、的博客
11-16 167
数据结构-单链表 单链表为一段内存进行指针的指向连接另一段内存的结构，其不需要一段十分庞大的内存，他可以在物理上可以进行内存的分散，在其结构上仍然是连接的。其在内存中的基本结构如下图： 接下来我来看一下单链表的插入过程，单链表有两种插入值的方法：1、头插法，即在头部插入值，如有单链...
c++ 链表_C语言实现链表（链式存储结构）
weixin_39719165的博客
11-23 1029
链表（链式存储结构）及创建链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。例如，使用链表存储 {1,2,3}，数据的物理存储状态如下图所示： 我们看到，上图 根本无法体现出各数据之间的逻辑关系。对此，链表的解决方案是，每个数据元素在存储时都配备一个指针，用于指向自己的直...
关于链表
qq_16259125的博客
04-29 306
一、链表的定义 链表是一种数据结构，其元素个数不受限定，可以通过添加进行改变。在多节点通讯中有大量的应用。 链表的基础是结构体，在结构体中不能包含与本身类型相同的结构，但可以包含有与之相同类型结构的指针。链表中的每一项都包含在何处找到下一项的信息。 链表中会有一个头指针变量，这个指针变量保存一个地址，通过这个地址来找到这个链表。头指针节点指向第一个节点。（每个节点包含数据部分和指针部分）最后一个节点的指针指向必须为空null。 1、链表的基本使用 链表需要包含一些基本的头文件，涉及到内存的操作和字符串的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值