C语言：算法之排序（详细代码）

已于 2022-09-17 09:10:04 修改
阅读量620 收藏
点赞数
文章标签： c语言 算法 排序算法
于 2022-09-17 09:06:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50711484/article/details/126822516
版权

目录

基本排序

冒泡排序                                                                        

插入排序                                      

选择排序                                                                          

进阶排序 

快速排序

希尔排序

堆排序

其他排序

归并排序

冒泡排序                                                                        

#include <stdio.h>
#include <stdlib.h>
//冒泡排序（从大到小）
void bubbleSort(int arr[],int n){
	int i,j,temp;
	for(i=1;i<n;i++){
		for(j=0;j<n-i;j++){
			if(arr[j]<arr[j+1]){
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
	}
	for(i=0;i<n;i++){
		printf("%d\t",arr[i]);
	}
}

//改进冒泡排序,当一轮排序没有交换任何一个元素，就说明是有序的数列，直接退出循环。
void bubbleSortImprovement(int arr[],int n){
	int i,j,temp;
	int flag=1;
	for(i=1;i<n;i++){
		for(j=0;j<n-i;j++){
			if(arr[j]<arr[j+1]){
				flag=0;
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
		if(flag==1){
			break;
		}
	}
	for(i=0;i<n;i++){
		printf("%d\t",arr[i]);
	}
}

int main()
{
	int arr[10]={4,2,5,7,3,1,6,9,8,0};
	bubbleSort(arr,10);
	system("pause");
}

插入排序                                      

#include <stdio.h>
#include <stdlib.h>
void insertSort(int arr[],int n){
	int i,j,temp;
	for(i=1;i<n;i++){
		temp=arr[i];
		j=i-1;
		while(j>=0 && arr[j]>temp){
			arr[j+1]=arr[j];
			j--;
		}
		arr[j+1]=temp;
	}
	for(i=0;i<n;i++){
		printf("%d\t",arr[i]);
	}
}
int main()
{
	int arr[10]={2,5,4,6,1,3,9,7,8,0};
	insertSort(arr,10);
	system("pause");
}

选择排序                                                                          

//每一轮遍历在未排序序列中找到最小（大）元素，与已排序序列的末尾元素调换位置；
void selectSort(int arr[],int n){
	int i,j,min,temp;
	for(i=0;i<n-1;i++){
		min=i;
		for(j=i;j<n;j++){
			if(arr[j]<arr[min]){
				min=j;
			}
		}
		temp=arr[i];
		arr[i]=arr[min];
		arr[min]=temp;
	}

	for(i=0;i<n;i++){
		printf("%d\t",arr[i]);
	}
}

//改进选择排序
//我们在每次遍历的时候找出最小值还有最大值，分别与左右已排序序列的末尾元素调换位置。
void swap(int * a,int * b){
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
void selectSort1(int arr[],int n){
	int min,max,z;
	int left=0;
	int right=n-1;
	while(left<right){
		min=left;
		max=right;
		for(z=left;z<=right;z++){
			if(arr[z]<arr[min]){
				min=z;
			}
			if(arr[z]>arr[max]){
				max=z;
			}
		}
		swap(&arr[max],&arr[right]);
		if(min==right){
			min=max;
		}
		swap(&arr[min],&arr[left]);
		left++;
		right--;
	}

	for(z=0;z<n;z++){
		printf("%d\t",arr[z]);
	}
}
int main()
{
	int arr[10]={2,5,4,6,1,3,9,7,8,0};
	selectSort1(arr,10);
	system("pause");
}

快速排序​​​​​​​

#include<stdio.h>
#include<stdlib.h>
void quickSort(int arr[],int left,int right){
        int l=left;
        int r=right;
        int base=arr[l];
        if(l>=r){
                return;
        }
		while(l<r){
			while(l<r){
				if(arr[r]>=base){
					r--;
				}else{
					arr[l]=arr[r];
					break;
				}
			}
			while(l<r){
				if(arr[l]<=base){
					l++;
				}else{
					arr[r]=arr[l];
					break;
				}
			}
		} 
        arr[l]=base;
        quickSort(arr,left,l-1);
        quickSort(arr,r+1,right);
}

void main(){
        int i;
        int arr[10]={34,5,6,22,56,88,11,2,4,0};
        quickSort(arr,0,9);
        for(i=0;i<10;i++){
                printf("%d\t",arr[i]);

        }
        system("pause");
}

希尔排序

#include<stdio.h>
#include<stdlib.h>

void shellSort(int arr[], int len){
	int gap;//步长
	int i,j,k;
	int temp;
	for(gap=len/2;gap>0;gap=gap/2){//步长分别为5，2，1
		for(i=0;i<gap;i++){//每个小组的第一个元素
			for(j=i+gap;j<len;j=j+gap){//插入排序，将待排序的元素拿出来，使其前面大于此元素的都向后移一位，然后在比他小的元素后面插入此元素
				temp=arr[j];
				k=j-gap;
				while(k>=0 && arr[k]>temp){
					arr[k+gap]=arr[k];
					k=k-gap;
				}
				arr[k+gap]=temp;
			}
		}
	}
}

void main()
{
    int i;
	int arr[10]={9,0,6,7,8,5,4,3,2,1};
    shellSort(arr, 10); 
    for (i = 0; i < 10; i++) { 
        printf("%d\t",arr[i]);
    }
    printf("\n");
	system("pause");
}

堆排序

#include<stdio.h>
#include<stdlib.h>
void adjustHeapSort(int a[],int root, int last)
{
	int child;
	int temp;
	while(2*root+1<=last){
		child=2*root+1;
		if(child+1<=last && a[child]<a[child+1]){
			child++;
		}
		if(a[child]>a[root]){
			temp=a[child];
			a[child]=a[root];
			a[root]=temp;
		}
		root=child;
	}
} 

void swap(int *a,int *b){
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}
void heap_sort(int a[], int len)
{
	int i;
	//第一个循环：构建一个大顶堆
	for(i=len/2-1;i>=0;i--){
		adjustHeapSort(a,i,len-1);
	}
	//第二个循环：将堆顶的元素和最后一个元素对换，调整大顶堆，一次循环
	for(i=len-1;i>0;i--){
		swap(&a[0],&a[i]);
		adjustHeapSort(a,0,i-1);
	}
}
void main()
{
	int i;
    int a[10] = {4,3,1,2,6,5,0,9,8,7};
    heap_sort(a, 10);
    for(i=0; i<10; i++){
		printf("%d ", a[i]);
    } 
    system("pause");
}

归并排序

void merge(int arr[],int tempArr[],int left,int mid,int right){
	//标记左半区第一个未排序的元素
	int l_pos=left;
	//标记右半区第一个未排序的元素
	int r_pos=mid+1;
	//临时数组元素的下标
	int pos=left;
	//合并
	while(l_pos<=mid && r_pos<=right){
		if(arr[l_pos]<arr[r_pos]){
			tempArr[pos++]=arr[l_pos++];
		}else{
			tempArr[pos++]=arr[r_pos++];
		}
	}
	//合并左半区剩余的元素
	while(l_pos<=mid){
		tempArr[pos++]=arr[l_pos++];
	}
	//合并右半区剩余的元素
	while(r_pos<=right){
		tempArr[pos++]=arr[r_pos++];
	}
	//把临时数组中合并后的元素复制回原来的数组
	while(left<=right){
		arr[left]=tempArr[left];
		left++;
	}
}

void msort(int arr[],int * tempArr,int left, int right)
{
	//如果只有一个元素，那么不用划分;只需要被归并
	if(left<right){
		int mid=(left+right)/2;
		//递归划分左半区
		msort(arr,tempArr,left,mid);
		//递归划分右半区
		msort(arr,tempArr,mid+1,right);
		//合并已经排序的部分
		merge(arr,tempArr,left,mid,right);
	}
} 

void mergeSort(int arr[], int len)
{
	//分配一个辅助数组
	int * tempArr=(int *)malloc(len*sizeof(int));
	if(tempArr!=NULL){
		msort(arr,tempArr,0,len-1);
		free(tempArr);
	}else{
		printf("空间分配失败！");
	}
}
void main()
{
	int i;
    int arr[10] = {4,3,1,2,6,5,0,9,8,7};
    mergeSort(arr, 10);
    for(i=0; i<10; i++){
		printf("%d ", arr[i]);
    } 
    system("pause");
}

看到刘仔请叫他去学习
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
冒泡排序和快速排序
cjydsg123的博客
08-23 430
排序算法中重要的两种排序
C语言排序算法冒泡排序
07-27
以下是对C语言冒泡排序的描述，不包含具体的代码实现： 基本思想：冒泡排序通过多次遍历待排序的元素，在每一轮遍历中比较相邻的两个元素，并根据需要交换它们的位置，使得较大（或较小）的元素逐渐“浮”到序列的...
排序算法C语言代码
dayslrk的博客
07-27 4222
常用算法排序C语言代码
常用的排序算法（C语言）
最新发布
weixin_63356609的博客
07-08 902
桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
八大排序算法—源代码(c语言)
Brant_zero的博客
07-15 3289
插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法的C语言实现。...
c语言排序算法_排序算法代码（C语言实现）
weixin_39880666的博客
11-29 143
冒泡排序基本思想：每次比较相邻元素，如果他们的顺序错误就把他们交换过来；#include冒泡排序运行结果快速排序基本思想：从数列中挑出一个元素，称为基准，重新排列数组，所有比基准值小的元素摆放在基准值前面，所有比基准值大的放在基准值后面（相同的数可以放到任意一边）。#include<stdio.h> #define N 10 int p[101]; void quick_sort(...
C语言“排序”代码
jiemuyumi的博客
03-17 1159
C语言数据结构“排序”代码 冒泡排序 快速排序 归并排序 直接插入排序 希尔排序 选择排序 堆排序 //初始条件：将一个一维数组从小到大排序 //输入：一个一维数组arr和它的长度n //输出：一个已经被排好序的数组 void bubblesort(int arr[],int n){ int temp; for(int j=n-1;j>0;j--){ for(int i=0;i<j;i++){ if(arr[i]>arr[i+1]){ temp=arr[i+1];
C语言排序算法之冒泡排序实现方法【改进版】
01-01
本文实例讲述了C语言排序算法之冒泡排序实现方法。分享给大家供大家参考，具体如下： 冒泡排序和改进的冒泡排序 /*------------------------------------------------------------------------------------------- ...
最快的排序算法 C语言最简单的排序算法冒泡排序并返回排序前索引序号，排序算法数据结构
04-07
在计算机科学中，排序算法是最基本也是最重要的算法之一。冒泡排序是一种简单的排序算法，它的主要思想是通过不断地比较相邻元素，并交换它们以达到排序的目的。在C语言中，冒泡排序的实现非常简单，下面我们将详细...
C语言排序算法之插入排序
01-20
算法实现： 使用插入排序将下面的数字按照从小到大的顺序排列 步骤1:数组中已经排好的是{1}，将9插入数组中 步骤2:数组中已经排好的是{2,9}，将5...程序代码： #include #include <stdlib> //插入排序 void Ins
C语言经典排序算法的完整代码
向上取整
09-07 3077
排序 1.插入排序 1.1直接插入排序 int insertSort(int array[],int n){ int i , j; int tempNum; for(i = 1; i < n;i++){ tempNum = array[i]; for(j = i - 1; j >= 0 && tempNum < array[j];j--){ array[j + 1] = array[j];
六种排序算法C语言实现源代码
07-02
冒泡排序、插入排序、归并排序、快速排序、希尔排序、选择排序的C语言实现源代码。内附注释说明。
C语言几种排序代码
07-07
包括有十种排序方法，有堆排序，归并排序，基排序，简单选择排序，快速排序，冒泡排序等等
c语言经典排序算法(8种-含源代码)
02-23
c语言学习资源，linux下c语言经典排序算法(8种-含源代码)
C语言排序代码
07-23
main(){int number[10];input(number);max_min(number);output(number);}input(number)int number[10];{int i;for(i=0;i<9;i++)　 scanf("%d,",&number;[i]);　 scanf("%d",&number;[9]);}max_min(array)int array[10];{int *max,*min,k,l;int *p,*arr_end;arr_end=array+10;max=min=array;for(p=array+1;p<arr_end;p++)　 if(*p>*max) max=p;　 else if(*p<*min) min=p;　 k=*max;　 l=*min;　 *p=array[0];array[0]=l;l=*p;　 *p=array[9];array[9]=k;k=*p;　 return;}output(array)int array[10];{ int *p;for(p=array;p<array+9;p++)　 printf("%d,",*p);printf("%d\n",array[9]);}
C语言排序算法（十种排序代码可跑
wangchengjiea的博客
09-08 2517
C语言排序算法（十种排序代码可跑）冒泡排序：选择排序：插入排序：归并排序：快速排序：希尔排序：堆排序：计数排序：桶排序：基数排序：以上就是所有代码，希望同学们好好学习！！！ 冒泡排序： #include<stdio.h> #include<stdlib.h> #include<time.h> #define N 10 void bubble_sort(int k[], int n) { int i, j, temp; for (i = 0; i < n -
2021-07-26
qq_46079830的博客
07-28 296
八大排序算法的各项比较以及各自的特点 一、八大排序算法的总体比较 二、算法各自的特点（具体实现见后面博客） 1.快排 （1）算法思想 选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序; （2）优缺点 优点：极快数据移动少； 缺点：不稳定； （3）效率分析 此排序算法的效率在序列...
C++ 排序
fhy19901014的专栏
08-28 453
#include using namespace std; //直接顺序排序 void InsertSort(int r[], int n) { for (int i=2; i<n; i++) { r[0]=r[i]; //设置哨兵 for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置
C语言归并排序（合并排序）算法及代码
weixin_30432179的博客
05-20 923
归并排序也称合并排序，其算法思想是将待排序序列分为两部分，依次对分得的两个部分再次使用归并排序，之后再对其进行合并。仅从算法思想上了解归并排序会觉得很抽象，接下来就以对序列A[0], A[l]…, A[n-1]进行升序排列来进行讲解，在此采用自顶向下的实现方法，操作步骤如下。(1)将所要进行的排序序列分为左右两个部分，如果要进行排序的序列的起始元素下标为first，最后一个元素的下标为last，那...
C语言详解：冒泡排序算法及其图像分析
本文主要介绍了C语言中的冒泡排序算法，一种基础但直观的排序方法。冒泡排序的基本思想是通过反复遍历待排序的序列，比较相邻元素并根据需要交换它们的位置，使得每一轮遍历后，序列中最大的元素都会“冒泡”到序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值