链表面试笔试题目总结

链表是最基本的数据结构,凡是学计算机的必须的掌握的,在面试的时候经常被问到,关于链表的实现,百度一下就知道了。在此可以讨论一下与链表相关的练习题。


1在单链表上插入一个元素,要求时间复杂度为O(1)

解答:一般情况在链表中插入一元素是在末尾插入的,这样需要从头遍历一次链表,找到末尾,时间为O(n)。要在O(1)时间插入一个新节点,可以考虑每次在头节点后面插入,即每次插入的节点成为链表的第一个节点。


2、给定一个链表,判断是否有环。

解答:这个是一个经典的问题了,思路也很简单,我们首先设置两个指针p1,p2同时指向链表的头部,然后p1每次向后走1步,p2每次向后走2步。如果有环,那么有一步会出现p1=p2,如果p2已经到达了尾结点,则无环。复杂度:时间:O(n),空间:O(1)

扩展:给定一个链表,找出环的入口位置。思路也是一样,用p1,p2指针。只是需要多做一步,那就是当p1=p2的时候,将p1重新指向链表的头结点,然后p1和p2都每次向后走一步,下一次p1=p2的结点就是环的入口。复杂度:时间:O(n),空间:O(1)


3遍历单链表一次,找出链表中间节点

解答:定义两个指针p和q,初始都指向链表头节点。然后开始向后遍历,p每次移动2步,q移动一步,当p到达末尾的时候,p正好到达了中间位置。


4、单链表逆置,不允许额外分配存储空间,不允许递归,可以使用临时变量,执行时间为O(n)

解答:这个题目在面试笔试中经常碰到,基本思想上将指针逆置。如下图所示:

链表面试笔试题目总结_第1张图片

实现:

Node* reverse_list(Node *head){
  Node *cur=head;
  Node *pre = NULL;
  Node *post = cur->next;
//    Node *reverse_head = cur;
  while(post){
      cur->next = pre;
      pre = cur;
      cur = post;
        post = post->next;
  }
  cur->next = pre;
//    reverse_head = cur;
  return cur;
}


扩展:链表翻转。给出一个链表和一个数k,比如,链表为1→2→3→4→5→6k=2,则翻转后2→1→6→5→4→3,若k=3,翻转后3→2→1→6→5→4,若k=4,翻转后4→3→2→1→6→5,用程序实现。

实质是也是逆置,只不过是两个链表逆置后再串联起来。实现如下:

bool rotate_list(Node *head,int k,Node* &newhead){
	if(k < 0)
		return false;
	else if(0 == k)
		return true;
	int len = 0;
	Node *node=head;
	while(node){
		++len;
		node = node->next;
	}
	if(k > len)
		return false;
	Node *one_end,*two_start;
	node = head;
	Node *post = node->next;
	int n=k;
	if(1 == n){
	}else{
		while(n > 1){// rotate sublist one
			node->next = post->next;
			post->next = head;
			head = post;
			post = node->next;
			--n;
		}
	}

	if(len-k <= 1){ // rotate sublist two
	}else{
        one_end = node;
        node = post;
        post = post->next;
        two_start = node;
        n = len-k;
        while(n>1){
            one_end->next = post;
            node->next = post->next;
            post->next = two_start;
            two_start = post;
            post = node->next;
            --n;
        }
	}
    newhead = head;
	return true;
}

5、用一个单链表L实现一个栈,要求pushpop的操作时间为O(1)

解答:根据栈中元素先进后出的特点,可以在链表的头部进行插入和删除操作


6、用一个单链表L实现一个队列,要求enqueuedequeue的操作时间为O(1)

解答:队列中的元素是先进先出,在单链表结构中增加一个尾指针,数据从尾部入队,从头

部入队。


7、给定两个链表(无环),判断是否有相交。

解答:首先明确一点,如果两个链表相交,那么从第一个交点开始到尾结点结束,所有的结点都是公共结点。所以,两个有公共结点而部分重合的链表,拓扑形状看起来像一个Y,而不可能像X。

这也就是说,如果两个链表相交,那么这两个链表的尾结点肯定是公共结点,如果尾结点不是公共结点,那么这两个链表肯定不相交。

所以我们可以如下操作:依次遍历两个链表,最后判断尾结点是否相同,如果相同,则相交,如果不相同,则不相交。复杂度:时间:O(m+n),空间:O(1)

或者一个链表的头结点指向另一个链表的尾节点,判断是否有环。


8、给定两个链表(无环),找到第一个公共节点。

解答:我们最容易想到的是从尾结点开始挨个向前比较,最后一个相同的就是第一个公共结点。(从后往前遍历)

但是单链表只能从前往后进行遍历,如果想要从后往前的话则需要先从前向后遍历一次,同时用来记录每一个结点,最后出栈,然后挨个对比,这样的确可行,但是却要额外付出O(m+n)的空间,时间复杂度O(mn)。(单链表+栈)

仔细想想,我们可以先分别遍历两个单链表,记录长度m和n(无妨假设m>n),然后先让长度为m的链表向后走(m-n)步,接着两个链表同时向后遍历,第一个相同的结点就是要求的第一个公共结点。复杂度:O(m+n)m,n分别为两个链表的长度;空间:O(1)

PS:另外还有一种巧妙的方法是把在一个链表尾部插入另一个链表,然后判断合成的新链表是否有环。环入口即为第一个公共点

可参考:http://blog.csdn.net/wcyoot/article/details/6426436


扩展:两个链表,找出他们的第一个交点,要求每个链表只能遍历一次,可以对链表进行任何操作,空间O(1).

题目告诉说可以对链表进行任何操作,这是一个没有用到的条件(大家一定要注意到题目中没有用到的条件,往往是解题的关键所在)。

1.遍历第一个链表List1,将每一个节点的next都置为NULL。

2.遍历第二个链表List2,List2的尾节点就是第一个交点。

 

9、 给定2个链表,求这2个链表的并集(链表)和交集(链表)。不要求并集(链表)和交集(链表)中的元素有序。输入:List1:10->15->4->20List2:8->4->2->10输出:交集(链表)4->10并集(链表)2->8->20->4->15->10

法一:简单直观的方法:

InterSection(list1,list2):初始化结果链表为空,遍历链表1,在链表2中查找它的每一元素,如果链表2中也有这个元素,则将该元素插入到结果链表中

     Union(list1,list2): 初始化结果链表为空,将链表1中的所有元素都插入到结果链表中。遍历链表2,如果结果链表中没有该元素,则插入,否则跳过该元素。

法二:可适应归并排序,not clear。

法三:Hash法

Union(list1,list2),首先用链表1初始化结果链表,创建一个空的hash表。遍历链表1,将链表中的元素插入到hash表。然后遍历list2,对于list2中的元素,如果hash表中不存在该元素,则同时将该元素插入到结果链表中,如果hash表中已经存在,则忽略该元素,继续遍历下一个元素。

InterSection(list1,list2),首先初始化结果链表为NULL,创建一个空的hash表。遍历list1,将list1中的每一个元素都插入到hash表中。然后遍历list2,对于list2中的元素,如果已经存在于hash表中,则将该元素插入到结果链表,如果不存在与hash表中,则忽略该元素,继续遍历下一个元素。

参考:http://blog.csdn.net/lalor/article/details/7430631


10、从单链表返回倒数第n个元素

普通,基本思路就是用栈,一一压栈,再弹栈,第n个元素就可出来。

进阶,看到栈,就应该想到递归,递归是天然的栈。用全局变量,实现如下:

Node* pn_elem = NULL;
int nn;
void recursive(Node* node){
  if(!node)   return ;
  recursive(node->next);
  if(1==nn)   pn_elem =  node;
  --nn;
}

高级,维护两个指针,两个指针相差n个元素,当前面的指针到达链表末尾,后面指针所指的元素即是所求的元素。实现如下

Node* last_n_elem(Node*node,int n){
  if(node! || n<1)    returnNULL;
  Node *p=node,*q=node;
  while(n>0 && q){
      q=q->next;
      --n;
  }
  while(q){
      q=q->next;
      p=p->next;
  }
  return p;
}


11、链表元素去重,从未排序的链表中移除重复的项。

思路:可使用额外的空间的话,可以用数组存数字,实现最好的方式就是哈希表啦。遍历一下即可。

实现:

std::maphash;
void duplicate_remove(Node *node){
  if(!node)   return ;
  Node *post=node->next;
  hash[node->data] = true;
  while(post){
      if(hash[post->data]){
          Node *temp = post;
          post = post->next;
          node->next = post;
          delete temp;
      }else{
          hash[post->data] = true;
          node = post;
          post = post->next;
      }
  }
}

如果不允许使用临时缓存,怎么解决?

思路:用两个指针。当某个指针指向某个元素时,另一个指针将后面的相同元素全部删除。复杂度O(n^2)。具体实现就不写了。


12链表求和问题。

该问题基本上有两个类型:

a、1->2->5->4 , 2->5->3->4,得3->7->8->8.

思路:先加高位,再加低位。两个0~9的数相加,要么不进位,要么进位为1.用两个指针,p指向当前进位点,q指向当前操作点。当然第一个元素得特殊考虑,可能进位嘛。

自己实现:

Node* merge_list_add(Node *list1,Node *list2){
    Node*q1=list1,*q2=list2,*ans=NULL,*pre=NULL,*p=NULL,*q=NULL;
    int cvalue = q1->data+ q2->data;
    bool flag = false;
    ans = new Node();
    // node 1
    if(cvalue >9){ //进位
        pre = new Node();
        pre->data =cvalue%10;
        ans->next = pre;
        ans->data = 1;
        p=pre;
    }else if(9 ==  cvalue){//最高位为9
        flag = true;
        ans->data =cvalue;
        pre= ans;
        p=pre;
    }else{
        ans->data =cvalue;
        p = pre= ans;
    }
    q1=q1->next;q2=q2->next;
    while(q1 && q2){// the following node
        q = new Node();
        pre->next = q;
        cvalue = q1->data+ q2->data;
        q->data =cvalue%10;
        if(cvalue > 9 ){
            if(flag){
                if(p != ans){
                    p->data += 1;
                }else{//999...[],前面全是9
                    Node*temp = new Node();
                    temp->data= 1;
                    temp->next= ans;
                    flag =false;
                    ans =temp;
                    p = ans;
                }
            }else{
                p->data +=1;
            }
            for(p=p->next;p!=q;p=p->next){
                p->data =0;
            }
        }else if(cvalue <9){
            p = q;
        }
        pre = q;
        q1=q1->next;q2=q2->next;
    }
    return ans;
}

参考:http://hawstein.com/posts/add-singly-linked-list.html,第二种实现不错


b、 元素个数不一定相同,高位在后,个位在链表头结点。1->2->3 , 4->5->3->4,得5->7->6->4.

思路:需要注意的是,链表为空,有进位,链表长度不一样。

#include 
#include 
using namespace std;
struct Node{
    int data;
    Node *next;
};
Node* create_list(int arr[],int len){
    assert(arr &&len>0);
    Node *head =  new Node();
    head->data = arr[0];
    Node *cur=NULL;
    Node *pre=head;
    for(int i=1;idata =arr[i];
        pre->next = cur;
        pre = cur;
    }
    cur->next = NULL;
    return head;
}
Node* merge_list_add(Node *list1,Node *list2){
    if(NULL == list1) returnlist2;
    if(NULL == list2) returnlist1;
    Node *ans=NULL,*pre=NULL;
    int c=0;//进位
    int value = 0;
    while(list1 &&list2){
        value =list1->data +list2->data + c;
        Node* temp = newNode();
        temp->data =value%10;
        c = value/10;
        if(pre){
            pre->next =temp;
            pre = temp;
        }else
            ans=pre=temp;
        list2 = list2->next;
        list1 =list1->next;
    }  
    if(!list1 &&!list2 && c>0){//两个链表长度一样,但有进位
        Node* temp = newNode();
        temp->data = 1;
        temp->next =NULL;//结束
        pre->next = temp;
    }
    //有一个链表更长
    while(list1){
        value =list1->data + c;
        Node* temp = newNode();
        temp->data =value%10;
        c = value/10;
        pre->next = temp;
        pre = temp;
        list1 =list1->next;   
    }
    while(list2){
        value =list2->data + c;
        Node* temp = newNode();
        temp->data =value%10;
        c = value/10;
        pre->next = temp;
        pre = temp;
        list2 =list2->next;   
    }
    pre->next = NULL;
    return ans;
}
int main(){
    int a[]={1,2,7};
    int b[]={4,5,3,9,3};
    //此处应该加个判断,保证数组元素均在[0,9]
    Node* lista =create_list(a,3);
    Node* listb =create_list(b,5);
    Node* cur = lista;
    cout<<"list a:";
    while(cur != NULL){
        cout<data<<"";
        cur = cur->next;
    }
    cur = listb;
    cout<data<<"";
        cur = cur->next;
    }
    cout<next)
       cout<data<<" ";
    cout<


13用算法实现删除链表的一个中间节点,所知的只有该节点的指针。如a-b-c-d-e中只知道c的指针,实现a-b-d-e

思路:若直接删除的话,链表就断了,可是无法得到节点c的前驱b。故可转换思路利用c的后继d。将d的值赋给c, 然后将后继节点d删除,也就实现删除操作。

由于c的位置不定,得分情况讨论。一、c为普通的中间节点,用上述方式解决。二,c为头节点,用上述方式解决。三、c为尾节点,一般认为删除即可,但是会出现问题。删除之后,尾节点的前驱不为空,下次遍历就会出错,特别注意。四、c为空节点,直接返回。

实现:

bool remove_elem(Node* node){
  if(!node || !node->next)    returnfalse;
  Node *post = node->next;
  node->data = post->data;
  node->next = post->next;
  delete post;
  return true;
}

扩展:

a、Google题目,给定单向链表的头指针和一个结点指针,定义一个函数在O(1)时间删除该结点

思路跟前面的一致,同样要注意尾节点。

 

b、只给定单链表中某个结点p(非空结点),在p前面插入一个结点。

思路:首先分配一个结点q,将q插入在p后,接下来将p中的数据copy入q中,
然后再将要插入的数据记录在p中。


14环链表开始节点,1->2->5->4->2

思路:

1、        用快慢指针,满指针1,快指针2。

我们注意到第一次相遇时,指针走过的路程S1 = 非环部分长度 + 弧A长

快指针走过的路程S2 = 非环部分长度 + n * 环长 + 弧A长

S1 * 2 = S2,可得 非环部分长度 = n * 环长 - 弧A长

让指针1到起始点后,走过一个非环部分长度,指针2过了相等的长度。

就是n * 环长 - 弧A长,正好回到环的开头。

或者参考:http://blog.csdn.net/lalor/article/details/7628332

 2、     更简单直观的方法就是利用哈希表。无环的话,每个地址就是不一样;有环的话,两个地址一样的就是环开始节点。下面用c++的map实现

std::maphash;

Node* loop_start(Node* node){

  while(node){

      if(hash(node)) 

          return node;

      else{

          hash(node) = true;

          node = node->next;

      }

  }

  return NULL; //return head ;  same

}

15如何知道环的长度

 

一、在环上相遇后,记录第一次相遇点为pos,之后指针slow继续每次走1步,fast每次走2步。在下次相遇的时候fastslow正好又多走了一圈,也就是多走的距离等于环长

  设从第一次相遇到第二次相遇,设slow走了len步,则fast走了2*len步,相遇时多走了一圈:环长=2*len-len。

二、利用哈希表,即两个碰撞元素间的个数


16输入一个链表的头结点,从尾到头反过来打印出每个结点的值。

思路:用栈实现。

进阶:用递归。实现如下:

void PrintListReversingly(ListNode*pHead){
      if(pHead != NULL){
           if(pHead->m_pNext != NULL){
                 PrintListReversingly(pHead->m_pNext);
           }
       printf("%d\t",pHead->m_nValue);
      }
}

注意:但使用递归就意味着可能发生栈溢出的风险,尤其是链表非常长的时候。所以,基于循环实现的栈的鲁棒性要好一些。


17输入两个递增链表,合并为一个递增链表。

思路:遍历两个链表,依次比较,形成新的队列

进阶:递归,每次递归返回合并后新链表的头结点

list_node*List::recursive_merge(list_node * a,list_node * b){
        if(a == NULL)return b;
        if(b == NULL)return a;
        if(a->value <= b->value){
                a->next=recursive_merge(a->next,b);
                return a;
        }
        if(a->value > b->value){
               b->next=recursive_merge(a,b->next);
                return b;
        }
}

18用链表实现约瑟夫环

这里就不实现了。

 

19、判断一条单向链表是不是回文1-2-4-2-1

思路:对于单链表结构,可以用两个指针从两端或者中间遍历并判断对应字符是否相等。但这里的关键就是如何朝两个方向遍历。

由于单链表是单向的,所以要向两 个方向遍历的话,可以采取经典的快慢指针的方法,即定位到链表的中间位置,再将链表的后半逆置,最后用两个指针同时从链表头部和中间开始同时遍历并比较即可。

实现:(注意链表元素的奇偶性,稍微不同)

bool is_list_plalindrome(Node*head){
  if(!head)
      return false;
  Node *one=head,*two=head,*pre=NULL;
  while(two!=NULL && two->next!=NULL){
      pre=one;
      one = one->next;
      two = two->next->next;
  }
  //if length of list is odd, mid
  Node *subhead=NULL,*node=NULL,*post=NULL;
  if(!two){ //even,two==NULL
      subhead = one;
  }else{ //odd
      subhead=one->next;
  }
    node=subhead;
    post=node->next;
    while(node->next){// rotate sublist (旋转的这种写法,很容易理解)
        node->next = post->next;
        post->next = subhead;
        subhead = post;
        post = node->next;
    }
    for(Node*p=head,*q=subhead;p!=pre->next;p=p->next,q=q->next){
        if(p->data!=q->data)
            return false;
    }
    return true;
}



20、从尾到头输出链表。

题目:输入一个链表的头结点,从尾到头反过来输出每个结点的值。

思路:跟输出倒数第n个元素的方法类似。

方法一、先把链表反向,然后再从头到尾遍历一遍。但该方法需要额外的操作

方法二、设一个栈,从头到尾遍历一次,把结点值压力栈中,再出栈打印。

方法三、递归。

实现:

void list_out_reverse(Node*head){
  if(!head)
      return;
  else
      list_out_reverse(head->next);
  cout<data<<" ";
}


扩展:该题还有两个常见的变体:

1. 从尾到头输出一个字符串;

2. 定义一个函数求字符串的长度,要求该函数体内不能声明任何变量。

两个的分别实现:

void reverseString(conststring& s,unsigned int begin){
  if(!s.size())
      return;
  if(begin>=s.size())
      return;
  reverseString(s,begin+1);
  cout<

int getLength(const char *s){
  if(*s=='/0')
      return 0;
  return getLength(s+1) + 1;
}
 

21、链表和数组的区别?

分析:主要在基本概念上的理解。但是最好能考虑的全面一点,现在公司招人的竞争可能就在细节上产生,谁比较仔细,谁获胜的机会就大。

数组无需初始化,因为数组的元素在内存的栈区,系统自动申请空间。而链表的结点元素在内存的堆区,每个元素须手动申请空间,如malloc。也就是说数组是静态分配内存,而链表是动态分配内存。链表如此麻烦为何还要用链表呢?数组不能完全代替链表吗?回到这个问题只需想想我们当初是怎么完成学生信息管理系统的。为何那时候要用链表?因为学生管理系统中的插入,删除等操作都很灵活,而数组则大小固定,也无法灵活高效的插入,删除。

数组是线性结构,静态分配内存,在内存中连续,数组元素在栈区。可以直接索引,时间复杂度O(1)。数组插入或删除元素比较困难,时间复杂度O(n)

链表也是线性结构,动态分配内存,在内存中不连续,链表元素在堆区。元素的定位均需遍历,时间复杂度O(n)。链表插入或删除元素操作灵活性强,时间复杂度O(1)

 

 

22、编写实现链表排序的一种算法。说明为什么你会选择用这样的方法?

思路:如果只是数据内容之间的相互交换,那么这种排序方法也比较适合链表的排序,插入、冒泡、希尔和选择排序。快速排序、合并排序、堆排序都涉及到了中间值的选取问题,所以不大适合链表排序。

选择排序的实现:

Node* insert_sort(Node *head){
    if(!head ||!head->next)
        return head;
    Node *p,*q,*pre,*temp;
    p=head->next;
    head->next=NULL;
    //   p is the head of unsorted list
    //   head is the head of sorted list
    while(p){
        q=head;
        while(q &&(q->data < p->data)){
            pre=q;
            q=q->next;
        }
        temp = p->next;
        if(q==head){
            p->next = q;
            head = p;
        }else{
            pre->next=p;
            p->next = q;
        }
        p=temp;
    }
    return head;
}

其他排序参考:http://blog.csdn.net/hackbuteer1/article/details/6666475

http://wenku.baidu.com/link?url=CxhR7E5PGrEwRU5eKu_3xX5EvZ6MP-7GhRLhAfoQFThh5HxlQ5SgIxdfRPVXRO-oeCkwFYFqLJJezeswxdOmRE4W_QJBY3iS4Xpot23XCPi


23、复杂链表的复制(默认无环)

Q:有一个复杂链表,其结点除了有一个m_pNext指针指向下一个结点外,还有一个m_pSibling指向链表中的任一结点或者NULL。请完成函数ComplexNode* Clone(ComplexNode* pHead),以复制一个复杂链表。

一开始想这道题毫无思路,如果蛮来,首先创建好正常的链表,然后考虑sibling这个分量,则需要O(n^2)的时间复杂度。

思路一: 一般复制一个简单链表就这么遍历一遍就好了,这个复杂链表,比简单链表多的地方就在于多了一个sibling的指针,也就是说在建立完简单链表之后,如何在新的链表中找到sibling对应的地址。我们已知的是旧的节点的地址,所以只需要用一个map,保存每一个节点旧的节点对应的新的节点的地址即可。(即将原链表中的结点N和相应复制结点N'建立哈希映射

第一次遍历,建立简单节点,第二次遍历,对于旧链表中的每一个节点的sibling指针地址,从map中找到新链表中对应节点的地址,连接上就好了。

实现:(不错的实现,学习

ComplexNode* Clone(ComplexNode*pHead){
    if(pHead == NULL)  return NULL;
     mappointMap;
     ComplexNode* newHead,*tail; // newHead指向复制的新链表的开头,tail始终指向结尾
     // 开辟一个头结点
     newHead = new ComplexNode;
     newHead->value = pHead->value;
     newHead->pNext = NULL;
     newHead->pSibling = NULL;
     pointMap[pHead] = newHead; // 将头结点放入map中
 
     tail = newHead;
     ComplexNode *p = pHead->pNext;
     while(p != NULL){ // 第一遍先将简单链表复制一下
        ComplexNode* newNode = new ComplexNode;
        newNode->value = p->value;
        newNode->pNext = NULL;
        newNode->pSibling = NULL;
 
        tail->pNext = newNode;
        tail = newNode;
        pointMap[p] = newNode;
         p = p->pNext;
     }
     // 根据map中保存的数据,找到对应的节点
     p = pHead;
     tail = newHead;
     while(p!=NULL){
         if(p->pSibling!=NULL){
             tail->pSibling =pointMap.find(p->pSibling)->second;//Key,找N对应的N’
         }
         p = p->pNext;
         tail = tail->pNext;
     }
    return newHead;
 }

 

思路二:(精妙)一个技巧便可以巧妙的解答此题。看图便知。

首先是原始的链表

链表面试笔试题目总结_第2张图片

然后我们还是首先复制每一个结点N为N*,不同的是我们将N*让在对应的N后面,即为

链表面试笔试题目总结_第3张图片

然后我们要确定每一个N*的sibling分量,非常明显,N的sibling分量的next就是N*的sibling分量。

最后,将整个链表拆分成原始链表和拷贝出的链表。

这样,我们就解决了一个看似非常混乱和复杂的问题。

实现:

struct Node{
    int val;
    Node* next;
    Node*sibling;
};
void Clone(Node* head){
    Node*current=head;
    while(current){
        Node*temp=new Node;
        temp->val=current->val;
        temp->next=current->next;
        temp->sibling=NULL;
        current->next=temp;
        current=temp->next;
    }
}
void ConstructSibling(Node*head){
    Node*origin=head;
    Node*clone;
    while(origin){
        clone=origin->next;
        if(origin->sibling)
            clone->sibling=origin->sibling->next;
        origin=clone->next;
    }
}
 
Node* Split(Node* head){
    Node*CloneHead,*clone,*origin;
    origin=head;
    if(origin){
        CloneHead=origin->next;
        origin->next=CloneHead->next;
        origin=CloneHead->next;
        clone=CloneHead;
    }
    while(origin){
        Node*temp=origin->next;
        origin->next=temp->next;
        origin=origin->next;
        clone->next=temp;
        clone=temp;
    }
    return CloneHead;
}
//the whole thing
Clone(head);
ConstructSibling(head);
Split(head);

 

参考:http://www.cnblogs.com/daniagger/archive/2012/06/19/2555321.html

http://www.cnblogs.com/cyttina/archive/2012/10/28/2743290.html

 

大家如果还发现其他不错的题目,欢迎补充


你可能感兴趣的:(数据结构)