你真的懂单链表吗


 



      首先，上一道开胃菜：怎么判断两个单链表是否相交？ 
      我们假设两个单链表分别是A（有m个结点）和B（有n个结点），当然，最容易想到的肯定是两层循环，遍历A中的元素，然后分别与B中的元素进行比较，但是这样做的时间复杂度达到了O(m*n)，那么有没有更简单的办法呢？肯定有！ 
      我们来看看单链表的性质：每个结点只通过一个指针指向后继结点。那么是不是意味着两个单链表如若相交，它们就只能是Y形相交，而不可能是X形相交，亦即从第一个相同的结点开始，后面的结点全部一样。如果能想到这个，后面的就简单明了了：只要A链表和B链表的最后一个结点值相等，则证明A链表和B链表相交。该算法的时间复杂度也下降到O(m+n)。 
      我们进一步来思考：怎么找到第一个相交的元素呢？ 
      这里就当然不能像刚才那样，但是出发点还是一样，我们同样可以保证只要两次遍历。我们假设m > n，那么如果我们将两个链表的末尾对齐，是不是从最后一个往前看（当然单链表不能往前遍历，我们先这样看）的时候，A链表会比B链表多m-n个元素，而A链表中的前m-n个元素可以忽略，直接从第m-n个元素开始和B链表一起向前遍历，比较A链表上第m-n+i个元素和B链表第i个元素（i<n）即可。第一个相同的元素即为所求。参看下图可以帮助理解： 



      实现代码如下： 

Java代码  收藏代码
  1. /** 
  2.      * 寻找两个单链表第一个相同的元素。 
  3.      * @param A 第一个单链表 
  4.      * @param B 第二个单链表 
  5.      * @return 若存在相同元素，则返回其值；否则返回-1并打印消息 
  6.      */  
  7.     public static int findSame(FLinkedList A, FLinkedList B){  
  8.         int m = A.length();  
  9.         int n = B.length();  
  10.         FLinkedNode aHead = A.getElem(0);  
  11.         FLinkedNode bHead = B.getElem(0);  
  12.         if(m >= n){  
  13.             int s = m - n;  
  14.             for(int i = 0; i < s; i ++){  
  15.                 aHead = aHead.getNext();  
  16.             } // end for  
  17.             while(aHead.getNext() != null){  
  18.                 if(aHead.getValue() == bHead.getValue()){  
  19.                     return aHead.getValue();  
  20.                 }else{  
  21.                     aHead = aHead.getNext();  
  22.                     bHead = bHead.getNext();  
  23.                 } // end if-else  
  24.             } // end while  
  25.         }else{  
  26.             int s = n - m;  
  27.             for(int i = 0; i < s; i ++){  
  28.                 bHead = bHead.getNext();  
  29.             } // end for  
  30.             while(aHead.getNext() != null){  
  31.                 if(aHead.getValue() == bHead.getValue()){  
  32.                     return bHead.getValue();  
  33.                 }else{  
  34.                     aHead = aHead.getNext();  
  35.                     bHead = bHead.getNext();  
  36.                 } // end if-else  
  37.             } // end while  
  38.         } // end if-else  
  39.         System.out.println("没有找到相同的元素！！");  
  40.         return -1;  
  41.  

（代码中的FlinkedList是本人自己实现的单链表，功能和系统的LinkedList差不多，方法的功能大家看名字就基本知道了，只是它是更纯粹的单链表而已） 

      下面来看看其它的几个单链表相关的典型问题（贴代码太占空间，这里就只谈谈思路，大家可以动手试试）： 

      单链表的反转 
      如题，怎么实现一个单链表A（有m个元素）的反转呢？ 
      方案一：如果不能破坏原单链表，我们需要重新新建一个链表C，然后遍历原来的A链表，对C链表实行头插法建表（头插法即将新加入的结点作为链表的头结点，对应的还有尾插法，即直接在链表末尾添加元素）； 
      方案二：如果可以破坏原单链表呢？暴力一点的办法是不断地交换相邻的两个元素，即首先将第一个元素通过m-1次交换使其变成链表的最后一个元素，然后又是同样的方法将现任的第一个元素通过m-2次交换使其成为链表的倒数第二个元素，以此类推。 

      单链表的排序 
      就排序原理而言，个人觉得其实不用过多考虑存储结构的问题，即不管是顺序存储还是链式存储，都不影响排序的基本原理，只是不同的存储结构会影响不同排序方法的效率而已。因为我们完全可以夸张地将顺序存储也想象为不连续的存储只是它们相邻两者的间隙极端的小。即我们将货物分别存在美国和中国的仓库里和都存放在一个仓库里是一样的，只是运费问题而已。 
      明白了这一点，那么单链表的排序就和普通的数组排序没有什么太大的区别。我们现在要做的事就是针对性地选择一个时间性能相对较好的排序算法。 
      我们知道的排序方法有很多：插入排序、冒泡排序、快速排序、归并排序、堆排序以及基数排序等等，那么这其中哪些对顺序结构和链式结构不那么感冒呢？熟悉这些排序的童鞋肯定知道，是插入排序和冒泡排序。其他的几种常见排序方法就比较偏袒顺序存储结构了。所以，如果要对链表进行排序，我会选择插入排序或者冒泡排序。（不太清楚这些基本排序原理的click here：http://wlh0706-163-com.iteye.com/blog/1465570） 

      删除单链表中的最小元素 
      我能想到的办法就是遍历两次：第一次找到单链表中最小的元素，第二次遍历删除该元素。第一次遍历的时候需要借助两个变量，一个保存当前的最小元素的值，另一个保存当前最小值的位序。第二次遍历的时候当然就是删除第一次遍历得到的最小元素的位序上的元素了。 

      删除所有重复结点 
      这个一般得借助其他的数据结构了。基本思路应该是：遍历链表，用一个数据结构保存当前已经遍历的元素，若下一个访问的链表里的元素已经存在于已经访问的元素集合中，则删除单链表中的该元素，否则继续，直至到达链表的末尾。保存已经访问过的元素可以用数组，也可以用其他的。 

      判断一个链表是否包含另一个链表 
      这个问题其实和开篇的问题一样，只是换了一种说法而已。因此只要找到第一个相同的元素就可以了。 

      找出单链表中的倒数第K个元素 
      我们首先要确保的就是单链表的元素个数大于K。 
      这里的实现思路也很巧妙：我们定义两个指针a和b，全部指向链表的头结点，然后a指针开始向后遍历，但a遍历到第K个元素的时候，b指针也开始从头开始遍历，接下来的事你应该知道了，当a指针到达链表的末尾时，b指针恰好指着链表的倒数第K个元素。这样的时间复杂度是O(n)。 

      找出单链表中间的节点

　 用两个指针 一个指针每次跳一次 P1 = P1->NEXT
  另外一个指针 每次跳两次 P2 = p2->next->next  当P2为NULL时那个就是终点,这时P1所在的位置就是中间节点  这是相对于单向链表

给定一个单链表，只给出头指针h：

1、如何判断是否存在环？

2、如何知道环的长度？

3、如何找出环的连接点在哪里？

4、带环链表的长度是多少？

 

解法：

1、对于问题1，使用追赶的方法，设定两个指针slow、fast，从头指针开始，每次分别前进1步、2步。如存在环，则两者相遇；如不存在环，fast遇到NULL退出。

2、对于问题2，记录下问题1的碰撞点p，slow、fast从该点开始，再次碰撞所走过的操作数就是环的长度s。

3、问题3：有定理：碰撞点p到连接点的距离=头指针到连接点的距离，因此，分别从碰撞点、头指针开始走，相遇的那个点就是连接点。(证明在后面附注)

4、问题3中已经求出连接点距离头指针的长度，加上问题2中求出的环的长度，二者之和就是带环单链表的长度

void Isloop(Llink head)
{
 if(!head||!head->next)
  return;
 Llink p,q;
 bool loop=false;
 p=q=head->next;
 while(q&&q->next)//判断是否有环
 {
  p=p->next;
  q=q->next->next;
  if(p==q)
  {
   loop=true;
   break;
  }
 }
 if(!loop)
  cout<<"This link has not loop\n";
 else
 {
  cout<<"This link has a loop\n";
  Llink r=p;
  q=head->next;
  int nonloop=1,loopcount=1;

  //nonloop计算非环结点数，loopcount计算环上结点数
  do//计算环上的结点数
  {
   p=p->next;
   ++loopcount;
  }while(p!=r);
  --loopcount;
  while(p!=q)//得到环的入口结点，同时计算得到非环的结点数
  {
   p=p->next;
   q=q->next;
   ++nonloop;
  }
  --nonloop;
  cout<<"\nStart of loop: "<<p->data<<endl;  
  cout<<"\nCount of nonloop: "<<nonloop
      <<"\nCount of loop: "<<loopcount
      <<"\nCount of Linknode: "<<nonloop+loopcount<<endl;
 }
}

  

判断是否存在环的程序：

bool IsExitsLoop(slist *head)  
  1. {  
  2.     slist *slow = head, *fast = head;  
  3.     while ( fast && fast->next )   
  4.     {  
  5.         slow = slow->next;  
  6.         fast = fast->next->next;  
  7.         if ( slow == fast ) break;  
  8.     }    
  9.     return !(fast == NULL || fast->next == NULL);  
  10. }  

 

寻找环连接点（入口点）的程序：

slist* FindLoopPort(slist *head)  
  1. {  
  2.     slist *slow = head, *fast = head;    
  3.     while ( fast && fast->next )   
  4.     {  
  5.         slow = slow->next;  
  6.         fast = fast->next->next;  
  7.         if ( slow == fast ) break;  
  8.     }    
  9.     if (fast == NULL || fast->next == NULL)  
  10.         return NULL;  
  11.     slow = head;  
  12.     while (slow != fast)  
  13.     {  
  14.          slow = slow->next;  
  15.          fast = fast->next;  
  16.     }  
  17.     return slow;  
  18. } 

亦可以用类似与hash表的方法，即设立一个数组，将链表结点中的值做数组下标，当赋值冲突时就是环的接入点

  1.  bool isloop(Llink p)
    {
     if(!p||!p->next)
      return true;
     int a[MAXSIZE],n=0;
     memset(a,0,sizeof(int)*MAXSIZE);
     p=p->next;
     while(p)
     {
      if(a[p->data]==-1)//存在环时，会发生冲突
      {
       cout<<"\nLoop node: "<<p->data<<endl
        <<"\nLen of node: "<<n<<endl;
       return true;
      }
      a[p->data]=-1;
      ++n;
      p=p->next;
     }
     return false;
    }
    Llink CreatlinkLoop()
  2. //创建一个有环的链表
    {
     Llink head=new Lnode;
     //head->data=0;
     head->next=NULL;
     Lelemtype e;
     Llink q=head;
     int N=0;
     cout<<"input elems:";
     while(cin>>e)
     {
      Llink p=new Lnode;
      ++N;
      p->data=e;
      p->next=q->next;
      q->next=p;
      q=p;
     }
     cin.clear();
     cin.sync();
     srand(time(0));
     q->next=Findnode(head,rand()%N);//随机产生环的接入点
     return head;
    }
    Llink Findnode(Llink head,int n)//找出链表中的第n个结点
    {
     if(n<=0)
      return head;
     Llink p=head->next;
     for(int i=1;p&&i<n;++i)
      p=p->next;
     return p;
    }

////////////////////////////////////////////////////////

附注

问题2的证明如下：

链表形状类似数字 6 。
假设甩尾（在环外）长度为 a（结点个数），环内长度为 b 。
则总长度（也是总结点数）为 a+b 。
从头开始，0 base 编号。
将第 i 步访问的结点用 S(i) 表示。i = 0, 1 ...
当 i＜a 时，S(i)=i ；
当 i≥a 时，S(i)=a+(i-a)%b 。

分析追赶过程:
两个指针分别前进，假定经过 x 步后，碰撞。则有：S(x)=S(2x)
由环的周期性有：2x=tb+x 。得到 x=tb 。
另，碰撞时，必须在环内，不可能在甩尾段，有 x>=a 。

连接点为从起点走 a 步，即 S(a)。
S(a) = S(tb+a) = S(x+a)。
得到结论：从碰撞点 x 前进 a 步即为连接点。

根据假设易知 S(a-1) 在甩尾段，S(a) 在环上，而 S(x+a) 必然在环上。所以可以发生碰撞。
而，同为前进 a 步，同为连接点，所以必然发生碰撞。

综上，从 x 点和从起点同步前进，第一个碰撞点就是连接点。

/////////////////////////////////////////////////////////////

假设单链表的总长度为L，头结点到环入口的距离为a，环入口到快慢指针相遇的结点距离为x，环的长度为r，慢指针总共走了s步，则快指针走了2s步。另外，快指针要追上慢指针的话快指针至少要在环里面转了一圈多(假设转了n圈加x的距离)，得到以下关系：
    s = a + x;
    2s = a + nr + x;
    =>a + x = nr;
    =>a = nr - x;
    由上式可知：若在头结点和相遇结点分别设一指针，同步(单步)前进，则最后一定相遇在环入口结点，搞掂！
附图：

带环的链表
posted @ 2015-09-27 18:16  —腾飞  阅读(216)  评论(0)    收藏  举报