链表相关的算法题大汇总(2) — 数据结构之链表奇思妙想

声明:转自http://hi.baidu.com/lanxuezaipiao/item/afc616caf8393a155050585b


高级函数(具体代码实现见后面)

1.单链表反转

思路1:O(n^2).

       我的做法是“狸猫换太子”,不进行改动链表结构,只首尾交换len/2次。但是在本函数中用到了定位函数,定位函数实际上是遍历了一遍整个链表,所以综合效率很低,达到O(n^2).

void reverseList(Node*Head)

思路2:O(n).

       就最一般的情况而言(没有之前写的那么多辅助函数,即条件单纯为只有Head指向一个单链表)。那么可以实现O(n)效率。做法是用三个相邻的指针进行遍历,在遍历的途中,更改指针方向。当然要注意链表数目分情况,和拆链的处理。

Node* reverseList2(Node*Head)

 

2.找出单链表的倒数第4个元素

思路1:O(2n)

        先遍历一遍链表记录节点个数。然后定位该位置count-3,定位函数实际上也是遍历一遍,所以总效率O(n)+O(n)

bool findLast4th1(Node*Head,int &ans)

思路2:O(n)

        如果题目限制要求,仅允许遍历一遍,则可以按如下方法进行。先定义两个指针,第一个指针先走4步,然后从这时开始,第一个指针和第二个指针同时继续走,即第一个指针和第二个指针相差4步。则第二个指针到头时,第一个指针指向倒数第四个。注意要考虑链表长度。

bool findLast4th2(Node*Head,int &ans)

思路3:O(n)

        做一个数组arr[4],让我们遍历单链表,把第1个、第5个、第9个……第4N+1个扔到arr[0],把第2个、第6个、第10个……第4N+2个扔到arr[1],把第3个、第7个、第11个……第4N+3个扔到arr[2],把第4个、第8个、第12个……第4N个扔到arr[3],这样随着单链表的遍历结束,arr中存储的就是单链表的最后4个元素,找到最后一个元素对应的arr[i],让k=(i+1)%4,则arr[k]就是倒数第4个元素。如果不易理解,画个图就好了。注意增加的空间只需要4个,所以是常数级的。比如加到第5个节点时就会把arr[0]中的值冲掉。

bool findLast4th3(Node*Head,int &ans)

 

3.找出单链表的中间元素

思路1:O(2n)

         在函数的支持下,直接求整个链表的长度,然后定位中间元素。

bool getMiddleOne1(Node*Head,int&ans)

思路2:O(n)

        如果仍要求只遍历一遍。类似于上题,还是使用两个指针first和second,只是first每次走一步,second每次走两步:

bool getMiddleOne2(Node*Head,int&ans)

 

4.删除无头单链表的一个节点

思路:

         注意这里的要求是无头链表,即未知Head指针。但是知道的是current指针指向该链表的某一位置。现在希望删除该指针,而不影响整个链表。即虽然不知道Head指针,但是该链还是完整的。

        首先需要明确一点,即current指针之前的链表段落是不可能知道的。这是由链表的单向性决定的。没有任何技术可以做到这一点。

        其次,删除链表某节点,该节点不能是首节点,因为首节点一旦删除,Head无法找到该链表了。

        再次,删除链表某节点,该节点不能是尾节点,因为尾节点一旦删除,则尾节点的前一节点的指针域无法置0(因为单链无法回溯)。

        所以题意解释为:删除无头单链表的一个节点(既非首节点也非尾节点)。

        解法是利用“狸猫换太子”。首先复制current指针的下一个节点的value到current节点中。然后删除current的下一节点。

void deleteNoHeadList(Node*Head,Node*Current)

               

4+.增加无头单链表的一个节点,一个指针current指向单链表中的一个节点,在该节点之前增加一个节点insertNode。

思路:

         思路还是“狸猫换太子”,即在current之后增加一个节点insertNode,然后交换insertNode和current的值。

         由于在current之后增加节点这个操作在current指向首尾都可以实现。

         所以这道问题转化为:增加无头单链表的一个节点,current指针指向该链表某节点(可以为首尾),在其之前增加节点p。

void addNoHeadList(Node*Head,Node*Current,Node*insertNode)

 

5.两个不交叉的有序链表的合并

思路:O(len1+len2)

        合并的办法如下,首先用Node*& 方式传入两个链表的头指针Head1,Head2。用指针引用是因为最后要修改Head1和Head2均为NULL。否则可能被其他人误引用了。然后定义一个合并后的链表的头指针和尾指针Head和Tail。然后不断比较Head1和Head2的首元素,加入到新的合并的链表中。注意一点这里的加入并不是先增加申请一个节点分配,然后删除释放原来的节点。而是直接将指针指向。也就是说在合并的过程中只是指针指向改变了,完全没有申请新的内存和释放节点空间。最后如果有一个Head1或Head2的已经空了,则直接将剩余链表连接到Head即可。当然要注意很多细节。

Node* mergeTwoList(Node*& Head1,Node*& Head2)

 

6.有个二级单链表,其中每个元素都含有一个指向一个单链表的指针。写程序把这个二级链表称一级单链表。

思路:

        注意要重新定义二级单链表的结构,具体的算法是:把所有的下级单链表顺次连接。即可。程序代码略。

 

7.单链表交换任意两个元素(不包括表头)

思路:

          利用“狸猫换太子”,不破坏链表结构,只交换二者Node* cur1和Node* cur2的指向的值。程序代码略。

          其中的任意两个元素由外界给定该两个节点的指针。

 

8.判断单链表是否有环(6形状)?如何找到环的“起始”点?如何知道环的长度?


思路:

        注意分析题意,题意并非是说单链表完全成O形状的环,而是说单链表成6形状的环。

        首先判断是否有环:为此我们建立两个指针,从Head一起向前跑,一个步长为1,一个步长为2,用

  while(直到步长2的跑到结尾)
{
检查两个指针是否相等,直到找到为止。
}

来进行判断。

            原因是,在这场跑步中,结束循环有两种可能,其一是原来无环,所以2先跑到结尾,因为2比1快,二者不可能相等。其二是原来是有环的,因为这场赛跑永远没有z终点,但是在环中,由于2比1快,因而必定套圈,也即2追上了1,这在无环中是不可能出现的情况。

           而进行计算环的长度,只要找到交汇点,然后在圈中跑一次就可以了。

int getCircleLength(Node* cross)

bool judgeCircleExists(Node* Head)

        

9.判断两个单链表是否相交


            注意这里是判断是否相交。对于判断问题来讲,相对还是比较简单的。注意单链表并非不能有重复元素。

思路1:O(len1*len2)

            把第一个链表的指针值逐项存在hashtable中,遍历第2个链表的每一项的指针值,如果能在第一个链表中找到,则必然相交。但是C++的STL模板中的hash不太会用。所以我使用了set集合,不过貌似set集合是使用遍历的方式来查找元素是否在集合中的,所以效率是比较低的,至少在O(len1*len2)级别。

bool judgeIntersectList1(Node* Head1,Node* Head2)

思路2:O(len1+len2)

          把一个链表A接在另一个链表B的末尾,如果有环,则必然相交。如何判断有环呢?从A开始遍历,如果能回到A的表头,则肯定有环。

注意,在返回结果之前,要把刚才连接上的两个链表断开,恢复原状。

bool judgeIntersectList2(Node* Head1,Node* Head2)

思路3:O(len1+len2)

         如果两个链表的末尾元素相同(指针相同,即为同一个元素,而非值相等),则必相交。
bool judgeIntersectList3(Node* Head1,Node* Head2)

 

10.两个单链表相交,计算相交点

思路1:

         分别遍历两个单链表,计算出它们的长度M和N,假设M比N大,则长度M的链表先前进M-N,然后两个链表同时以步长1前进,前进的同时比较当前的元素,如果相同,则必是交点。
Node* getIntersectPoint(Node* Head1,Node* Head2)

思路2:

         将指针p1,p2定位到两个链表的尾部,然后同时将两个指针前移(不可以,因为是单向链表)

 

11.用链表模拟大整数加法运算

思路:

        对于高精度大数计算,没有数组那么高效,具体数组的做法参见OJ高精度,链表的好处是可以定义节点,其中包含指数次数和值两部分,比如20001可以表示为(2,4)->(1,0)->NULL其中2表示值,4表示10的4次方。这样的话如果数属于稀疏型的则以较少的空间保存了值。具体程序略。

 

12.单链表排序

思路:

         参见基本函数13://冒泡排序链表,具体的做法是“狸猫换太子”,即只交换节点中的值,对链表结构不做改动。

void sortList(Node*& Head);


 

13.删除单链表中重复的元素

思路:

         用Hashtable辅助,遍历一遍单链表就能搞定。同高级函数9的原因,我不太会使用C++STL中的hash。而如果使用set集合来存储链表中的所有的值,实际上效率和每次重新遍历单链表是一样的。“用了c++标准库中的set来保存访问过的元素,所以很方便的就可以判断当前节点是否在set集合中,直接使用set提供的find函数就可以了。而且使用set的查找在时间复杂度上比较低。”我不太清楚STL中set集合的实现方式,如果是基于类似hash结构的话,那自然效率O(1),而如果是数组的话,实际在遍历一遍,所以效率O(n)。不过貌似后者的可能性大一些。

void DeleteDuplexElements(Node*Head);


高级函数代码:

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.单链表反转1

//单链表反转(O(n^2))
void reverseList(Node*Head)
{
 int count=numOfNodes(Head);
 //“狸猫换太子”,首尾交换
 for(int i=1;i<=count/2;i++)
 {
  Node* p1=locateNodeI(Head,i);
  Node* p2=locateNodeI(Head,count+1-i);
  swap(p1->value,p2->value);
 }
}

1.单链表反转2
//单链表反转(O(n))
Node* reverseList2(Node*Head)
{
 if(Head==NULL||Head->next==NULL)//空链和单节点
 {
  return Head;
 }
 Node* p1=Head;
 Node* p2=Head->next;
 Node* p3=Head->next->next;
 if(p3==NULL)//只有两个节点
 {
  p1->next=NULL;
  p2->next=p1;
  Head=p2;
  return Head;
 }
 else//至少三个节点
 {
  p1->next=NULL;
  while(p3!=NULL)
  {
   p2->next=p1;
   p1=p2;
   p2=p3;
   p3=p3->next;
  }
  p2->next=p1;
  Head=p2;
  return Head;
 }
}

2.找出单链表的倒数第4个元素1

//查找倒数第四个元素,传入ans中 O(2N)
bool findLast4th1(Node*Head,int &ans)
{
 //先确定节点个数:
 int count=numOfNodes(Head);
 //定位count-4
 Node* p=locateNodeI(Head,count-3);
 if(p!=NULL)
 {
  ans=p->value;
  return true;
 }
 else 
 {
  return false;
 }
}

2.找出单链表的倒数第4个元素2

//查找倒数第四个元素,传入ans中 O(N),只遍历一遍
bool findLast4th2(Node*Head,int &ans)
{
 Node* p1=Head;
 Node* p2=Head;
 //p1先走4步。
 for(int i=0;i<4;i++)
 {
  if(p1!=NULL)
  {
   p1=p1->next;
  }
  else
  {
   return false;//肯定链表长度不够
  }
 }
 //同步移动
 while(p1!=NULL)
 {
  p1=p1->next;
  p2=p2->next;
 }
 ans=p2->value;
 return true;

}

2.找出单链表的倒数第4个元素3

//查找倒数第四个元素,传入ans中 O(N)
bool findLast4th3(Node*Head,int &ans)
{
 int arr[4];
 Node* p=Head;
 int i=0;
 int count=0;
 while(p!=NULL)
 {
  arr[i]=p->value;
  p=p->next;
  i=(i+1)%4;
  count++;
 }
 if(count<4)
 {
  return false;
 }
 else
 {
  ans=arr[i];
  return true;
 }
}

3.找出单链表的中间元素1

//获取中间元素O(2n)
bool getMiddleOne1(Node*Head,int&ans)
{
 int count=numOfNodes(Head);
 if(count==0)
 {
  return false;
 }
 else
 {
  Node* p=locateNodeI(Head,(count+1)/2);
  ans=p->value;
  return true;
 }

}

3.找出单链表的中间元素2

//获取中间元素O(n)
//类似于上题,还是使用两个指针first和second,只是first每次走一步,second每次走两步:
bool getMiddleOne2(Node*Head,int&ans)
{

 if(Head==NULL)//空链表
 {
  return false;
 }
 else
 {
  Node*first=Head;
  Node*second=Head->next;
  while(second!=NULL&&second->next!=NULL)
  {
   first=first->next;
   second=second->next;
   second=second->next;
  }
  ans=first->value;
  return true;
 }
}

4.删除无头单链表的一个节点

//删除无头单链表的非首尾节点"狸猫换太子";
void deleteNoHeadList(Node*Head,Node*Current)
{
 Node* p=Current->next;
 //一定是非首尾节点,否则会出错
 Current->value=Current->next->value;
 Current->next=Current->next->next;
 free(p);
}

4+.增加无头单链表的一个节点,一个指针current指向单链表中的一个节点,在该节点之前增加一个节点insertNode。
//增加无头单链表的一个节点,current指针指向该链表某节点(可以为首尾),在其之前增加节点insertNode。
void addNoHeadList(Node*Head,Node*Current,Node*insertNode)
{
 insertNode->next=Current->next;
 Current->next=insertNode;
 swap(Current->value,insertNode->value);
}

5.两个不交叉的有序链表的合并
//合并两个有序的链表
Node* mergeTwoList(Node*& Head1,Node*& Head2)
{
 Node* Head=NULL;//合并后的链表
 Node* Tail=NULL;//合并后链表的尾指针

 //p1,p2遍历两个链表
 Node* p1=Head1;
 Node* p2=Head2;
 while(!(p1==NULL||p2==NULL))
 {
  if(p1->value<=p2->value)
  {
   if(Head==NULL)//第一个节点
   {
    Head=p1;
    Tail=Head;
   }
   else
   {
    Tail->next=p1;
    Tail=Tail->next;
   }
   p1=p1->next;
  }
  else
  {
   if(Head==NULL)//第一个节点
   {
    Head=p2;
    Tail=Head;
   }
   else
   {
    Tail->next=p2;
    Tail=Tail->next;
   }
   p2=p2->next;
  }
 }
 if(p1!=NULL)
 {
  if(Head!=NULL)
  {
   Tail->next=p1;
  }
  else
  {
   Head=p1;
  }
 }
 else if(p2!=NULL)
 {
  if(Head!=NULL)
  {
   Tail->next=p2;
  }
  else
  {
   Head=p2;
  }

 }
 Head1=NULL;
 Head2=NULL;
 return Head;
}

8.判断单链表是否有环(6形状)?如何找到环的“起始”点?如何知道环的长度?1
//计算单链表成环,环的长度,输入的参数为成环的交汇点。
int getCircleLength(Node* cross)
{
 int len=1;
 Node* p=cross;
 while(p->next!=cross)//千万不能写作p->next!=p
 {
  len++;
  p=p->next;
 }
 return len;
}

8.判断单链表是否有环(6形状)?如何找到环的“起始”点?如何知道环的长度?2

//判断单链表是否有环,并且返回环的长度
bool judgeCircleExists(Node* Head,int &len)
{
 
 if(Head==NULL)//空链
 {
  return false;
 }
 else if(Head->next==Head)//1个节点且成环
 {
  return true;
 }
 else if(Head->next==NULL)//1个节点不成环
 {
  return false;
 }

 //至少两个节点情形
 //初始化跑步机
 Node* p1=Head;//跑步者1号,跑到第1个节点
 Node* p2=Head->next;//跑步者2号,跑到第2个节点
 while(p2!=NULL&&p2->next!=NULL)//利用了&&短路
 {
  p1=p1->next;
  p2=p2->next->next;
  if(p1==p2)
  {
   //此时p1(p2)即为交汇点
   len=getCircleLength(p1);
   return true;
  }
 }
 return false;

}

9.判断两个单链表是否相交1
//判断两个单链表是否相交(Y型)
bool  judgeIntersectList1(Node* Head1,Node* Head2)
{
 set<Node*>s;

 Node* p1=Head1;
 Node* p2=Head2;
 while(p1!=NULL)
 {
  s.insert(p1);
  p1=p1->next;
 }
 while(p2!=NULL)
 {
  if(s.find(p2)!=s.end())
  {
   s.clear();
   return true;
  }
  p2=p2->next;
 }
 s.clear();
 return false;
}

9.判断两个单链表是否相交2

//判断两个单链表是否相交(Y型)
bool  judgeIntersectList2(Node* Head1,Node* Head2)
{
 if(Head1==NULL||Head2==NULL)
 {
  return false;
 }

 Node* p1=Head1;
 Node* p2=Head2;
 //先找到链表2的末尾,由p2指向
 while(p2->next!=NULL)
 {
  p2=p2->next;
 }
 //将链表1的表头与链表2的表尾连接
 p2->next=p1;
 //遍历链表1,如果回到了链表1表头,则相交
 while(p1!=NULL)
 {
  if(p1->next==Head1)
  {
   //记得恢复原状:
   p2->next=NULL;
   return true;
  }
  p1=p1->next;
 }
 //记得恢复原状:
     p2->next=NULL;
 return false;
}

9.判断两个单链表是否相交3

//判断两个单链表是否相交(Y型)
bool  judgeIntersectList3(Node* Head1,Node* Head2)
{
 if(Head1==NULL||Head2==NULL)
 {
  return false;
 }

 Node* p1=Head1;
 Node* p2=Head2;
 //p1与p2记录两链表的尾指针
 while(p1->next!=NULL)
 {
  p1=p1->next;
 }
 while(p2->next!=NULL)
 {
  p2=p2->next;
 }
 if(p1==p2)
 {
  return true;
 }
 return false;
}

10.两个单链表相交,计算相交点
//两链表相交,计算相交点:
Node* getIntersectPoint(Node* Head1,Node* Head2)
{
 int len1=numOfNodes(Head1);
 int len2=numOfNodes(Head2);
 int initMove=abs(len1-len2);
 Node* p1=Head1;
 Node* p2=Head2;

 if(len1>len2)
 {
  for(int i=0;i<initMove;i++)
  {
   p1=p1->next;
  }
 }
 else
 {
  for(int i=0;i<initMove;i++)
  {
   p2=p2->next;
  }
 }
 while(p1!=NULL&&p2!=NULL)
 {
  if(p1==p2)
  {
   return p1;
  }
  p1=p1->next;
  p2=p2->next;

 }
 return NULL;
}

12.单链表排序

//链表排序
//排序的方法是不破坏结构,有“狸猫换太子”的意思,只进行value的交换,不破坏链表结构
void sortList(Node*& Head)
{
 int count=numOfNodes(Head);
 if(count==0||count==1)
 {
  return ;
 }

 //冒泡排序
 bool exchange;
 for(int i=2;i<=count;i++)
 {   
  exchange=false;
  for(int j=count;j>=i;j--)
  {
   Node* p1=locateNodeI(Head,j);
   Node* p2=locateNodeI(Head,j-1);
   if(p1->value<p2->value)
   {
    exchange=true;
    swap(p1->value,p2->value);
   }
  }
  if(!exchange)
   break;
 }
}

13.删除单链表中重复的元素

//删除单链表中的重复元素:使用set集合来实现:
void DeleteDuplexElements(Node*Head)
{
 if(Head==NULL||Head->next==NULL)//链表为空或者只有一个元素
 {
  return ;
 }

 //以下至少两个元素
 set<int>s;
 Node* p1=Head;
 Node* p2=Head->next;
 s.clear();
 s.insert(p1->value);
 while(p2!=NULL)//要删除的不可能是链表头,因为如果是链表头,则集合还为空。
 {
  if(s.find(p2->value)==s.end())//没有
  {
   s.insert(p2->value);
   p2=p2->next;
   p1=p1->next;
  }
  else//已经有,则要删除该节点
  {
   //不可能是链表头
   //如果是链表尾
   if(p2->next==NULL)
   {
    p1->next=NULL;
    free(p2);
    p2=NULL;
   }
   else
   {
    p1->next=p2->next;
    free(p2);
    p2=p1->next;
   }
  }
 }
}

已标记关键词 清除标记
相关推荐
DirectX修复工具(DirectX Repair)是一款系统级工具软件,简便易用。本程序为绿色版,无需安装,可直接运行。 本程序的主要功能是检测当前系统的DirectX状态,如果发现异常则进行修复。程序主要针对0xc000007b问设计,可以完美修复该问。本程序中包含了最新版的DirectX redist(Jun2010),并且全部DX文件都有Microsoft的数字签名,安全放心。 本程序为了应对一般电脑用户的使用,采用了易用的一键式设计,只要点击主界面上的“检测并修复”按钮,程序就会自动完成校验、检测、下载、修复以及注册的全部功能,无需用户的介入,大大降低了使用难度。在常规修复过程中,程序还会自动检测DirectX加速状态,在异常时给予用户相应提示。 本程序适用于多个操作系统,如Windows XP(需先安装.NET 2.0,详情请参阅“致Windows XP用户.txt”文件)、Windows Vista、Windows 7、Windows 8、Windows 8.1、Windows 8.1 Update、Windows 10,同时兼容32位操作系统和64位操作系统。本程序会根据系统的不同,自动调整任务模式,无需用户进行设置。 本程序的V4.0版分为标准版、增强版以及在线修复版。所有版本都支持修复DirectX的功能,而增强版则额外支持修复c++的功能。在线修复版功能与标准版相同,但其所需的数据包需要在修复时自动下载。各个版本之间,主程序完全相同,只是其配套使用的数据包不同。因此,标准版和在线修复版可以通过补全扩展包的形式成为增强版。本程序自V3.5版起,自带扩展功能。只要在主界面的“工具”菜单下打开“选项”对话框,找到“扩展”标签,点击其中的“开始扩展”按钮即可。扩展过程需要Internet连接,扩展成功后新的数据包可自动生效。扩展用时根据网络速度不同而不同,最快仅需数秒,最慢需要数分钟,烦请耐心等待。如扩展失败,可点击“扩展”界面左上角小锁图标切换为加密连接,即可很大程度上避免因防火墙或其他原因导致的连接失败。 本程序自V2.0版起采用全新的底层程序架构,使用了异步多线程编程技术,使得检测、下载、修复单独进行,互不干扰,快速如飞。新程序更改了自我校验方式,因此使用新版本的程序时不会再出现自我校验失败的错误;但并非取消自我校验,因此程序安全性与之前版本相同,并未降低。 程序有更新系统c++功能。由于绝大多数软件运行时需要c++的支持,并且c++的异常也会导致0xc000007b错误,因此程序在检测修复的同时,也会根据需要更新系统中的c++组件。自V3.2版本开始使用了全新的c++扩展包,可以大幅提高工业软件修复成功的概率。修复c++的功能仅限于增强版,标准版及在线修复版在系统c++异常时(非丢失时)会提示用户使用增强版进行修复。除常规修复外,新版程序还支持C++强力修复功能。当常规修复无效时,可以到本程序的选项界面内开启强力修复功能,可大幅提高修复成功率。请注意,请仅在常规修复无效时再使用此功能。 程序有两种窗口样式。正常模式即默认样式,适合绝大多数用户使用。另有一种简约模式,此时窗口将只显示最基本的内容,修复会自动进行,修复完成10秒钟后会自动退出。该窗口样式可以使修复工作变得更加简单快速,同时方便其他软件、游戏将本程序内嵌,即可进行无需人工参与的快速修复。开启简约模式的方法是:打开程序所在目录下的“Settings.ini”文件(如果没有可以自己创建),将其中的“FormStyle”一项的值改为“Simple”并保存即可。 新版程序支持命令行运行模式。在命令行中调用本程序,可以在路径后直接添加命令进行相应的设置。常见的命令有7类,分别是设置语言的命令、设置窗口模式的命令,设置安全级别的命令、开启强力修复的命令、设置c++修复模式的命令、控制Direct加速的命令、显示版权信息的命令。具体命令名称可以通过“/help”或“/?”进行查询。 程序有高级筛选功能,开启该功能后用户可以自主选择要修复的文件,避免了其他不必要的修复工作。同时,也支持通过文件进行辅助筛选,只要在程序目录下建立“Filter.dat”文件,其中的每一行写一个需要修复文件的序号即可。该功能仅针对高级用户使用,并且必须在正常窗口模式下才有效(简约模式时无效)。 本程序有自动记录日志功能,可以记录每一次检测修复结果,方便在出现问时,及时分析和查找原因,以便找到解决办法。 程序的“选项”对话框中包含了7项高级功能。点击"常规”选项卡可以调整程序的基本运行情况,包括日志记录、安全级别控制、调试模式开启等。只有开启调试模式后才能在C
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页