算法导论-排序(一)-插入排序、归并排序

目录:                                                                                                         


     1、插入排序算法伪码

     2、插入排序c++实现

     3、归并排序算法伪码

     4、归并排序c++实现

     5、总测试程序

  此链接为MIT算法导论第一讲详细笔记,感谢Sheridan

内容:                                                                                                          


        1、插入排序算法伪码  T(n) = Θ(n2)                 

             Insertion_sort(A[],n) //数组下标从1开始

                      for j <- 2 to n

                              do key <- A[j]

                               i <- j-1

                               while i>0 and A[i]>key

                                          A[i+1] <- A[i]

                                          i <- i-1

                              A[i+1]=key

 

       2、插入排序c++实现                

 1 template<typename T>
 2 void insertion_sort(vector<T> &A)
 3 {
 4     int i,j;
 5     T key;
 6     int len=A.size();
 7     for (j=1;j<len;j++)
 8     {
 9         i=j-1;
10         key=A[j];
11         while (i>=0&&A[i]>key)
12         {
13             A[i+1]=A[i];
14             i--;
15         }
16         A[i+1]=key;
17     }
18 }
View Code    

       3、归并排序算法伪码      T(n) = Θ(nlgn)          

           1) 归并总代码

              Merge_sort(A[],p,r)

                 if  p<r

                      q=(p+r)/2 // “分”

                      Merge_sort(A[],p,q) // “治”

                      Merge_sort(A[],q+1,r) // “治”

                      Merge(A[],p,q,r) // “合”

            2)归并子代码

              Merge(A[],p,q,r)

                      len1 <- q-p+1

                      len2 <- r-q

                      for i <- 1 to len1

                            L[i] <- A[i+p]

                      for j <- 1 to len2

                            R[j] <- A[j+q+1]

                       L[len1+1]=INT_MAX

                       R[len2+1]=INT_MAX

                       i <- j <- 1

                       for k <- p to r

                            if L[i]>R[J]

                                    A[k]=R[j]

                                    j <- j+1

                            else

                                    A[k]=L[i]

                                     i <- i+1

 

       4、归并排序c++实现                

 1 template<typename T>
 2 void merge_sort(vector<T> &A,int p,int r)
 3 {
 4     if (p<r)
 5     {
 6         int mid=(p+r)/2;
 7         merge_sort(A,p,mid);
 8         merge_sort(A,mid+1,r);
 9         merge(A,p,mid,r);
10     }
11 }
View Code
 1 template<typename T>
 2 void  merge(vector<T> &A,int p,int q,int r)
 3 {
 4     int n1=q-p+1;
 5     int n2=r-q;
 6     T *L=new T[n1+1];
 7     T *R=new T[n2+1];
 8 
 9     for (int i=0;i<n1;i++)
10         L[i]=A[i+p];
11     for (int i=0;i<n2;i++)
12         R[i]=A[i+q+1];
13 
14     L[n1]=R[n2]=INT_MAX;
15 
16     int i=0,j=0;
17     for (int k=p;k<=r;k++)
18     {
19         if (L[i]>R[j])
20         {
21             A[k]=R[j];
22             j++;
23         }
24         else
25         {
26             A[k]=L[i];
27             i++;
28         }
29     }
30 
31     delete[] L;
32     delete[] R;
33 
34 }
View Code

 

       5、总测试程序                            

        Sort.h

 1 #ifndef SORT_HH
 2 #define SORT_HH
 3 template<typename T >
 4 class Sort
 5 {
 6     public:
 7         void insertion_sort(vector<T> &A);
 8         void merge_sort(vector<T> &A,int p,int r);
 9         void print_element(vector<T> A);
10     private:
11         void merge(vector<T> &A,int p,int q,int r);
12 };
13 template<typename T>
14 void Sort<T>::insertion_sort(vector<T> &A)
15 {
16     int i,j;
17     T key;
18     int len=A.size();
19     for (j=1;j<len;j++)
20     {
21         i=j-1;
22         key=A[j];
23         while (i>=0&&A[i]>key)
24         {
25             A[i+1]=A[i];
26             i--;
27         }
28         A[i+1]=key;
29     }
30 }
31 
32 template<typename T>
33 void Sort<T>::merge(vector<T> &A,int p,int q,int r)
34 {
35     int n1=q-p+1;
36     int n2=r-q;
37     T *L=new T[n1+1];
38     T *R=new T[n2+1];
39 
40     for (int i=0;i<n1;i++)
41         L[i]=A[i+p];
42     for (int i=0;i<n2;i++)
43         R[i]=A[i+q+1];
44 
45     L[n1]=R[n2]=INT_MAX;
46 
47     int i=0,j=0;
48     for (int k=p;k<=r;k++)
49     {
50         if (L[i]>R[j])
51         {
52             A[k]=R[j];
53             j++;
54         }
55         else
56         {
57             A[k]=L[i];
58             i++;
59         }
60     }
61 
62     delete[] L;
63     delete[] R;
64 
65 }
66 
67 template<typename T>
68 void Sort<T>::merge_sort(vector<T> &A,int p,int r)
69 {
70     if (p<r)
71     {
72         int mid=(p+r)/2;
73         merge_sort(A,p,mid);
74         merge_sort(A,mid+1,r);
75         merge(A,p,mid,r);
76     }
77 }
78 template<typename T>
79 void Sort<T>::print_element(vector<T> A)
80 {
81     int len=A.size();
82     for (int i=0;i<len;i++)
83     {
84         std::cout<<A[i]<<" ";
85     }
86     std::cout<<std::endl;
87 }
88 #endif
View Code

       sot_main.cpp  

 1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 #include "Sort.h"
 5 int main()
 6 {
 7     Sort<int> sort1;
 8     Sort<double> sort2;
 9     
10     int a[]={3,1,4,2,78,34,465};
11     vector<int > vec_a(a,a+7);
12     double b[]={3.3,3.2,4.34,2,7.8,3.4,4.65};
13     vector<double> vec_b(b,b+7);
14     sort1.insertion_sort(vec_a);
15     sort1.print_element(vec_a);
16     sort2.merge_sort(vec_b,0,6);
17     sort2.print_element(vec_b);
18 
19     return 0;
20 }
View Code

     输出:  

1 2 3 4 34 78 465
2 3.2 3.3 3.4 4.34 4.65 7.8

转载于:https://www.cnblogs.com/zhoutaotao/p/3949372.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 算法10-12~10-14是关于归并排序的。 归并排序是一种基于分治思想的排序算法,它将待排序的序列分成两个子序列,对每个子序列进行排序,然后将两个已排序的子序列合并成一个有序序列。 算法10-12是归并排序的递归实现,它将待排序的序列不断地分成两个子序列,直到每个子序列只有一个元素,然后将这些子序列两两合并,直到最终得到一个有序序列。 算法10-13是归并排序的非递归实现,它使用迭代的方式将待排序的序列分成若干个子序列,然后将相邻的子序列两两合并,直到最终得到一个有序序列。 算法10-14是归并排序的优化实现,它使用插入排序来处理长度较小的子序列,以提高排序效率。具体来说,当子序列的长度小于等于一定阈值时,使用插入排序排序,否则使用归并排序排序。 ### 回答2: 归并排序是一种基于分治思想的排序算法。该算法的核心思想是将待排序的序列不断分割成更小的子序列,直到每个子序列只有一个元素,然后将这些子序列逐一合并,直到整个序列有序。因此,归并排序分为两个主要过程,分别是分割过程和合并过程。 分割过程:归并排序首先将待排序的序列均分成两个子序列,然后递归地对子序列进行分割,直到每个子序列只有一个元素。 合并过程:将两个有序的子序列合并成一个有序的序列。此时需要定义两个指针 i 和 j 分别指向两个子序列的起始位置,比较两个指针所指向的元素的大小,将较小的元素放到结果数组中并将指针向后移动,直到有一个子序列的指针到达了序列的末尾,然后将另一个子序列中未处理的元素依次放入结果数组中。 归并排序的时间复杂度为 O(N*logN),其中 N 为序列的长度。因此,归并排序是一种性能较好且稳定的排序算法,但由于其需要使用临时数组来辅助排序,因此空间复杂度为 O(N)。 总之,归并排序是一种高效且稳定的排序算法,适用于各种规模的序列。在实际应用中,可以使用多线程或并发编程来加速归并排序的执行过程,提高排序效率。 ### 回答3: 归并排序是一种常见的排序算法,采用了分治的思想,可以在最坏情况下也达到O(nlogn)的时间复杂度。它将一个大问题拆分成小问题,然后逐个解决小问题。下面是归并排序的基本流程: 1. 将待排序的序列按照中间位置分为两个子序列,分别排序。 2. 合并两个有序的子序列,形成一个新的有序序列。 具体实现时,我们可以使用递归或迭代两种方式。下面以递归方式来说明归并排序实现。 算法10-12:递归实现归并排序 1. 将序列按中间位置分为左右两个子序列。 2. 对左右子序列分别递归调用归并排序。 3. 合并左右子序列。 算法10-13:合并两个有序序列 1. 定义一个新序列,长度为左右子序列之和。 2. 从两个子序列的头开始比较,将小的元素放入新序列中。 3. 将剩余的元素全部复制到新序列中。 算法10-14:归并排序时间复杂度 1. 分解阶段:将序列分为两个子序列,时间复杂度为O(logn)。 2. 合并阶段:合并两个有序序列,时间复杂度为O(n)。 3. 总时间复杂度为O(nlogn)。 归并排序虽然时间复杂度较低,但空间复杂度为O(n),需要额外的存储空间来存储临时序列。但相比其他排序算法,归并排序具有稳定性,适合处理大规模数据的排序

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值