LeetCode—Sort List解题报告

转载请注明：http://blog.csdn.net/ict2014/article/details/17416115

原题如下：

题目解析：

       题目要求是对单链表进行从小到大排序，要求的时间复杂度为O(nlogn)。

       从时间复杂度上分析此题，可以排除插入排序等O(n^2)的算法。

       剩余两种排序算法，快速排序和合并排序。这两种算法究竟使用哪一个呢？此时我们要结合题目的数据结构——单链表进行分析，看哪一个更加方便快捷。快速排序的思想是选定一个pivot点，在该点之前的都小于此点，在该点之后的都大于此点，然后前半部分和后半部分分别递归排序，繁杂的操作就是调整指针。对于合并排序而言，从中间将链表拆分成两个链表，两个链表单独进行排序，排序后的两个链表进行合并操作即可。相比较而言，个人感觉合并排序比较简单一些，拆分成两个链表的时候，从链表的中间进行切分即可，合并两个有序的单链表也是很简单的操作。

题目代码：

       我们实现合并排序，算法的时间复杂度为O(nlogn)。代码在leetcode上Accept.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        //List is empty or only one node
        if(head == NULL || head->next == NULL){
            return head;
        }
        //List size
        int size = GetSize(head);
        //Combination Sort
        return CombinationSort(head, size);
    }
    
    //Combination Sort
    ListNode* CombinationSort(ListNode* head, 
                              const int& size){
        if(size <= 1){
            return head;
        }
        
        ListNode* head2 = ForwardNSteps(head, size>>1);
        ListNode* newHead1 = CombinationSort(head, size>>1);
        ListNode* newHead2 = CombinationSort(head2,size-(size>>1));
        
        return CombineTwoList(newHead1, newHead2);
    }
    
    //Combine two sorted lists
    ListNode* CombineTwoList(ListNode* head1,
                             ListNode* head2){
        ListNode* newhead;
        ListNode* current1 = head1;
        ListNode* current2 = head2;
        
        if(head1->val < head2->val){
            newhead = head1;
            current1 = current1->next;
        }else{
            newhead = head2;
            current2 = current2->next;
        }
        
        ListNode* pre = newhead;
        while(current1 != NULL && current2 != NULL){
            if(current1->val < current2->val){
                pre->next = current1;
                pre = current1;
                current1 = current1->next;
            }else{
                pre->next = current2;
                pre = current2;
                current2 = current2->next;
            }
        }
        
        if(current1 != NULL){
            pre->next = current1;
        }
        
        if(current2 != NULL){
            pre->next = current2;
        }
        
        return newhead;
    }
    
    //move forward N steps
    ListNode* ForwardNSteps(ListNode* head,
                            const int& nsteps){
        for(int i = 1; i < nsteps; ++i){
            head = head->next;
        }
        ListNode* head2 = head->next;
        head->next = NULL;
        return head2;
    }
    
    //calculate the length of list
    int GetSize(ListNode* head){
        int length = 0;
        while(head != NULL){
            head = head->next;
            ++length;
        }
        return length;
    }
};

注意程序的第31行，左移右移运算符的优先级小于加减乘除，第一次总是wrong answer，调试之后，才发现

“size-size>>1”的结果始终为0，因此，必须用括号将size>>1括起来。这是一点需要注意的小事项。

程序总体是合并排序的思想，22-34是合并排序的核心代码段。完成拆分、合并操作。75-84完成拆分操作，36-73完成合并两个有序单链表操作。代码只是用英文进行了简单的注释，如有疑问，可以互相讨论。