精华内容
下载资源
问答
  • 归并排序c
    千次阅读
    2020-10-18 20:51:39

    归并排序

    对一个元素个数为20个的随机数组进行快速排序

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    void Display(int *arr, int n){
    	for (register int i = 0; i < n; i++){
    		printf("%d ", arr[i]);
    	}
    	printf("\n");
    }
    
    void merge(int *arr, int L, int M, int R){
    	int LEFT_SIZE = M - L;
    	int RIGHT_SIZE = R - M + 1;
    	int left[LEFT_SIZE];
    	int right[RIGHT_SIZE];
    	int i, j, k;
    	
    	//将原数组左边分到一个新数组left中
    	for(i = L; i < M; i++){
    		left[i - L] = arr[i]; 
    	} 
    	//将原数组右边分到一个新数组right中
    	for(i = M; i <= R; i++){
    		right[i - M] = arr[i]; 
    	}
    	i = 0; j = 0; k = L;
    	while(i < LEFT_SIZE && j < RIGHT_SIZE){
    		//如果left数组的第一个数字比right数组第一个数字小就把它放到新数组里 
    		if(left[i] < right[j]){
    			arr[k] = left[i];
    			i++;
    			k++;
    		}else{
    			arr[k] = right[j];
    			j++;
    			k++;
    		}
    	}
    	while(i < LEFT_SIZE){
    		arr[k] = left[i];
    		i++;
    		k++;
    	}
    	while(j < RIGHT_SIZE){
    		arr[k] = right[j];
    		j++;
    		k++;
    	}
    	 
    }
     
    
    void mergesort(int *arr, int L, int R){
    	int M = (L + R)/2;
    	if(L == R){
    		return;
    	}else{
    		printf("归并排序中:");
    		Display(arr, 20);
    		mergesort(arr, L, M);
    		mergesort(arr, M+1, R);
    		merge(arr, L, M+1, R);		
    	}
    }
    
    
    		
    int main(){
    	int arr[20] = {6,5,4,3,2,1,8,7,0,9,11,33,22,55,77,44,66,99,888,90};;
    	//生成一个有20个元素的随机数组
    	srand((unsigned int)time(0));//修改种子
    	for (register int i = 0; i < 20; i++){	
    		arr[i] = rand();
    	}
    	printf("原数组为:\n");
    	Display(arr, 20);
    	printf("\n");
    	int L = 0;
    	int R = 19;
    	mergesort(arr, L, R);
    	printf("\n归并排序后:\n");
    	Display(arr, R+1);
    	return 0;
    }
    
    

    如有不足,欢迎各位大佬指正

    更多相关内容
  • 排序算法中的归并排序(Merge Sort)是利用”归并”技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 一、实现原理: 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的...
  • 048 归并排序 C语言
  • 归并排序c语言

    2016-02-18 19:17:36
    归并排序C语言实现,这里提供给大家分享,很好用!
  • 归并排序 c语言实现

    2021-01-11 23:42:53
    归并排序 归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法 算法复杂度:O(nlogn) 就是将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序...

    归并排序

    归并排序(Merge Sort)是建立在归并操作上的一种有效,稳定的排序算法
    算法复杂度:O(nlogn)
    就是将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
    在这里插入图片描述
    递归实现

    /* 归并排序 - 递归实现 */
    
    #include <stdio.h>
    #include<stdlib.h> 
    #define ElementType int
    
    
    
    /* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
    void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
    { /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
         int LeftEnd, NumElements, Tmp;
         int i;
         
         LeftEnd = R - 1; /* 左边终点位置 */
         Tmp = L;         /* 有序序列的起始位置 */
         NumElements = RightEnd - L + 1;
         
         while( L <= LeftEnd && R <= RightEnd ) {
             if ( A[L] <= A[R] )
                 TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */
             else
                 TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */
         }
    
         while( L <= LeftEnd )
             TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */
         while( R <= RightEnd )
             TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */
             
         for( i = 0; i < NumElements; i++, RightEnd -- )
             A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
    }
    
    void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd )
    { /* 核心递归排序函数 */ 
         int Center;
         
         if ( L < RightEnd ) {
              Center = (L+RightEnd) / 2;
              Msort( A, TmpA, L, Center );              /* 递归解决左边 */ 
              Msort( A, TmpA, Center+1, RightEnd );     /* 递归解决右边 */  
              Merge( A, TmpA, L, Center+1, RightEnd );  /* 合并两段有序序列 */ 
         }
    }
    
    void MergeSort( ElementType A[], int N )
    { /* 归并排序 */
         ElementType *TmpA;
         TmpA = (ElementType *)malloc(N*sizeof(ElementType));
         
         if ( TmpA != NULL ) {
              Msort( A, TmpA, 0, N-1 );
              free( TmpA );
         }
         else printf( "空间不足" );
    }
    
    
    int main()
    {
    	int A[5]={4,5,3,3,2};
    	MergeSort(A,5);
    	for(int i=0;i<5;++i)
    	{
    		printf("%d ",A[i]);
    	}
    	return 0;
    }
    

    迭代实现

    #include <stdio.h>
    #include<stdlib.h> 
    #define ElementType int
    
    /* 归并排序 - 迭代实现 */
    
    /* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
    void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
    { /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
         int LeftEnd, NumElements, Tmp;
         int i;
         
         LeftEnd = R - 1; /* 左边终点位置 */
         Tmp = L;         /* 有序序列的起始位置 */
         NumElements = RightEnd - L + 1;
         
         while( L <= LeftEnd && R <= RightEnd ) {
             if ( A[L] <= A[R] )
                 TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */
             else
                 TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */
         }
    
         while( L <= LeftEnd )
             TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */
         while( R <= RightEnd )
             TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */
             
         for( i = 0; i < NumElements; i++, RightEnd -- )
             A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
    }
    
    
    /* length = 当前有序子列的长度*/
    void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )
    { /* 两两归并相邻有序子列 */
         int i, j;
          
         for ( i=0; i <= N-2*length; i += 2*length )
             Merge( A, TmpA, i, i+length, i+2*length-1 );
         if ( i+length < N ) /* 归并最后2个子列*/
             Merge( A, TmpA, i, i+length, N-1);
         else /* 最后只剩1个子列*/
             for ( j = i; j < N; j++ ) TmpA[j] = A[j];
    }
    
    void Merge_Sort( ElementType A[], int N )
    { 
         int length; 
         ElementType *TmpA;
         
         length = 1; /* 初始化子序列长度*/
         TmpA = malloc( N * sizeof( ElementType ) );
         if ( TmpA != NULL ) {
              while( length < N ) {
                  Merge_pass( A, TmpA, N, length );
                  length *= 2;
                  Merge_pass( TmpA, A, N, length );
                  length *= 2;
              }
              free( TmpA );
         }
         else printf( "空间不足" );
    }
    
    int main()
    {
    	int A[5]={4,5,3,3,2};
    	Merge_Sort(A,5);
    	for(int i=0;i<5;++i)
    	{
    		printf("%d ",A[i]);
    	}
    	return 0;
    }
    
    展开全文
  • 主要介绍了C语言数据结构 链表与归并排序实例详解的相关资料,需要的朋友可以参考下
  • 本文实例为大家分享了C语言实现归并排序的具体代码,供大家参考,具体内容如下 归并排序的基本思想: 将两个及其以上的有序表合并为一张有序表,把待排序序列通过分治法分为若干个有序子序列,然后每两个子序列合并...
  • 归并排序C语言实现

    2011-12-03 16:28:33
    归并排序C语言实现
  • 归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补...

    概念:

    归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。


     

    分治算法 

    阶段        可以理解为就是递归拆分子序列的过程,递归深度为log2n。

    阶段        合并相邻有序子序列,我们需要将两个已经有序的子序列合并成一个有序序列,比如上图中的最后一次合并,要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列,合并为最终序列[1,2,3,4,5,6,7,8],来看下实现步骤。 

     

     所以本质是先分:递归拆成2个2个的比较排序,再治:再相邻两个为单位排好序放入一个新的数组。要求两组排序每组内本身要排好序


    C语言代码

    #include<stdio.h>
    #define len 10000
    int temp[len];                       //临时数组用来存放有序数列部分
    void merge(int [],int,int,int);     //分治思想的“治”部分,将有序的两个部分合并成一个有序部分
    void mergesort(int [],int,int);
    int main()
    {
        int n,a[1000],i;
        scanf("%d",&n);
        for(i=0;i<n;i++)
            scanf("%d",&a[i]);            //主函数输入
        mergesort(a,0,n-1);                //归并函数(merge sort)处理
        for(i=0;i<n;i++)                    //输出
            printf("%d ",a[i]);
        return 0;
    }
    
    ///分治思想的“治”部分,将有序的两个部分合并成一个有序部分
    void merge(int a[],int start,int mid,int end)    
    {
        int i,j,k=0;
        i=start;j=mid+1;
        while(i<=mid && j<=end)            
        {
            if(a[i]<a[j])
                temp[k++]=a[i++];
            else
                temp[k++]=a[j++];
        }
        
        if(j==end+1)    
        {
            while(i<=mid)
                temp[k++]=a[i++];
        }
        if(i==mid+1)
        {
            while(j<=end)
                temp[k++]=a[j++];
        }
        
        for(i=0,j=start;i<k;i++,j++)
            a[j]=temp[i];
        
    }
    
    //递归调用
    void mergesort(int a[],int start,int end)
    {
        if(start>=end)  return;
        int mid=(start+end)/2;
        mergesort(a,start,mid);
        mergesort(a,mid+1,end);    //先分
        merge(a,start,mid,end);    //再治
        
    }

    输出结果

     

    展开全文
  • 归并排序c语言实现

    2015-03-05 16:42:24
    归并排序算法C语言实现,以比较为基础的时间复杂度下限
  • 归并排序(C语言)

    千次阅读 2022-04-25 19:23:12
    归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序...

    基本思想

    归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
    在这里插入图片描述

    递归实现

    //归并排序
    void MergeSort(int* a, int sz)
    {
    	int* tmp = (int *)malloc((sizeof(int)) * (sz - 1));
    	_MergeSort(a, 0, sz - 1,tmp);
    }
    
    void _MergeSort(int* a, int left, int right,int* tmp)
    {
    	if (left >= right)
    		return;
    
    	int mid = (left + right) / 2;
    
    	//分解
    	_MergeSort(a, left, mid,tmp);
    	_MergeSort(a, mid+1,right,tmp);
    	
    	//合并
    	int begin1 = left, end1 = mid;
    	int begin2 = mid + 1, end2 = right;
    	int index = left;
    	while (begin1 <= end1 && begin2 <= end2)
    	{
    		if (a[begin1] < a[begin2])
    		tmp[index++] = a[begin1++];
    		
    		else
    			tmp[index++] = a[begin2++];
    	}
    	while (begin1 <= end1)
    		tmp[index++] = a[begin1++];
    
    	while (begin2 <= end2)
    		tmp[index++] = a[begin2++];
    
    	memcpy(a + left, tmp + left, (right - left + 1)*4);
    }
    

    非递归实现

    归并排序采取的是严格二分,因此归并的非递归实现较为简单,并不需要模拟栈的开辟,只需要令gap=1,进行合并,再领gap*2,直至gap<sz

    void MergeSortNonR(int* a, int sz)
    {
    	int* tmp = (int*)malloc(sizeof(int) * (sz - 1));
    
    	int gap = 1;
    
    	int i = 0;
    
    	while (gap<sz)
    	{
    		for (i = 0; i < sz; i = i + gap * 2)
    		{
    			int begin1 = i, end1 = i + gap - 1;
    			int begin2 = i + gap, end2 = i + 2 * gap - 1;
    			int index = i;
    			//当end1超过sz
    			if (end1 >= sz)
    				end1 = sz - 1;
    
    			//当begin2超过sz,令[begin2,end2]不存在
    			if (begin2 >= sz)
    			{
    				begin2 = 1;
    				end2 = 0;
    			}
    			//	end2超过sz
    			if (begin2 < sz && end2 >= sz)
    				end2 = sz - 1;
    
    			while (begin1 <= end1 && begin2 <= end2)
    			{
    				if (a[begin1] <= a[begin2])
    					tmp[index++] = a[begin1++];
    				else
    					tmp[index++] = a[begin2++];
    
    			}
    			while (begin1 <= end1)
    				tmp[index++] = a[begin1++];
    
    			while (begin2 <= end2)
    				tmp[index++] = a[begin2++];
    		}
    		memcpy(a, tmp, 4 * sz);
    		gap *= 2;
    	}
    }
    
    展开全文
  • 归并排序 C语言实现

    万次阅读 多人点赞 2019-04-20 13:05:45
    1. 归并排序(排序的方法一种,速度比选择排序、插入排序等快很多)适合较多数据排序 2. 归并排序思想(拆分、合并) 2.1 拆分 2.2 合并 2.2 合并详解 3. c语言代码实现 #include<stdio.h> #...
  • 归并排序 C语言

    2014-03-08 23:10:20
    C语言归并排序算法完整代码,欢迎交流讨论。
  • 图形实例4.C语言代码实现四、归并排序1.简单介绍2.算法原理3.图形实例4.C语言代码实现 一、冒泡排序 1.简单介绍 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列...
  • 归并排序C语言)详解

    万次阅读 多人点赞 2020-05-04 10:30:32
    今天记录一下归并排序,因为在csdn里面没有找到特别清楚的解析,所以想自己写的认真一点,也查阅了一些资料,通过这篇博客记录一下; 归并排序,光看字面,归并,似乎是把两个合并到一起,也是由此我们也就先来说...
  • 每次将待排序数组分为大致相等的三部分分别进行排序,然后再进行归并
  • C语言实现归并排序

    千次阅读 2022-04-07 12:46:43
    归并排序每次递归的动作: 将给定数组以中点为界,分为左右两部分,且左右两边的数字分别有序。(至于如何将它做到分别有序,则需使用递归实现) 使用两个指针 L(初始值为左边界) 和 R(初始值为中点右侧的第一个...
  • C语言——归并排序

    千次阅读 2021-12-09 21:56:42
    C语言——归并排序 归并排序用到了分治思想,借助递归的方式对一串数字进行排序,整个过程分为分开和合并两个过程。其实归并排序的思想并不难理解,但是用代码实现它却并不容易,我们要写两个函数去分别实现这个过程...
  • 归并排序C语言完整代码)

    千次阅读 2022-04-19 21:45:36
    归并排序是建立在归并操作上的一种有效的算法,该算法是采用分治法的一个非常典型的应用, 是一种稳定的排序算法。 将已有的子序列合并,得到完全有序的的序列;即先使每个子序列有序,再使子序列段间有序。 若将...
  • 归并排序 C语言

    2021-09-23 13:30:32
    归并排序是一种效率高、稳定的排序算法。是分治法非常典型的应用。 一、基本思想 归并排序的思想有点类似二叉树的后序遍历。 将待排序列不断分割成多个子序列,直到序列只剩一个元素,认为它默认有序。 有序的子...
  • 归并排序(C语言简单实现)

    千次阅读 2020-11-29 16:31:49
    归并排序(C语言简单实现) 归并排序(Merging Sort)利用的就是归并的思想实现的排序方法。原理是:假设初始序列含有n个记录,则可以看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到[n/2]个长度为2...
  • 二路归并排序c语言实现

    千次阅读 2017-10-16 16:07:05
    二路归并排序 c 语言实现。
  • C语言归并排序算法

    千次阅读 2022-02-05 22:17:31
    如果说快速排序是让一个数组分成很多小集体进行排序,那么归并排序就是让很多有序的小集体合成一个有序数组。 思路: 如果是升序,对于每一个数字来说其本身是有序的,最初让两个只有一个元素的数组arr1,arr2的...
  • c语言归并排序

    2022-07-03 08:25:56
    目录前言:归并排序1.递归版本 演示:实现:2.非递归版本演示:实现: ❥(ゝω・✿ฺ) hi~ 欢迎大家点开我的文章~ 这里我会介绍归并排序的两种实现方法:递归和非递归。
  • 归并排序在对链表进行排序中的应用(c语言实现)
  • 排序算法之——归并排序 C语言实现

    千次阅读 2020-12-20 19:11:58
    一 、归并排序的思路: 归并排序采用的是分治的思想,就是将数组进行分隔,直到最小的单位(两个元素),然后对最小的单位进行排序。 最后将排好序的单位依次遍历到数组中。 1 将数组进行分隔,直到不能再分的最小...
  • C语言归并排序(完整代码版)

    千次阅读 2021-09-11 18:59:21
    归并排序的代码如下: #include<stdio.h> #include<stdlib.h> void Merge(int arr[], int tmp[], int start,int mid, int end)//合并小组并排序 { int i = start;//i标识//左小组的第一个元素位置 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,764
精华内容 25,905
关键字:

归并排序c