1)④排序算法之归并排序

  1 #include "iostream"
  2 #include "vector"
  3 #include "time.h"
  4 #include "iomanip"
  5 using namespace std;
  6
  7 #define num 25
  8 typedef int type;//type类型为int
  9
 10 /*
 11 *将非降数组A,B,中的元素
 12 */
 13 void merge(vector<type>A,vector<type>B,vector<type>&C,int flags)
 14 {
 15     int ia =0,ib=0,ic=0;
 16     if(flags==1)//升序
 17     {
 18         while(ia<A.size()&&ib<B.size())
 19         {
 20             if(A[ia]<=B[ib])
 21             {
 22                 C.push_back(A[ia++]);
 23             }else C.push_back(B[ib++]);
 24         }
 25     }else if(flags==0){//降序
 26         while(ia<A.size()&&ib<B.size())
 27         {
 28             if(A[ia]>=B[ib])
 29             {
 30                 C.push_back(A[ia++]);
 31             }else C.push_back(B[ib++]);
 32         }
 33     }
 34     while(ia<A.size())
 35     {
 36         C.push_back(A[ia++]);
 37     }
 38
 39     while(ib<B.size())
 40     {
 41         C.push_back(B[ib++]);
 42     }
 43
 44 }
 45
 46 /*
 47 *将n个长度的子表归并为m个子表(n为偶数,m=n/2;否,m=n/2+1)
 48 */
 49 int Merge_sort(vector<vector<int>>array,int n,vector<vector<int>>&mid,int &count,int flags)
 50 {
 51     int i;
 52     if(n%2==0)
 53     {
 54         count = n/2;
 55         for(i=0;i<n-1;i=i+2)
 56         {
 57             merge(array[i],array[i+1],mid[i/2],flags);
 58         }
 59     }else{
 60         count = n/2 +1;
 61         vector<int>temp;
 62         temp.clear();
 63         for(i=0;i<n-2;i=i+2)
 64         {
 65             merge(array[i],array[i+1],mid[i/2],flags);
 66         }
 67         merge(array[n-1],temp,mid[count-1],flags);
 68     }
 69     return 0;
 70 }
 71
 72 void Sort_Merge()
 73 {
 74     int i,j,flags;
 75     time_t start,end;
 76     vector<int>array;
 77     cout<<"Initialize Array:"<<endl;
 78     for(i=0;i<num;i++)//随机产生数组中的数据
 79     {
 80         array.push_back(rand()%1000);
 81         cout<<setw(5)<<array[i]<<" ";
 82         if((i+1)%10==0)cout<<endl;
 83     }
 84     cout<<endl;
 85     cout<<"please inout flags[flags:1,升序;0降序]:";
 86     cin>>flags;
 87     start = clock();
 88     vector<vector<int>>arraymid(array.size());
 89     for(i=0;i<array.size();i++)//初始化num个子表
 90     {
 91         arraymid[i].push_back(array[i]);
 92     }
 93     vector<vector<int>>mid(num);//存放num个子表归并后的子表
 94     int count =arraymid.size();//用于记录起始子表数目
 95     int countmid = count;//用于记录归并后子表的数目
 96     while(count!=1)
 97     {
 98         for(i=0;i<countmid;i++)
 99         {
100             mid[i].clear();//清空待存放归并后子表的数组
101         }
102         Merge_sort(arraymid,count,mid,countmid,flags);//归并
103
104         for(i=0;i<count;i++)//将归并后的子表赋给arraymid,然后继续归并
105         {
106             arraymid[i].clear();
107             for(j=0;j<mid[i].size();j++)
108             {
109                 arraymid[i].push_back(mid[i][j]);
110             }
111         }
112         count = countmid;//子表数目更新为归并后的子表数目
113     }
114     end = clock();
115     cout<<"The Merge_Sorted Array:"<<endl;
116     //输出最终排序后的的结果
117     for(i=0;i<count;i++)
118     {
119         for(j=0;j<mid[i].size();j++)
120         {
121             cout<<setw(5)<<mid[i][j]<<" ";
122             if((j+1)%10==0)cout<<endl;
123         }
124     }
125     cout<<endl;
126
127     cout<<"performnace time:";
128     cout<<(double)(end - start )/1000<<"Seconds"<<endl;
129 }
130
131 int main()
132 {
133     Sort_Merge();
134     return 0;
135 }

时间: 2024-10-28 20:30:12

1)④排序算法之归并排序的相关文章

排序算法系列——归并排序

记录学习点滴,菜鸟成长记 归并排序的英文叫做Merge-Sort,要想明白归并排序算法,还要从“递归”的概念谈起. 1.递归 一般来讲,人在做决策行事的时候是往往是从已知出发,比如,我又要举个不恰当的例子了→_→: 看到漂亮姑娘→喜欢人家→追→女朋友→老婆 但是人家施瓦辛格不是这么想的,人家从小就立志当总统: 要当总统←先当州长←竞选州长要有钱←那得找个有钱妹子←妹子都喜欢明星←身材好能当明星←健身 递归,就像一个人对自己的发展有清晰的规划和坚定的信心一样,他知道每一步会有怎么样的结果,他需要仅

常用排序算法之——归并排序

归并排序的原理: 如果数组的元素个数大于1,则: 将数组平均分为两部分: 左边的数组归并排序:递归 右边的数组归并排序:递归 将两个各自有序的数组合并,需要一个额外的辅助数组,暂时保存合并结果:返回 否则,数组元素个数为1时,已经有序:直接返回. 稳定排序.时间复杂度在最坏.最好.平均情况下都为O(N lgN),空间复杂度为O(N). 代码: 1 #include <iostream> 2 using namespace std; 3 4 template<typename T>

Java常见排序算法之归并排序

在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let‘s go~~~ 1.排序算法的基本概念的讲解 时间复杂度:需要排序的的关键字的比较次数和相应的移动的次数. 空间复杂度:分析需要多少辅助的内存. 稳定性:如果记录两个关键字的A和B它们的值相等,经过排序后它们相对的位置没有发生交换,那么我们称这个排序算法是稳定的. 否则我们称这个排序算法是不稳定的

我的Java开发学习之旅------&amp;gt;Java经典排序算法之归并排序

一.归并排序 归并排序是建立在归并操作上的一种有效的排序算法,该算法是採用分治法(Divide and Conquer)的一个很典型的应用.将已有序的子序列合并,得到全然有序的序列.即先使每一个子序列有序.再使子序列段间有序.若将两个有序表合并成一个有序表.称为二路归并. 归并过程为:比較a[i]和a[j]的大小.若a[i]≤a[j],则将第一个有序表中的元素a[i]拷贝到r[k]中,并令i和k分别加上1.否则将第二个有序表中的元素a[j]拷贝到r[k]中,并令j和k分别加上1.如此循环下去.直

排序算法之归并排序(Mergesort)解析

一.归并排序的优缺点(pros and cons) 耗费心思来理解它,总要有个理由吧: 归并排序的效率达到了巅峰:时间复杂度为O(nlogn),这是基于比较的排序算法所能达到的最高境界 归并排序是一种稳定的算法(即在排序过程中大小相同的元素能够保持排序前的顺序,3212升序排序结果是1223,排序前后两个2的顺序不变),这一点在某些场景下至关重要 归并排序是最常用的外部排序方法(当待排序的记录放在外存上,内存装不下全部数据时,归并排序仍然适用,当然归并排序同样适用于内部排序...) 缺点: 归并

排序算法 之 归并排序

归并排序也是基于分治思想的一种排序算法,是通过对两个或两个以上的有序序列合并来实现的,对两个序列合并的叫两路归并,对两个以上序列合并的叫多路归并.归并排序的时间复杂度也为O(N*logN).下面来看一下两路归并的实现: 基本思想:归并排序时先找出序列的中间元素把序列分解为两个子序列,对子序列重复这个过程直至把序列分解成为只包含单个元素的序列,然后把相邻的序列两两合并使之有序,重复两两合并直至合并成为一个序列归并结束序列有序. 代码实现: /// <summary> /// 归并排序 /// &

八大排序算法之七-归并排序

归并类的排序算法 归并:将两个或两个以上的有序表组合成一个新的有序表. 内部排序中,通常采用的是 2-路归并排序.即:将两个位置相邻的记录有序子序列归并为一个记录有序的序列.归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 图解如下 看成是 n 个有序的子序列(长度为 1),然后两两归并. 得到 n/2 个长度为2 或 1 的有序子序列.继续亮亮归并 最后一趟 代码如下: #include<iostream> #i

我的Java开发学习之旅------&gt;Java经典排序算法之归并排序

一.归并排序 归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为二路归并. 归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1:否则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直

指针实现时间复杂度为O(n*logN)的排序算法(归并排序算法)

归并排序 1 /** 2 * Definition for singly-linked list. 3 * struct ListNode { 4 * int val; 5 * ListNode *next; 6 * ListNode(int x) : val(x), next(NULL) {} 7 * }; 8 */ 9 class Solution { 10 public: 11 ListNode* sortList(ListNode* head) { 12 //排序算法 空间复杂度N*lo

Java实现排序算法之归并排序

一.综述 归并排序(Merge sort,台湾译作:合并排序)是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 算法描述 归并操作的过程如下: 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列 设定两个指针,最初位置分别为两个已经排序序列的起始位置 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置 重复步骤3直到某一指针达到序列尾 将另一序列剩下的所有元素直接复制到合并序列尾