C语言数据结构_十大经典排序算法

独爱众生

已于 2023-06-20 23:22:23 修改

阅读量127

点赞数 1

文章标签：排序算法数据结构 c语言

于 2023-06-04 17:01:23 首次发布

本文链接：https://blog.csdn.net/weixin_74953731/article/details/131034201

版权

第一关冒泡排序

void sort_array(int *arr, int n)
//  编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组arr 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i ,j;
    int flag ;
    for(i=0;i<n-1;i++)
    {
        flag = 0;
        for(j=0;j<n-i-1;j++)
            if(arr[j]>arr[j+1])
            {
                int temp   =arr[j];
                    arr[j]    = arr[j+1];
                    arr[j+1] = temp; 
                    flag  = 1;
            }
            if(flag==0)
                break;
            if(i<3)
                print_array(arr, n);   
    }
       print_array(arr, n);   
    
    /********** End **********/
}

第二关选择排序

void sort_array(int *arr, int n)
//  编程实现《选择排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次选择操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
     int i ,j,min;
     int flag = 0,temp=0;
    for(i=0;i<n-1;i++)
    {
        min = arr[i];
        for(j=i+1;j<n;j++)
            if(min>arr[j])
                {
                    min = arr[j];
                    flag = 1;
                    temp=j;
                }

       if(flag==1)
       {
          int t = arr[i];
          arr[i]  = arr[temp];
          arr[temp] = t;
          flag = 0 ;
       }

        if(i<3)
            print_array(arr, n);  
    }
       
       print_array(arr, n);   


    
    /********** End **********/
}

第三关插入排序

//  编程实现《插入排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次插入操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
   
    
   	int i ,j ,temp;
	for(i =1;i<n;i++)
  	{
      if(arr[i]<arr[i-1])
      {
        temp = arr[i];
        for(j=i-1;temp<arr[j]&&j!=-1;j--)         
             arr[j+1] = arr[j];
             
             
        arr[j+1] =temp;
      }
      if(i<4)
        print_array(arr, n);
  	}
     print_array(arr, n);  

    
    /********** End **********/
}

第四关希尔排序

void sort_array(int *arr, int n)
//  编程实现《希尔排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出三遍增量排序操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    
	int i = 0,t=0;
	int key = 0;
	int end = 0;
	int Gap[4] = {5,2,1,-1};
	int gap = Gap[t];
	while (gap > 0)
	{
		for (i = gap; i < n; i++)
		{
			key = arr[i];
			end = i - gap;
			while (end >= 0 && key<arr[end])
			{
				arr[end + gap] = arr[end];
				end=end-gap;
			}
			arr[end + gap] = key;
		}
		
		print_array(arr, n);
		t++;
		gap=Gap[t];
	
	}
	print_array(arr, n);

    
    /********** End **********/
}

第五关归并排序

int* merge_array(int *arr1, int n1, int* arr2, int n2)
//  编程实现两个有序数组arr1和arr2合并
//  函数参数：有序数组arr1 数组arr1长度 有序数组arr2 数组arr2长度
//  函数返回值：返回从小到大排序后的合并数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int arr3_length =  n1 + n2;
    int *arr3 = (int *)malloc(sizeof(int)*arr3_length);
	int i=0 , j=0,t=0;
	while(i<n1&&j<n2)
		{
			if(arr1[i]<=arr2[j])
				arr3[t++] = arr1[i++];
			else
				arr3[t++] = arr2[j++];	
		}


	if(i==n1)
		{
			while(t<arr3_length)
				arr3[t++] = arr2[j++];	
		}
	else
		{
            while(t<arr3_length)
			arr3[t++] = arr1[i++];
		}
	return arr3;
    
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int mid ;
    int left = 0 ,right = n;
	mid = (left+right)/2;	
    if(right!=1)
    {		 
        int *Arr_1 = &arr[left],*Arr_2 = &arr[mid];
        Arr_1 = merge_sort(Arr_1,mid);
        Arr_2 = merge_sort(Arr_2,right-mid);
        arr = merge_array(Arr_1,mid,Arr_2,right-mid);

    }
    return arr;
    
    /********** End **********/
}

第六关快速排序

int partition_array(int *arr ,int l,int r)
// 编程实现arr[l, r]分区：选定一个基准，左边比基准小，右边比基准大
// 返回基准所处位置
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp = arr[l];
	while(l<r)
	{        
		while((l<r)&&arr[r]>=temp)
			r--;
		arr[l] = arr[r];

		while((l<r)&&arr[l]<=temp)
			l++;
		arr[r] = arr[l];

    }
    arr[l] = temp;
    return l;

    /********** End **********/
}

int* quick_sort(int *arr, int l, int r)
//  基于partition_array函数编程实现快速排序：自上而下的递归方法
//  函数参数：有序数组arr 初始l=0，r=n-1
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int pos = partition_array(arr,l,r);

    if(l<r)
    {
        if(l<pos-1)
			arr = quick_sort(arr,l,pos-1);
        if(pos+1<r)
            arr = quick_sort(arr,pos+1,r);
    }
    return arr;

    /********** End **********/
}

第七关堆排序

void adjustHeap(int *arr, int param1, int j)
// 编程实现堆的调整
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp;
    if(j<param1)
	{
		int max=j;
		int s1=2*j+1;
		int s2=2*j+2;
		if(arr[s1]>arr[max]&&s1<param1)
			max=s1;
		if(arr[s2]>arr[max]&&s2<param1)
			max=s2;
		if(max!=j)
		{
			
            temp     = arr[max];
            arr[max] = arr[j];
            arr[j]   = temp; 
			
            adjustHeap(arr,param1,max);		
		}
	}
    /********** End **********/
}

int* heap_sort(int *arr, int n)
//  基于adjustHeap函数编程实现堆排序
//  函数参数：无序数组arr 数组长度n
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,temp;
    int last=n-1;				
	int parent=(last-1)/2;		
	for(int i=parent;i>=0;i--)	
	{
		adjustHeap(arr,n,i);		
	}
    for(int i=n-1;i>=0;i--)
	{
        temp   = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;	
		adjustHeap(arr,i,0);		
	}

    return arr;

    /********** End **********/
}

第八关计数排序

void sort_array(int *arr, int n)
//  编程实现《计数排序算法》
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出：
//  每一行一个元素及其个数（升序），如 1 1
//  以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int MAX =arr[0],MIN=arr[0], t =0 ;;
 
  	int i ; 
    for(i=0;i<n;i++)
        {
            if(arr[i]>=MAX)
                    MAX = arr[i];       
             if(arr[i]<=MIN)
                    MIN = arr[i];
        }
    int Arr_2[MAX] ;
    int  j=0;
    while(j<=MAX)
    {
    		Arr_2[j] =0;
    		j++; 
	}
    for( i=0;i<n;i++)
       	 Arr_2[arr[i]]++;
    for( i = MIN;i<=MAX;i++)
        {
           int temp = Arr_2[i];
           while(Arr_2[i]!=0) 
            {
                arr[t] = i; 
                t++;
                Arr_2[i]--;
            }
        	if(temp!=0)
           	printf("%d %d\n",i,temp);
          
        }
    
    print_array(arr,n);
    
    /********** End **********/
}

第九关桶排序

int* sort_array(int *arr, int n)
//  编程实现《桶排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,j,MAX = arr[0],MIN = arr[0],Num = 10;
	
	int bucketEle[10] ;
    for(i=0;i<n;i++)
        if(arr[i]>=MAX)
                MAX = arr[i];       
        else if(arr[i]<=MIN)  
        		MIN = arr[i];
	int len =15;
	int bucketArry [Num][len];
	for(i=0;i<Num;i++)
		{
			bucketEle[i]  = 0; 
			for(j=0;j<len;j++)
				bucketArry[i][j]=0;
		}
	for(i=0;i<n;i++) 
	{
		int  subScript_1 = arr[i]/10;	
		bucketArry[subScript_1][bucketEle[subScript_1]] = arr[i];
		bucketEle[subScript_1]++;
	}
	int temp,f;
	for(temp=0;temp<Num;temp++) 
		{
			int length = bucketEle[temp];
			for(i=0;i<length-1;i++)
				{
					for(j=0;j<length-i-1;j++)
						{
							if(bucketArry[temp][j]>bucketArry[temp][j+1])
							{
								f = bucketArry[temp][j];
								bucketArry[temp][j] = bucketArry[temp][j+1];
								bucketArry[temp][j+1] = f;
							}
						}
				}
		}
			
	int t=0,k=0;
	for(i=0;i<Num;i++)
	{
		if(bucketEle[i]!=0)
		{
			while(k<bucketEle[i]) 
			{
				arr[t] = bucketArry[i][k];
				
				t++;
				k++; 
			}
		} 
		k=0;
	}
		 
	
   return arr;
    
    
    /********** End **********/
}

第十关基数排序

int* sort_array(int *arr, int n)
//  编程实现《基数排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
     int MAX =arr[0],MIN=arr[0], t =0 ;
 
  	int i ; 
    for(i=0;i<n;i++)
        {
            if(arr[i]>=MAX)
                    MAX = arr[i];       
             if(arr[i]<=MIN)
                    MIN = arr[i];
        }
    int Arr_2[MAX] ;
    int  j=0;
    while(j<=MAX)
    {
    		Arr_2[j] =0;
    		j++; 
	}
  
  
    for( i=0;i<n;i++)
       	 Arr_2[arr[i]]++; 
       	 
    for( i = MIN;i<=MAX;i++)
        {
           while(Arr_2[i]!=0) 
            {
                arr[t] = i; 
                t++;
                Arr_2[i]--;
            }
          
        }
    
    return arr;
    
    /********** End **********/
}