找出链表的中间元素 与 链表排序

Q2 找出链表的中间元素

1 ListNode* find_midlist(ListNode* head)

2 {

3 ListNode *p1, *p2;

4

5 if (head == NULL || head->next == NULL)

6 {

7 return head;

8 }

9 p1 = p2 = head;

10 while (1)

11 {

12 if (p2->next != NULL && p2->next->next != NULL)

13 {

14 p2 = p2->next->next;

15 p1 = p1->next;

16 }

17 else

18 {

19 break;

20 }

21 }

22 return p1;

23 }

思路分析：

单链表的一个比较大的特点用一句广告语来说就是“不走回头路”，不能实现随机存取（random
access）。如果我们想要找一个数组a的中间元素，直接a[len/2]就可以了，但是链表不行，因为只有a[len/2 - 1] 知道a[len/2]在哪儿，其他人不知道。因此，如果按照数组的做法依样画葫芦，要找到链表的中点，我们需要做两步（1）知道链表有多长（2）从头结点开始顺序遍历到链表长度的一半的位置。这就需要1.5n（n为链表的长度）的时间复杂度了。有没有更好的办法呢？有的。想法很简单：两个人赛跑，如果A的速度是B的两倍的话，当A到终点的时候，B应该刚到中点。这只需要遍历一遍链表就行了，还不用计算链表的长度。

上面的代码就体现了这个想法。

Q3 链表排序

1 double cmp(ListNode *p ,ListNode *q)

2 {return (p->keyVal - q->keyVal);}

3

4 ListNode* mergeSortList(ListNode *head)

5 {

6 ListNode *p, *q, *tail, *e;

7 int nstep = 1;

8 int nmerges = 0;

9 int i;

10 int psize, qsize;

11 if (head == NULL || head->next == NULL)

12 {return head;}

13 while (1)

14 { p = head;

15 tail = NULL;

16 nmerges = 0;

17 while (p)

18 { nmerges++; q = p; psize = 0;

19 for (i = 0; i < nstep; i++)
{

20 psize++;

21 q = q->next;

22 if (q == NULL)break;

23 }

24 qsize = nstep;

25 while (psize >0 || (qsize >0 && q))

26 {

27 if (psize == 0)
{
e = q; q = q->next; qsize--;
}

28 else
if (q == NULL || qsize == 0)
{
e = p; p = p->next; psize--;
}

29 else
if (cmp(p,q) <= 0)
{
e = p; p = p->next; psize--;
}

30 else
{
e = q; q = q->next; qsize--;
}

31 if (tail != NULL)
{
tail->next = e;
}

32 else{head = e;}

33 tail = e;

34 }

35 p = q;

36 }

37 tail->next = NULL;

38 if (nmerges <= 1){return head;}

39 else{nstep <<= 1;}

40 }

41 }

思路分析：

链表排序最好使用归并排序算法。堆排序、快速排序这些在数组排序时性能非常好的算法，在链表只能“顺序访问”的魔咒下无法施展能力；但是归并排序却如鱼得水，非但保持了它O(nlogn)的时间复杂度，而且它在数组排序中广受诟病的空间复杂度在链表排序中也从O(n)降到了O(1)。真是好得不得了啊，哈哈。以上程序是递推法的程序，另外值得一说的是看看那个时间复杂度，是不是有点眼熟？对！这就是分治法的时间复杂度，归并排序又是divide
and conquer。