单链表的实现（给定某结点，删除它；给定某结点，在他前面插入一个结点等）

于 2017-10-02 11:37:23 发布
阅读量2.3k 收藏 5
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 单链表的实现-以及经
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wangle965235568/article/details/78150394
本文介绍使用C++模板实现单链表的方法，并探讨单链表的适用场景及典型问题解决方案，包括环检测、节点删除与插入等。

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

基于C++语言实现单链表(利用模板)

首先，我们要搞清楚单链表的特征，在什么情况下适合用该数据结构。
1.链表在内存上的存放是不连续的，所以不能依赖下标来寻址
单链表的结构分布图
由于它的内存结构分布，决定了它适用于插入删除较多的情况（时间复杂度O（1））

现在我们来研究关于单链表的相关问题：具体代码在结尾
1.判断一个单链表是否有环
利用快慢指针（slow,fast），起始都指向头，slow一次走一个结点，fast一次走两个结点，当slow==fast时，跳出循环，if（fast==NULL||fast->next==NULL）则说明无环，返回NULL，否则返回fast->next(此为进入环的第一个结点)。在此也可返回bool值，但为了代码的复用，返回了fast->next或者NULL。具体操作需要根据实际要求。代码在最后。
2.只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
要删除一个结点，必须知道他的前驱结点。所以在此，将该节点的后一个结点的数据域赋值给该结点，然后删除该节点的后一个结点即可（缺陷，不能删除最后一个结点）
3.只给定单链表中某个结点p(非空结点)，在p前面插入一个结点
创建一个新结点，连接到该结点之后，将该结点的数据域赋值给新结点的数据域，再将要插入的数据域赋值给该结点
4.给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。
只需要将两个链表相连判断是否有环，则可解决，调用功能1即可
5.单链表的逆置
①利用头插进行逆置
②利用前后指针进行逆置
6.已知递增有序的单链表 A,B 和C 分别存储了一个集合，设计算法实现 A：=A∪（B∩C）并使求解结构 A 仍保持递增。要求算法的时间复杂度为 O(|A|+|B|+|C|)。其中,|A|为集合A 的元素个数。
都为有序单链表，则进行遍历的时候不需要进行重复遍历。

#include <iostream>
using namespace std;

template <typename T>
class Link;

template <typename T>
class Node
{
private:
       T _data;
       Node  *_next;
public:
       Node(T val = T()):_data(val),_next(NULL) { }
       friend class Link<T>;
};
//带头节点的单链表的实现。
template <typename T>
class Link
{
public:
    Link()
    {
       _head = new Node<T>();
    }
    /*~Link()
    {
       Node<T>* pcr = _head->_next;
       while(pcr != NULL)
       {
           Node<T> *next = pcr->_next;
            _head->_next = next;
          delete pcr;
          pcr = next;
       }
    }*/
    void insertHead(T val);
    void insertTail(T val);
    void deleteNode(T val);
    Node<T>* Search(T val);           //查询val对应的节点，有则返回节点的地址，没有则返回NULL；
    Node<T>* IsExitsLoop();            //检测是否有环。

    void inverse();
    void show();                   //打印链表的所有节点
    void show1(Node<T>* p)          //只打印p指向的节点的数据
    {
        if(p != NULL)
      {
         cout<<p->_data<<endl;
      }
    }
    void deleteNode(Node<T> *p);//只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
    void insertNode(Node<T> *p,T val);//只给定单链表中某个结点p(非空结点)，在p前面插入一个结点
    Node<T>* intersection (Link<T> list2);//给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。
    void merge(Link<T> list1,Link<T> list2);
    //已知递增有序的单链表 A,B 和C 分别存储了一个集合，设计算法实现 A：=A∪（B∩C） ，
    //并使求解结构 A 仍保持递增。要求算法的时间复杂度为 O(|A|+|B|+|C|)。其中,|A|为集合A 的元素个数。
private:
    Node<T>* _head;
};
template <typename T>
void Link<T>::show()
{
   Node<T>* pcr = _head->_next;
   while(pcr != NULL)
   {
      cout<<pcr->_data<<" ";
      pcr = pcr->_next;
   }
   cout<<endl;
}
//template <typename T>
//void Link<T>::show1(Node *p)
//{
//  if(p != NULL)
//  {
//      cout<<p->_data<<endl;
//  }
//}
template <typename T>
void Link<T>::insertHead(T val)
{
    Node *pcr = new Node(val);

    pcr->_next = _head->_next;
    _head->_next = pcr;
}
template <typename T>
void Link<T>::insertTail(T val)
{
    Node<T> *pcr = new Node<T>(val);
    Node<T> *p = _head;
    while(p->_next != NULL)
    {
      p = p->_next;
    }
    p->_next = pcr;
}
template <typename T>
void Link<T>::deleteNode( T val)
{
     Node *pcr = _head;
     while(pcr->_next != NULL)
     {
        if(pcr->_next->_data == val)
        {
           Node *p = pcr->_next;
           pcr->_next = p->_next;
           delete p;
           return;
        }
        pcr = pcr->_next;
     }
}
#if 0
template <typename T>
void Link<T>::inverse()                //单链表的逆置-->最简单的方法，利用头插法，进行逆置。
{
    if(_head->_next==NULL || _head->_next->_next==NULL)
    {
       return ;
    }
   Node *pcr = _head->_next;;
   _head->_next = NULL;
   while(pcr!=NULL)
   {
       insertHead(pcr->_data);
       pcr = pcr->_next;
   }
}
#endif
template <typename T>
void Link<T>::inverse()             //利用前后指针，来逆置（稍微麻烦）
{
    if(_head->_next==NULL || _head->_next->_next==NULL)
    {
       return ;
    }
    Node *after = _head->_next;
    Node *front = _head;
    front->_next = NULL;
    while(after != NULL)
    {
       front = after;
       after = after->_next;
       front->_next = _head->_next;
       _head->_next = front; 
    }
}

template <typename T>
Node<T>* Link<T>::Search(T val)
{
   Node<T>* p = _head->_next;
   while(p != NULL)
   {
       if(p->_data == val)
       {
         return p;
       }
       p = p->_next;
   }
   return NULL;
}

//------------------------------单链表的相关经典问题---------------------------------------
//给定单链表，检测是否有环。
template <typename T>
Node<T>* Link<T>::IsExitsLoop()                      //利用快慢指针进行解析。
{
   Node<T> *fast = _head;    
   Node<T> *slow = _head;
   while(fast != NULL && fast->_next != NULL)
   {
      slow = slow->_next;
      fast = fast->_next->_next;
      if(slow == fast)
      {
         break;
      }
   }
   if(fast==NULL || fast->_next ==NULL)
   {
     return NULL;
   }
   else
   {
     return fast;
   }
}

//给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。
template <typename T>
Node<T>* Link<T>::intersection (Link<T> list2)
{
    Node<T> *p = _head->_next;
    while(p->_next !=  NULL)
    {
        p=p->_next;
    }
    p->_next = list2._head->_next;
    Node<T> *tmp = IsExitsLoop();
    if(tmp != NULL)//有交点
    {
        return tmp->_next;
    }
    else
    {
        return NULL;
    }
}



//只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
template <typename T>
void Link<T>::deleteNode(Node<T>* p)
{
    Node<T>* q = p->_next;
    p->_data = q->_data;
    p->_next = q->_next;
    delete q;
    q= NULL;
}
//只给定单链表中某个结点p(非空结点)，在p前面插入一个结点
template <typename T>
void Link<T>::insertNode(Node<T>* p,T val)          
{

   Node<T>* q = new Node<T>(val);
   q->_next = p->_next ;
   p->_next = q;
   q->_data = p->_data;
   p->_data = val;
}

////已知递增有序的单链表 A,B 和C 分别存储了一个集合，设计算法实现 A：=A∪（B∩C） ，
//并使求解结构 A 仍保持递增。要求算法的时间复杂度为 O(|A|+|B|+|C|)。其中,|A|为集合A 的元素个数。
template <typename T>
void Link<T>::merge(Link<T> list1,Link<T> list2)
{
    Node<T>* p_list1 = list1._head->_next;
    Node<T>* p_list2 = list2._head->_next;
    Node<T>* p_head = _head;
    while(p_list1 != NULL || p_list2 != NULL )
    {
        if(p_list1->_data > p_list2->_data)
        {
            p_list2 =  p_list2->_next;
        }
        else if(p_list1->_data < p_list2->_data)
        {
            p_list1 = p_list1->_next;
        }
        else
        {
            while(p_head->_next != NULL)
          {

            if(p_head->_next->_data > p_list1->_data  )
            {
                insertNode(p_head->_next,p_list1->_data);
            }
            else if(p_head->_next->_data < p_list1->_data)
            {
                p_head = p_head->_next;
            }
            else
            {
               p_head = p_head->_next;
               break;
            }
          }
            p_head->_next = new Node<T>(p_list1->_data);
            p_list2 =  p_list2->_next;
            p_list1 = p_list1->_next;
        }
    }
}


int main()
{
   Link<int> list;

   /*list.insertHead(1);
   list.insertHead(2);
   list.insertHead(3);
   list.insertHead(4);*/

   list.insertTail(1);
   list.insertTail(3);
   list.insertTail(5);
   list.insertTail(7);
   list.show();

   Link<int> list1;
   list1.insertTail(3);
   list1.insertTail(4);
   list1.insertTail(5);
   list1.insertTail(7);
   list1.insertTail(8);

   Link<int> list2;
   list2.insertTail(2);
   list2.insertTail(3);
   list2.insertTail(5);
   list2.insertTail(6);
   list2.insertTail(7);
   list2.insertTail(8);

   list.merge(list1,list2);
   list.show();
   /*Node<int>* p = list.intersection(list1);
   if(p != NULL )
   {
       list.show1(p);
   }
   list.show();*/
   /*list.inverse();
   list.show();*/
   /*list.deleteNode(4);
   list.show();*/

   //Node<int>* p = list.Search(4);
    //list.show1(p);
    //Node<int>* q = list.Search(1);
    //list.deleteNode(q);
    //list.insertNode(q,0);
    //list.show();
     //list.show1(q);
     //p->_next = q;

    /* Node<int> *s;
   if(s = list.IsExitsLoop())
   {
      cout<<"该链表有环"<<endl;
   }
   else
   {
      cout<<"该链表无环"<<endl;
   }
   list.show1(s);*/
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值