链表排序(冒泡、选择、插入、快排、归并、希尔、堆排序)

原文 :http://www.cnblogs.com/TenosDoIt/p/3666585.html


这篇文章分析一下链表的各种排序方法。

 

以下排序算法的正确性都可以在LeetCode的链表排序这一题检测。本文用到的链表结构如下(排序算法都是传入链表头指针作为参数,返回排序后的头指针)

struct ListNode {

  int val;

  ListNode *next;

  ListNode(int x) : val(x), next(NULL) {}

  };

 

插入排序(算法中是直接交换节点,时间复杂度O(n^2),空间复杂度O(1)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
public :
     ListNode *insertionSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         if (head == NULL || head->next == NULL) return head;
         ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;
         pstart->next = head; //为了操作方便,添加一个头结点
         while (p != NULL)
         {
             ListNode *tmp = pstart->next, *pre = pstart;
             while (tmp != p && p->val >= tmp->val) //找到插入位置
                 {tmp = tmp->next; pre = pre->next;}
             if (tmp == p)pend = p;
             else
             {
                 pend->next = p->next;
                 p->next = tmp;
                 pre->next = p;
             }
             p = pend->next;
         }
         head = pstart->next;
         delete pstart;
         return head;
     }
};

选择排序(算法中只是交换节点的val值,时间复杂度O(n^2),空间复杂度O(1)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
public :
     ListNode *selectSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //选择排序
         if (head == NULL || head->next == NULL) return head;
         ListNode *pstart = new ListNode(0);
         pstart->next = head; //为了操作方便,添加一个头结点
         ListNode*sortedTail = pstart; //指向已排好序的部分的尾部
        
         while (sortedTail->next != NULL)
         {
             ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;
             //寻找未排序部分的最小节点
             while (p != NULL)
             {
                 if (p->val < minNode->val)
                     minNode = p;
                 p = p->next;
             }
             swap(minNode->val, sortedTail->next->val);
             sortedTail = sortedTail->next;
         }
        
         head = pstart->next;
         delete pstart;
         return head;
     }
};

快速排序1(算法只交换节点的val值,平均时间复杂度O(nlogn),不考虑递归栈空间的话空间复杂度是O(1))

这里的partition我们参考数组快排partition的第二种写法(选取第一个元素作为枢纽元的版本,因为链表选择最后一元素需要遍历一遍),具体可以参考here

这里我们还需要注意的一点是数组的partition两个参数分别代表数组的起始位置,两边都是闭区间,这样在排序的主函数中:

void quicksort(vector<int>&arr, int low, int high)

{

  if(low < high)

  {

   int middle = mypartition(arr, low, high);

   quicksort(arr, low, middle-1);

   quicksort(arr, middle+1, high);

  }

}

对左边子数组排序时,子数组右边界是middle-1,如果链表也按这种两边都是闭区间的话,找到分割后枢纽元middle,找到middle-1还得再次遍历数组,因此链表的partition采用前闭后开的区间(这样排序主函数也需要前闭后开区间),这样就可以避免上述问题

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Solution {
public :
     ListNode *quickSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //链表快速排序
         if (head == NULL || head->next == NULL) return head;
         qsortList(head, NULL);
         return head;
     }
     void qsortList(ListNode*head, ListNode*tail)
     {
         //链表范围是[low, high)
         if (head != tail && head->next != tail)
         {
             ListNode* mid = partitionList(head, tail);
             qsortList(head, mid);
             qsortList(mid->next, tail);
         }
     }
     ListNode* partitionList(ListNode*low, ListNode*high)
     {
         //链表范围是[low, high)
         int key = low->val;
         ListNode* loc = low;
         for (ListNode*i = low->next; i != high; i = i->next)
             if (i->val < key)
             {
                 loc = loc->next;
                 swap(i->val, loc->val);
             }
         swap(loc->val, low->val);
         return loc;
     }
};

 

快速排序2(算法交换链表节点,平均时间复杂度O(nlogn),不考虑递归栈空间的话空间复杂度是O(1))

这里的partition,我们选取第一个节点作为枢纽元,然后把小于枢纽的节点放到一个链中,把不小于枢纽的及节点放到另一个链中,最后把两条链以及枢纽连接成一条链。

这里我们需要注意的是,1.在对一条子链进行partition时,由于节点的顺序都打乱了,所以得保正重新组合成一条新链表时,要和该子链表的前后部分连接起来,因此我们的partition传入三个参数,除了子链表的范围(也是前闭后开区间),还要传入子链表头结点的前驱;2.partition后链表的头结点可能已经改变

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Solution {
public :
     ListNode *quickSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //链表快速排序
         if (head == NULL || head->next == NULL) return head;
         ListNode tmpHead(0); tmpHead.next = head;
         qsortList(&tmpHead, head, NULL);
         return tmpHead.next;
     }
     void qsortList(ListNode *headPre, ListNode*head, ListNode*tail)
     {
         //链表范围是[low, high)
         if (head != tail && head->next != tail)
         {
             ListNode* mid = partitionList(headPre, head, tail); //注意这里head可能不再指向链表头了
             qsortList(headPre, headPre->next, mid);
             qsortList(mid, mid->next, tail);
         }
     }
     ListNode* partitionList(ListNode* lowPre, ListNode* low, ListNode* high)
     {
         //链表范围是[low, high)
         int key = low->val;
         ListNode node1(0), node2(0); //比key小的链的头结点,比key大的链的头结点
         ListNode* little = &node1, *big = &node2;
         for (ListNode*i = low->next; i != high; i = i->next)
             if (i->val < key)
             {
                 little->next = i;
                 little = i;
             }
             else
             {
                 big->next = i;
                 big = i;
             }
         big->next = high; //保证子链表[low,high)和后面的部分连接
         little->next = low;
         low->next = node2.next;
         lowPre->next = node1.next; //为了保证子链表[low,high)和前面的部分连接
         return low;
     }
};

 


归并排序(算法交换链表节点,时间复杂度O(nlogn),不考虑递归栈空间的话空间复杂度是O(1))                       本文地址

首先用快慢指针的方法找到链表中间节点,然后递归的对两个子链表排序,把两个排好序的子链表合并成一条有序的链表。归并排序应该算是链表排序最佳的选择了,保证了最好和最坏时间复杂度都是nlogn,而且它在数组排序中广受诟病的空间复杂度在链表排序中也从O(n)降到了O(1)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Solution {
public :
     ListNode *mergeSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //链表归并排序
         if (head == NULL || head->next == NULL) return head;
         else
         {
             //快慢指针找到中间节点
             ListNode *fast = head,*slow = head;
             while (fast->next != NULL && fast->next->next != NULL)
             {
                 fast = fast->next->next;
                 slow = slow->next;
             }
             fast = slow;
             slow = slow->next;
             fast->next = NULL;
             fast = sortList(head); //前半段排序
             slow = sortList(slow); //后半段排序
             return merge(fast,slow);
         }
         
     }
     // merge two sorted list to one
     ListNode *merge(ListNode *head1, ListNode *head2)
     {
         if (head1 == NULL) return head2;
         if (head2 == NULL) return head1;
         ListNode *res , *p ;
         if (head1->val < head2->val)
             {res = head1; head1 = head1->next;}
         else {res = head2; head2 = head2->next;}
         p = res;
         
         while (head1 != NULL && head2 != NULL)
         {
             if (head1->val < head2->val)
             {
                 p->next = head1;
                 head1 = head1->next;
             }
             else
             {
                 p->next = head2;
                 head2 = head2->next;
             }
             p = p->next;
         }
         if (head1 != NULL)p->next = head1;
         else if (head2 != NULL)p->next = head2;
         return res;
     }
};

 


冒泡排序(算法交换链表节点val值,时间复杂度O(n^2),空间复杂度O(1))

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Solution {
public :
     ListNode *bubbleSortList(ListNode *head) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //链表快速排序
         if (head == NULL || head->next == NULL) return head;
         ListNode *p = NULL;
         bool isChange = true ;
         while (p != head->next && isChange)
         {
             ListNode *q = head;
             isChange = false ; //标志当前这一轮中又没有发生元素交换,如果没有则表示数组已经有序
             for (; q->next && q->next != p; q = q->next)
             {
                 if (q->val > q->next->val)
                 {
                     swap(q->val, q->next->val);
                     isChange = true ;
                 }
             }
             p = q;
         }
         return head;
     }
};

 


对于希尔排序,因为排序过程中经常涉及到arr[i+gap]操作,其中gap为希尔排序的当前步长,这种操作不适合链表。

对于堆排序,一般是用数组来实现二叉堆,当然可以用二叉树来实现,但是这么做太麻烦,还得花费额外的空间构建二叉树


 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值