MERGE_SORT归并排序C++实现

以下实现归并排序,第一部分含有哨兵(算法来自《算法导论》),第二部分不含哨兵

第一部分,含有哨兵的归并排序:

#include<iostream>

using namespace std;

void myMERGE(int * A, int p, int q, int r)

{

int n1 = q - p + 2;

int n2 = r - q + 1;

int L[n1];

int R[n2];

for(int i = 0; i < n1-1; ++i)

L[i] = A[p + i];

L[n1-1] = INT_MAX;

for(int j = 0; j < n2-1; ++j)

R[j] = A[q + j + 1];

R[n2-1] = INT_MAX;

int i = 0;

int j = 0;

for(int k = p; k <= r; ++k)

A[k] = L[i] < R[j] ? L[i++] : R[j++];

}

void MERGE_SORT(int *A, int p, int r)

{

if(r > p)

{

int q = (r + p) / 2;

MERGE_SORT(A, p, q);

MERGE_SORT(A, q+1, r);

myMERGE(A, p, q, r);

}

}

int main()

{

int b[4] = {4,3,2,1};

MERGE_SORT(b,0,3);

for(int i = 0; i < 4; ++i)

cout << b[i] << endl;

return 0;

}

-----------------------------------------------------

#include<iostream>

using namespace std;

void myMERGE(int *A, int p, int q, int r)

{

int n1 = q - p + 2;

int n2 = r - q + 1;

int L[n1];

int R[n2];

for(int i = 0; i < n1 - 1; ++ i)

{

L[i] = A[p + i];

}

L[n1 - 1] = 0;

for(int j = 0; j < n2 - 1; ++ j)

{

R[j] = A[q + 1 + j];

}

R[n2 - 1] = 0;

int i = 0;

int j = 0;

for(int k = p; k <= r; ++k)

{

A[k] = L[i] > R[j] ? L[i++] : R[j++];

}

}

void MERGE_DESCSORT(int *A, int p, int r)

{

if(r > p)

{

int q = (r + p) / 2;

MERGE_DESCSORT(A, p, q);

MERGE_DESCSORT(A, q + 1, r);

myMERGE(A, p, q, r);

}

}

int main()

{

int b[] = {1,2,3,4,5};

MERGE_DESCSORT(b, 0, 4);

for(int i = 0; i < 5; ++i)

{

cout << b[i] << endl;

}

return 0;

}

第二部分,不含有哨兵的归并排序:

#include<iostream>

using namespace std;

void myMERGE2(int *A, int p, int q, int r)

{

int n1 = q - p + 1;

int n2 = r - q;

int L[n1];

int R[n2];

for(int i = 0; i < n1; ++i)

L[i] = A[p + i];

for(int j = 0; j < n2; ++j)

R[j] = A[q + 1 + j];

int i = 0;

int j = 0;

int k = p;

while(i < n1 && j < n2)

A[k++] = L[i] < R[j]?L[i++]:R[j++];

while(i < n1)

A[k++] = L[i++];

while(j < n2)

A[k++] = R[j++];

}

void MERGE_SORT2(int *A, int p, int r)

{

if(p < r)

{

int q = (r + p) / 2;

MERGE_SORT2(A, p, q);

MERGE_SORT2(A, q + 1, r);

myMERGE2(A, p, q, r);

}

}

int main()

{

int b[] = {5,4,3,2,1};

MERGE_SORT2(b,0,4);

for(int i = 0; i < 5; ++i)

cout << b[i] << endl;

return 0;

}

时间: 2024-08-14 01:32:02

MERGE_SORT归并排序C++实现的相关文章

归并排序(MERGE_SORT)

归并排序(MERGE_SORT) 1)分治思想 :归并排序用到了一种称为分治法的设计方法,分治法的思想就是将原问题的分解成为几个规模小的但是类似于原问题的子问题,递归的求解子问题,之后再合并子问题的解,来组成原问题的解. 2)原理 :根据分治方法的思想,归并排序算法的基本操作分为三大步:分解,解决问题,合并结果.以一个需要排序的数组为例,分解也就是不停地递归分解问题,直到问题的规模降为1,然后开始合并. 3)C语言实现 : void merge(int from, int mid, int to

疯子的算法总结(六) 复杂排序算法 ① 归并排序 merge_sort()

归并排序采取了分治的思想,每次分别排左半边和右半边,不断递归调用自己,直到只有一个元素递归结束,开始回溯,调用merge函数,合并两个有序序列,再合并的时候每次给末尾追上一个最大int这样就不怕最后一位的数字不会被排序. #include <bits/stdc++.h> using namespace std; void merge(int a[],int n,int left ,int mid,int right); void merge_sort(int a[],int n,int lef

算法 排序NB二人组 堆排序 归并排序

参考博客:基于python的七种经典排序算法     常用排序算法总结(一) 序前传 - 树与二叉树 树是一种很常见的非线性的数据结构,称为树形结构,简称树.所谓数据结构就是一组数据的集合连同它们的储存关系和对它们的操作方法.树形结构就像自然界的一颗树的构造一样,有一个根和若干个树枝和树叶.根或主干是第一层的,从主干长出的分枝是第二层的,一层一层直到最后,末端的没有分支的结点叫做叶子,所以树形结构是一个层次结构.在<数据结构>中,则用人类的血统关系来命名,一个结点的分枝叫做该结点的"

两路归并排序

链表两路归并 #include<iostream> #include<assert.h> using namespace std; struct node { int val; node * next; node(int v) { val=v; next=NULL; } }; node * merge(node* list1 , node * list2) { assert(list1!=NULL&&list2!=NULL);//括号中是希望出现的正确的情况  no

利用Python实现归并排序

利用python进行归并排序,摘抄自http://blog.csdn.net/minxihou/article/details/51821052 "代码真的不是一气呵成的,而且也不是想当然写出来的.可能需要反复断点中断来查看是否有逻辑错误.在理解了问题的基础下我们需要先把大体的代码框架最好先写出来,特别是主要的逻辑判断语句.但是不需要太care我循环体或者判断里面语句怎么实现,当你把这一步做到的时候能避免很多不必要的错误发生." 1 import random 2 3 def Conf

python实现归并排序,归并排序的详细分析。

学习归并排序的过程是十分痛苦的.它并不常用,看起来时间复杂度好像是几种排序中最低的,比快排的时间复杂度还要低,但是它的执行速度不是最快的.很多朋友不理解时间复杂度低为什么运行速度不一定快,这个不清楚的伙伴可以看下我之前发表的文章http://www.cnblogs.com/Lin-Yi/p/7301535.html看完之后也许你会对时间复杂度有一个新的认识. 我谈的观点往往不是官方的定义,我希望能帮助更多基础薄弱的同学读懂思想~ 归并排序: 先分开再合并,分开成单个元素,合并的时候按照正确顺序合

[算法]——归并排序(Merge Sort)

归并排序(Merge Sort)与快速排序思想类似:将待排序数据分成两部分,继续将两个子部分进行递归的归并排序:然后将已经有序的两个子部分进行合并,最终完成排序.其时间复杂度与快速排序均为O(nlogn),但是归并排序除了递归调用间接使用了辅助空间栈,还需要额外的O(n)空间进行临时存储.从此角度归并排序略逊于快速排序,但是归并排序是一种稳定的排序算法,快速排序则不然. 所谓稳定排序,表示对于具有相同值的多个元素,其间的先后顺序保持不变.对于基本数据类型而言,一个排序算法是否稳定,影响很小,但是

【算法导论】归并排序

递归与分治 许多有用的算法在结构上是递归的:为了解决一个给定的问题,算法一次或多次递归地调用其自身以解决紧密相关的若干子问题.这些算法典型地遵循分治法的思想:将原问题分解为几个规模较小但类似于原问题的子问题,递归地求解这些子问题,然后再合并这些子问题的解来建立原问题的解. 分治模式在每层递归时都有三个步骤: 分解原问题为若干子问题,这些子问题是原问题的规模较小的实例. 解决这些子问题,递归地求解各子问题.然而,若子问题的规模足够小,则直接求解. 合并这些子问题的解成原问题的解. 归并排序 归并排

归并排序(Python)

一.采用分治策略:将原问题划分成n个规模较小的但结构和原问题相同的子问题,递归解决这些子问题后合并各个结果从而得到原问题的解. 二.分治策略的步骤: 分解:将原问题分解成一系列子问题 解决:子问题粒度足够小.能直接求解则直接求解,子问题不能直接求解则继续递归分解为更小的子问题 合并:将子问题的结果合并为原问题的解 总的来说就是递归分解问题至能直接求解,然再将各子问题的结果合并在一起从而得到原问题的解 三.归并排序(以整数排序为例) 3.1将待排序的数组为左右两个组单独排序,然后合并左右两个已排序