关联列表插入排序的时间和空间复杂度的分析

吴欣
151 阅读5分钟

在这篇文章中，我们探讨了关联列表插入排序的时间和空间复杂度分析。

内容表

  1. 链表插入式排序算法概述
  2. 插入式排序的最坏情况下的时间复杂度分析
  3. 插入排序的最佳情况下的时间复杂度分析
  4. 插入式排序的平均情况下的时间复杂度分析
  5. 插入式排序的空间复杂度分析
  6. 总结

以下是这个分析的要点：

| 时间和空间复杂度--
关联列表的插入式排序

| | --- | | 案例 | # 比较 | # 移位 | 空间 | 时间 | | 平均数 | N*(N-1)/4 | N*(N-1)/4 | O(1) | O(N2) | | 最差 | N*(N-1)/2 | N*(N-1)/2 | O(1) | O(N2) | | 最好的 | N | 0 | O(1) | O(N) |

链表插入式排序算法概述

插入排序是一种基于比较的排序算法。

链表插入排序算法的关键思想是将一个节点/元素插入已排序的链表中。

当元素几乎被排序时，这种方法更适合使用。插入排序从一个元素开始，然后一个一个地迭代加入连续的元素，并在不干扰排序顺序的情况下将它们插入到排序列表中。

通过一个例子来学习

Input list:
[5]->[-1]->[0]->[4]->[2]

Output:
[-1]->[0]->[2]->[4]->[5]

取一个新的列表（让新列表的名字为S），它将是我们的排序列表和给定的未排序列表的输入:

Input list:
[5]->[-1]->[0]->[4]->[2]

S:

现在，让我们开始做比较，如果S列表是空的，那么就把输入列表的第一个节点插入S中:

Input list:
[-1]->[0]->[4]->[2]

S:
[5]

现在，将 "输入列表 "的第一个节点值与 "S "中的节点值进行比较，并根据排序顺序将该值放入S中。像这样:

Input list:
[0]->[4]->[2]

S:
[-1]->[5]

同样地，经过一些迭代后，输入列表将是空的，而S将拥有初始输入列表的所有元素。

因此，列表会看起来像:

Input list:

S:
[-1]->[0]->[2]->[4]->[5]

链接列表的插入排序代码如下:

//Insertion Sort
   begin insertion_sort ( root_node )   //root_node is pointing at input list
       S = NULL    //initializing sorted linked list and assigning Null
       while ( root_node )
       {
       x = root_node->next   //intializing x new node and assigning root-node's next node in it
       temp = S    //initializing temp new node and assigning it S
       
       while ( temp->next && temp->next->value < root_node->value)   //checking conditions
       { 
       temp = temp->next   //updating temp to temp's next
       }
       root_node->next = temp->next
       temp->next = root_node
       root_node = x
       }
       return S
   end insertion_sort

在这里，我们应用了将输入列表中的元素放到新的排序节点 "S "中的想法，使用元素的比较和元素的移动。

链表插入式排序的时间复杂度分析

每一次传递后，排序后的列表'S'的大小增加1，未排序的输入列表的大小减少1。

第1遍：比较数：1，移位数：1
第2遍：比较数：2，移位数：2
第3遍：比较数：3，移位数：3
以此类推，直到

第n遍：比较数：n，移位数：n。
因此，比较总数：(n*(n-1))/2 ，移位总数：(n*(n-1))/2

函数的时间复杂度取决于比较数+移位数。

因此，链表插入排序的时间复杂性是O(n^2)。

插入式排序的最坏情况下的时间复杂度分析

最坏的情况是指这样的情况:

假设我们需要将列表按升序排列，鉴于输入的列表是递减的，那么在排序后的列表'S'中，每个元素都会有最大的移位次数。例如，如果输入的列表是8、6、5、4、2，那么。

Pass 1: 比较次数: 1, 移位次数: 1,
S: 8, input_list:6, 5, 4, 2
通过2：比较数：2，移位数：2，
S：8, 6，输入列表。5, 4, 2
以此类推，直到
通过5：比较次数：5，移位次数：5，
S：8, 6, 5, 4, 2，input_list。
因此，比较次数：n*(n-1)/2，移位次数：n*(n-1)/2。
因此，最坏情况下的时间复杂性为O(n^2)。

插入式排序的最佳情况下的时间复杂度分析

最好的情况是指这样的情况:

假设我们需要找到升序，并且给定的输入列表也是升序的，那么在'S'中就会有0（零）个移位。例如，如果输入列表。2, 4, 6, 8, 10, 那么。

Pass 1: 比较次数: 1, 移位次数: 0,
S: 2, input_list:4, 6, 8, 10
通过2：比较数：1，移位数：0，
S：2，4，输入列表。6，8，10，
以此类推，直到
通过5：比较次数：1，移位次数：0，
S：2，4，6，8，10，input_list。

因此，有零个移位和总共n个比较。
因此，最佳情况下的时间复杂性是O(n)。

插入式排序的平均案例时间复杂度分析

基于最坏情况和最好情况，每个元素的平均比较次数将是最坏情况的一半，同样，平均移位次数也是最坏情况的一半。

Pass 1：比较次数：1，移位次数：1；
Pass 2：比较次数：2/2，移位次数：2/2；
Pass 3：比较次数：3/2，移位次数：3/2，
以此类推，直到
Pass n：比较次数：n/2，移位次数：n/2。
因此，有n*(n-1)/4次比较和移位。
因此，平均情况下的时间复杂性为O(n^2)。

插入式排序的空间复杂度分析

链表插入排序的空间复杂度是恒定的，这是因为我们只为2个列表和函数中的一些新节点使用了恒定的额外空间来执行节点的比较和移动。

因此，链表插入排序的空间复杂度是O(1)。

总结

长话短说:

  • 链表插入排序的最坏情况下的时间复杂度是O(n^2)。
  • 链表插入排序的平均情况下的时间复杂度是 O(n^2)。
  • 链表插入排序的最佳情况下的时间复杂度是 O(n)。
  • 链表插入排序的空间复杂度为 O(1)。

| 时间和空间复杂度
在链接列表上
的插入式排序

| | --- | | 案例 | # 比较 | # 移位 | 空间 | 时间 | | 平均数 | N*(N-1)/4 | N*(N-1)/4 | O(1) | O(N2) | | 最差 | N*(N-1)/2 | N*(N-1)/2 | O(1) | O(N2) | | 最好的 | N | 0 | O(1) | O(N) |

通过OpenGenus的这篇文章，你一定对关联列表插入排序的时间和空间复杂度有了深刻的认识。

avatar
文章
阅读
粉丝