八大排序算法

最新推荐文章于 2022-05-22 10:15:59 发布
最新推荐文章于 2022-05-22 10:15:59 发布
阅读量870 收藏
点赞数
分类专栏： 笔记 文章标签： c++ c语言 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50539337/article/details/121448061
版权

1、排序算法分类
内排序（所有的数据都在内存上）
①冒泡排序
②选择排序
③直接插入排序
④希尔排序
⑤堆排序
⑥快速排序
⑦归并排序
⑧基数排序
外排序：借助磁盘空间（文件）来进行排序

①冒泡排序：
基本思想：将有待排序数据的相邻两个数据进行比较，将较大的数据放在后面，遍历一次后就可以将最大的数据放在最后面。结果n-1次遍历，整个数据序列就有序了。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

#include<stdio.h>
#include<stdlib.h>
void BulleSort(int *arr,int len)
{
    for(int i=0;i<len;i++)
    {
       
        for(int j=0;j<len-i-1;j++)
        {
            if(arr[j]>arr[j+1])
            {
                int tmp=0;
				tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
               
            }
        }
       
    }
	 printf("finsh soet\n");
	
}
int main()
{
   int arr[]={1,11,2,33,4,5,66};
   int len=sizeof(arr)/sizeof(int);
   for(int i=0;i<len;i++)
   {
	   printf("%d ",arr[i]);
   }
   printf("\n");
   BulleSort(arr,len);
   for(int i=0;i<len;i++)
   {
	   printf("%d ",arr[i]);
   }
   return 0;
}

②选择排序：
基本思想：每次从待排序中选出一个最小值放在起始位置，直至所有待排序列排完为止。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性;不稳定

#include<stdio.h>
#include<stdlib.h>
void SelectSort(int *arr,int len)
{
   for(int i=0;i<len;i++)
   {
	   int min=i;
	   for(int j=i+1;j<len;j++)
	   {
		   if(arr[j]<arr[min])
		   {
			   min=j;
		   }
	   }
	   int tmp=0;
	   tmp=arr[i];
	   arr[i]=arr[min];
	   arr[min]=tmp;
   }
   printf("\nfinsh sort\n");
    
}
 int main()
 {  
      int arr[]={1,11,2,33,4,5,66}; 
      int len=sizeof(arr)/sizeof(int);   
      for(int i=0;i<len;i++)  
       {	   
            printf("%d ",arr[i]); 
       }  
      SelectSort(arr,len);   
      for(int i=0;i<len;i++)  
       {	   
            printf("%d ",arr[i]); 
       }   
            return 0;
}

③直接插入排序
基本思想：将待排序序列看成两部分，左部分为有序，右部分为无序（第一次在部分只有一个数据）。循环从右部分拿出一个数据插入在部分。
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

#include<stdio.h>
#include<stdlib.h>
void SelectSort(int *arr,int len)
{
   for(int i=1;i<len;i++)
   {
	   int tmp=arr[i];
	   int j=i-1;
	   for( ;j>=0&&arr[j]>tmp;j--)
	   {
		   arr[j+1]=arr[j];
	   }
	   arr[j+1]=tmp;
   }
    printf("\nfinsh sort\n");
}
 int main()
 {  
      int arr[]={1,11,2,33,4,5,66}; 
      int len=sizeof(arr)/sizeof(int);   
      for(int i=0;i<len;i++)  
       {	   
            printf("%d ",arr[i]); 
       }  
      SelectSort(arr,len);   
      for(int i=0;i<len;i++)  
       {	   
            printf("%d ",arr[i]); 
       }   
            return 0;
}

④希尔排序
在这里插入图片描述
基本思想：先将待排序序列分成若干组，然后使用直接插入排序在组内排序。循环着将分组减到最小，执行以上过程，直到分组减为1。
希尔排序就是直接排序的优化，数据越有序，排序越快。
时间复杂度：时间复杂度是与增量序列相关的函数。 O(n^1.3~1.5)
空间复杂度：O(1)
稳定性：不稳定

#include<stdio.h>
ShellSort(int* arr,int len)
{
    int gap=len;
    while(gap>1)
    {
       gap=gap/2;
       int i=0;
       for(i=0;i<len-gap;i++)
       { 
           int end=i;
           int tmp=arr[gap+end];
           while(end>=0)
           {
               if(tmp<arr[end])
               {
                  arr[gap+end]=arr[end];
                  end-=gap;
               }
               else
               {
                   break;
               }
           }
        arr[end+gap]=tmp;
       }
    }
    printf("\nfinsh sort\n");
}
int main()
{ 
    int arr[]={11,2,4,1,99,89,45};
    int len=sizeof(arr)/sizeof(int);
    for(int i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
    ShellSort(arr,len);
    for(int i=0;i<len;i++)
    {
        printf("%d ",arr[i]);
    }
}

⑤堆排序
堆：堆通常是一个可以被看作一颗完全二叉数的数组对象。堆总是满足下列性质：
堆中某个结点的值总是不大于或不小于其父结点的值。
大根堆：每个子数的父结点都大于等于左、右孩子，
根是最大的。
小根堆：每个子数的父结点都小于等于其左、右孩子，根是最小的。
堆是一颗完全二叉树。
※完全二叉树的数组的储存性质
1、如果一个下标的结点为I,则其左孩子的下标为：2＊i+1，右孩子为：2＊i+2。
2、如果一个孩子的下标为i,则其父结点的下标的为：（i-1)/2。
基本思路：先将数组调整为大根堆。①从最后一颗子树开始调整。（len-2）/2 向上一颗子树调整（是-1的过程）。②每次调整过程都是从当前子数的根开始向下调整。
时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定

#include<stdio.h>

void Swap(int *a,int *b)
{
    int tmp=0;
    tmp=*a;
    *a=*b;
    *b=tmp;
}

void oneAdjust(int *arr,int len,int root)
{
	int tmp=arr[root];
	int i=root;
	int j=2*i+1;
	
	while(j<len)
	{
		if(j+1<len&&arr[j]<arr[j+1]) j++;//j为大孩子的下标

		if(arr[j]<tmp) break;

		arr[i]=arr[j];
		i=j;
		j=2*i+1;
	}
	arr[i]=tmp;
}

//O(nlogn)
void CreateHeap(int *arr,int len)
{
	int last_root=(len-2)/2;

	for(int i=last_root;i>=0;--i)
	{
		oneAdjust(arr,len,i);
	}
}

//O(nlogn)
void HeapSort(int *arr,int len)
{
	CreateHeap(arr,len);

	//O(nlogn)
	for(int i=0;i<len-1;++i)
	{
		Swap(&arr[0],&arr[len-1-i]);
		oneAdjust(arr,len-1-i,0);
	}
	printf("\nfinsh sort\n");
}

int main()
{
	int arr[]={11,1,2,4,3,7,90};
	int len=sizeof(arr)/sizeof(int);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	HeapSort(arr,len);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}

⑥快速排序
基本思想：任取带排序元素序列中的元素作为基准值，按照该基准值讲待排序列分为两子序列，左子系列中所有元素均小于基准值，右子序列中所有元素大于基准值，然后左右序列重复该过程，直到所有元素都排列在相应位置上为止。
时间复杂度：O(nlogn)
空间复杂度：O(logn)
稳定性：不稳定


#include<stdio.h>
#include<stdlib.h>
void Swap(int *a,int *b)
{ 
    int tmp=0;
    tmp=*a;
    *a=*b;
    *b=tmp;
}
void QuickSort(int *arr,int begin,int end)
{
     if(begin>=end)
    { 
       return;
    }
    int left=begin;
    int right=end;
    int key=left;
    while(left<right)
    {
         while(left<right&&arr[right]>=arr[key])
         {
             right--;
        }
  
        while(left<right&&arr[left]<=arr[key])
        {
            left++;
        }
        if(left<right)
        {
           Swap(&arr[left],&arr[right]);
        }
    }
    int meet=left;
    Swap(&arr[key],&arr[meet]);
    
    QuickSort(arr,begin,meet-1);
    QuickSort(arr,meet+1,end);
    
}
 int main()
 {  
      int arr[]={1,11,2,33,4,5,66}; 
      int len=sizeof(arr)/sizeof(int);   
      for(int i=0;i<len;i++)   
      {	   
            printf("%d ",arr[i]);  
      }  
      printf("\n");  
      QuickSort(arr,0,6);   
      for(int i=0;i<len;i++)  
      {	   
         printf("%d ",arr[i]); 
      }   
     return 0;
}

⑦归并排序
基本思想：将数据划分成不同的区间段（每个区间段已经有序），初始时，每个区间段只有一个数据。将相邻两个区间段合并到一块。重复这个过程，直到只剩下一个区间段。
时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定性：稳定

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

void Meger(int *arr, int len, int width, int *brr) //  width每个段的数据量个数
{
	int low1 = 0;
	int high1 = low1 + width - 1;
	int low2 = high1 + 1;
	int high2 = low2 + width - 1 < len - 1 ? low2 + width - 1 : len - 1;

	int index = 0;

	//  有两个归并段
	while(low2 < len)
	{
		// 两个段都有数据时
		while(low1 <= high1 && low2 <= high2)
		{
			if(arr[low1] < arr[low2])	brr[index++] = arr[low1++];
			else  brr[index++] = arr[low2++];
		}
		// 只剩下一个段有数据
		while(low1 <= high1) brr[index++] = arr[low1++];
		while(low2 <= high2) brr[index++] = arr[low2++];

		low1 = high2 + 1;
		high1 = low1 + width - 1;
		low2 = high1 + 1;
		high2 = low2 + width - 1 < len - 1 ? low2 + width - 1 : len - 1;
	}

	// 只有一个段的情况
	while(low1 < len)  brr[index++] = arr[low1++];

	for(int i = 0; i < len; ++i)
	{
		arr[i] = brr[i];
	}
}

void MegerSort(int *arr, int len)
{
	int *brr = (int*)malloc(sizeof(int) * len);
	if(brr == NULL) exit(0);

	for(int i = 1; i < len; i *= 2)
	{
		Meger(arr, len, i, brr);
	}

	free(brr);
	printf("\nfinsh sort\n");
}
int main()
{
	int arr[]={11,1,2,4,3,7,90};
	int len=sizeof(arr)/sizeof(int);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	MegerSort(arr,len);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}

⑧基数排序
基本思想：基数排序是针对有多个关键字（每个关键字的权重不同）的排序算法。
针对一组整形数据：按照权重划分（个位，十位，百位，千位…）。
按照从小权重到大权重进行处理。对于一个数据，拿到这一位的值，将原始数据存储到相应的队列中。一共有关键字取值范围的队列（1,2,3,4,5,6,7,8,9）。整个数据序列全部放入到队列后，按照队列顺序将其中的数据全部Pop出来，再放回到数组中。
基数排序数据之间不需要比较。
空间复杂度： O(dn) d是关键字的取值范围
时间复杂度： O(wn) w是关键字的个数
稳定性： 稳定

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

/*
   基数排序:

 */
/*
   队列的代码:
 */
typedef struct 
{
	int   *data;
	int   rear;
	int   head;
	int   size;
}Queue;

void InitQueue(Queue *que, int init_size)
{
	if(que == NULL)  exit(0);

	init_size = init_size > 0 ? init_size:10;
	que->data = (int*)malloc(sizeof(int) * init_size);

	if(que->data == NULL) exit(0);
	que->head = que->rear = 0;
	que->size = init_size;
}

void ClearQueue(Queue *que)
{
	if(que == NULL) exit(0);

	que->head = que->rear = 0;
}

void PushQue(Queue *que, int value)
{
	if(que == NULL) exit(0);

	if(que->rear == que->size) return;

	que->data[que->rear++] = value;
}

int EmptyQue(Queue *que)
{
	if(que == NULL)  exit(0);

	if(que->head == que->rear) return 1;

	return 0;
}

int PopQue(Queue *que)
{
	if(que == NULL) exit(0);

	if(EmptyQue(que))  return -1;

	int reval = que->data[que->head];

	que->head++;

	return reval;
}

void DestroyQue(Queue *que)
{
	if(que == NULL)  exit(0);

	free(que->data);
	que->data = NULL;

	que->head = que->rear = 0;
}

// 获取最大数的位数
int GetMaxWidth(int *arr, int len)
{
	int max_value = 0;

	for(int i = 0; i < len; ++i)
	{
		if(arr[i] > max_value)
		{
			max_value = arr[i];
		}
	}

	int width = 0;
	while(max_value)  //  1234  1234 % 10
	{
		width++;
		max_value /= 10;
	}

	return width;
}

//根据位数获取相应位上的值
int GetWidthValue(int value, int width)
{
	while(width)
	{
		if(value == 0) return 0;

		width--;
		value /= 10;
	}

	return value % 10;
}


void RadixSort(int *arr, int len)
{
	Queue  que[10];
	for(int i = 0; i < 10; ++i)
	{
		InitQueue(&que[i], len);
	}

	int max_width = GetMaxWidth(arr, len);

	for(int i = 0; i < max_width; ++i) // i==0  个位  i==1  十位
	{
		for(int j = 0; j < len; ++j) //  遍历整个待排序序列，按照i给定的位数将数据放到对应的队列中
		{
			int value = GetWidthValue(arr[j], i);
			PushQue(&que[value], arr[j]);
		}

		int index = 0;

		for(int k = 0; k < 10; ++k)  //  遍历所有的队列，按照顺序将队列中的数据全部输出
		{
			while(!EmptyQue(&que[k]))
			{
				arr[index++] = PopQue(&que[k]);
			}

			ClearQueue(&que[k]);
		}
	}

	for(int i = 0; i < 10; ++i)
	{
		DestroyQue(&que[i]);
	}
	printf("\nfinsh sort\n");
}
int main()
{
	int arr[]={11,1,2,4,3,7,90};
	int len=sizeof(arr)/sizeof(int);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	RadixSort(arr,len);
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}
小永。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法-8种排序算法
FREEDOM
06-05 331
排序算法总结 排序算法 平均时间复杂度 冒泡排序 O(n2) 选择排序 O(n2) 插入排序 O(n2) 希尔排序 O(n1.5) 快速排序 O(N*logN) 归并排序 O(N*logN) 堆排序 O(N*logN) 基数排序 O(d(n+r)) 一. 冒泡排序(BubbleSort) 基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。 过程： 比较相邻的两个数据，如果第二个数小，就交换位
数据结构基本八大排序算法
文景大大
03-04 1402
1.排序算法简介 　　由于待排序的记录数量不同，使得排序过程中涉及的存储器不同，可以将排序方法分为两大类：内部排序和外部排序。 　　内部排序：待排序记录存放在计算机的随机存储器（内存）中进行的排序过程。内部排序的方法很多，但就其全面性能而言，很难提出一种被认为最好的方法。每一种方法都有自己的优缺点，适合在不同的环境下使用（比如记录的初始排列状态等）。按照排序过程中依据的不同原则对内部排序大概可
八大基础排序算法
sclieshare的博客
07-20 302
八大基础排序算法冒泡排序选择排序插入排序快速排序归并排序希尔排序堆排序桶排序(基数排序) 稳定排序 前提:只有当在"二次"排序时不想破坏原先的次序,稳定性才有意义 概念:数据排序前后依然能保持相同数据的相对顺序 例子:对数组[3,3,1]进行选择排序算法进行排序,拿出最大的数3和最小的数1交换位置后变为[1,3,3],此时第一个3的下标本来是0,现在变成了2,排在了第二个3的后面.没有保持原先第一个3依旧保持在第二个3的前面的的相对顺序,这就是不稳定的排序 意义:如果我们只对一串数字排序,那么稳定与否确实不
Python实现八大排序算法
01-20
如何用Python实现八大排序算法 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定...
python八大排序算法速度实例对比
09-21
### Python八大排序算法速度实例对比 #### 排序算法概览 本文主要通过实例的方式对Python中的八大排序算法进行了速度对比。这些算法分别是：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、...
数据结构常见的八大排序算法（详细整理）
lgxzzz的博客
05-22 515
八大排序，三大查找是《数据结构》当中非常基础的知识点，在这里为了复习顺带总结了一下常见的八种排序算法。 常见的八大排序算法，他们之间关系如下： 排序算法.png 他们的性能比较： 性能比较.png 下面，利用Python分别将他们进行实现。 直接插入排序 算法思想： 直接插入排序.gif 直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。 因此，从上面的描述中我们
（巩固基础篇）排序算法：①插入排序②希尔排序③冒泡排序④选择排序⑤快速排序
一捆呆在ac篮子里的好葱，
07-08 763
排序算法：①插入排序②希尔排序③冒泡排序④选择排序⑤快速排序
Javascript排序算法（冒泡排序，选择排序，插入排序，归并排序，快速排序）
Museions的开心博客
06-07 1052
js排序算法 1.冒泡算法：比较任意两个相邻的项，如果第一个比第二个大，则交换顺序 /*冒泡排序*/ for (var i = 0; i < a.length; i++) { for (var j = i+1; j < a.length; j++) { if (a[j] < a[i]) { // var t = a[i]; // a[i] =
常见排序算法
zhang_jiayuan的博客
08-17 354
常见排序算法 排序问题作为算法基础的重要组成部分，代码实现方式多种多样，但其原理是基本一致的。常见的排序算法有： ①. 冒泡排序 ②. 选择排序 ③. 插入排序 ④. 归并排序 ⑥. 快速排序 ⑦. 堆排序 ⑧. 桶排序 ⑨. 基数排序 具体代码实现如下，均测试通过，如有错误，希指出。 冒泡排序 基本思想： * 设置外层循环次数 * 设置内层每一轮要比较的次数 * 两两比...
八大经典排序算法
热门推荐
weixin_43164548的博客
03-01 1万+
详细讲解了经典的排序算法的思路和实现过程
【数据结构与算法 11，互联网大厂面试必问的JVM底层原理
m0_61440508的博客
09-06 744
int min = arr[minIndex]; for(int j = 1 + i;j<arr.length;j++){ if(min > arr[j]){ min = arr[j]; minIndex = j; } } arr[minIndex] = arr[i]; arr[i] = min; } } 4、速度测试 选择排序：120000数...
七种经典的常见排序算法(选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、堆排序)
qq_39173601的博客
03-29 2019
目录写在前面参考源码1.选择排序特点算法步骤复杂度改进2.冒泡排序特点算法步骤复杂度最好情况最坏情况改进3.插入排序特点算法步骤复杂度最好情况改进4.希尔排序特点：算法步骤复杂度最好情况改进5.归并排序特点算法步骤复杂度改进6.快速排序特点算法步骤复杂度最坏情况7.堆排序特点算法步骤复杂度 写在前面 参考源码 花了小半周的时间来总结了常见的的排序算法，由于编程能力的欠缺，整理过程也是磕磕绊绊，好在最后bug都解决完了 本文主要写了七种常见排序算法：选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、
排序算法（一）（C语言实现）
weixin_45861045的博客
10-29 134
常用排序算法 一、冒泡排序 1.1：基本思想 相邻两两比较，较大的下沉，较小的上升 第一轮之后，最小的数就被放到第一个位置 1.2：优化 如果在进行到某趟排序时，已经排好了，则没有必要进行下一次排序。故可以使用flag标志来判断。 1.3：代码 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> void bubbleSort(int a[], int length) { int le
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值