排序算法

最新推荐文章于 2021-07-19 22:05:24 发布
最新推荐文章于 2021-07-19 22:05:24 发布
阅读量301 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bit666888/article/details/83419417
本文深入探讨了排序算法，包括其原理、实现方式以及应用场景。通过对不同排序算法的比较，帮助读者理解它们的效率和适用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

排序算法

#pragma once

void InsertSort(int* array, int size);//直接插入排序
void InsertSort_op(int* array, int size);//直接插入排序（嵌套二分查找）
void ShellSort(int* array, int size);//希尔排序
void Swap(int* pLeft, int* pRight);//交换
void SelectSort(int* array, int size);//选择排序
void SelectSort_op(int* array, int size);//选择排序优化
void Print(int* array, int size);//打印
void Test();//测试

#include "Sort.h"
#include <stdio.h>
#include <malloc.h>
#include <string.h>

//直接插入排序:比较次数多,每次比较O(N)
//          1.时间复杂度为 O((N-1)*N)=O(N^2)
//          2.空间复杂度为 O(1)
//          3.稳定性：稳定
//适用场景：1.接近有序，使得搬移的次数减少
//          2.元素个数较少
void InsertSort(int* array, int size)
{
	int i = 0;
	int end = 0;
	for (i=1; i < size; i++)
	{
		end = i - 1;
		int key = array[i];
		//搬移元素
		while (end >= 0 && key < array[end])
		{
			array[end + 1] = array[end];
			end--;
		}
		//插入
		array[end + 1] = key;
	}
}

//直接插入排序（嵌套二分查找）:比较次数减少 O(logN)
//              1.时间复杂度为：O((N-1)*logN)=O(NlogN)
//              2.空间复杂度为：O(1)
//              3.稳定性：稳定
void InsertSort_op(int* array, int size)
{
	int i = 0;
	for (i = 1; i < size; i++)
	{
		int end = i - 1;
		int left = 0;
		int right = end;
		int mid = 0;
		int key = array[i];
		//二分查找元素要插入的位置
		while (left <= right)
		{
			mid = left + ((right - left) >> 1);
			if (key < array[mid])
				right = mid - 1;
			else
				left = mid + 1;
		}
		//搬移元素
		while (end >=left)
		{
			array[end + 1] = array[end];
			end--;
		}
		//插入
		array[left] = key;
	}
}

//希尔排序:又称缩小增量排序，是对直接插入排序的优化
//         1.时间复杂度为：O(N^1.25)--O(1.6N^1.25) == O(N^1.3)
//         2.空间复杂度为：O(1)
//         3.稳定性：不稳定
//适用场景：1.顺序杂乱
//          2.元素个数较多
void ShellSort(int* array, int size)
{
	int i = 0;
	int gap = size;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (i = gap; i < size; i++)
		{
			int end = i - gap;
			int key = array[i];
			//搬移元素
			while (end >= 0 && key < array[end])
			{
				array[end + gap] = array[end];
				end -= gap;
			}
			//插入元素
			array[end + gap] = key;
		}
	}
}
//交换
void Swap(int* pLeft, int* pRight)
{
	int temp = *pLeft;
	*pLeft = *pRight;
	*pRight = temp;
}


//选择排序
void SelectSort(int* array, int size)
{
	int i = 0;
	int j = 0;
	int maxpos = 0;
	for (; i < size - 1; i++)
	{
		maxpos = 0;
		for (j = 1; j < size-i; j++)
		{
			if (array[maxpos] < array[j])
				maxpos = j;
		}
		if (maxpos != size - 1 - i)
			Swap(&array[maxpos], &array[size - 1 - i]);
	}
}

void SelectSort_op(int* array, int size)
{
	int i = 0;
	int begin = 0;
	int end = size - 1;
	int maxpos = 0;
	int minpos = 0;

	while (begin < end)
	{
		minpos = begin;
		maxpos = begin;
		i = begin + 1;
		while (i <= end)
		{
			if (array[maxpos] < array[i])
				maxpos = i;
			if (array[minpos]>array[i])
				minpos = i;
			i++;
		}
		
		if (minpos != begin)
			Swap(&array[minpos], &array[begin]);
		//9 2 3 7 6 5 4 8 0
		if (maxpos == begin)
			maxpos = minpos;
		if (maxpos != end)
			Swap(&array[maxpos], &array[end]);
		begin++;
		end--;
	}
}

//堆排序（大堆----升序）     （小堆----降序）
//此为大堆---> 升序
void AdjustDownHeap(int* array, int size,int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		//找左右孩子中最大的
		if (child+1<size && array[child + 1] > array[child])
			child += 1;
		//将最大的孩子节点和其双亲比较
		if (array[parent] < array[child])
		{
			Swap(&array[parent], &array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
	
}
//创建堆
void CreatHeap(int* array, int size)
{
	//找倒数第一个非叶子节点
	int root = (size - 2) >> 1;
	//递归调用向下调整
	for (; root >= 0; root--)
		AdjustDownHeap(array, size, root);
}

//快排：先排序后划分
//空间复杂度：O(logN)(一般情况下，它所开辟的空间相当于一棵二叉平衡树，所以空间复杂度=树的高度)
//稳定性：不稳定
//时间复杂度:
//如果每次取得基准值key刚好是该数组中的中间大小的值，则时间复杂度最好为O(NlogN) （划分了logN次，每次划分的时间为N）;
//但是，当数组有序或接近有序时，取得key就是最大或最小值，则时间复杂度最坏为O(N^2);
//所以，为了避免出现此种情况，影响快排的效率，给数组3个指针，取这三个数的中间值
int GetMidDataIndex(int* array, int left, int right)
{
	int mid = left + ((right - left) >> 1);
	if (array[left] < array[right])
	{
		if (array[mid] < array[left])
			return left;
		else if (array[mid]>array[right])
			return right;
		else
			return mid;
	}
	else//array[left]>array[right]
	{
		if (array[mid] > array[left])
			return left;
		else if (array[mid] < array[right])
			return right;
		else
			return mid;
	}
}
//1.hoare版本
//
int Partion(int* array, int left, int right)//key为基准，一般取数组最右边的值
{
	int keyIndex = GetMidDataIndex(array, left, right);
	if (keyIndex != right - 1)
		Swap(&array[keyIndex], &array[right - 1]);
		
	int key = array[right-1];

	int begin = left;
	int end = right - 1;
	
	while (begin < end)
	{
		while (begin < end && array[begin] <= key)
			begin++;
		while (begin < end && array[end] > key)
			end--;
		if (begin < end)
			Swap(&array[begin], &array[end]);
	}
	if (begin!=right-1)
		Swap(&array[begin], &array[right - 1]);
	return begin;
}
//快排的递归算法
void QuickSort(int* array,int left,int right)//区间是前闭后开[)
{
	if (right - left < 16)
		//如果数组中元素个数少，则采用插入排序效率高
		InsertSort(array, right - left);
	else
	{
		int div = Partion(array, left, right);
		QuickSort(array, left, div);
		QuickSort(array, div+1, right);
	}
}
//2.挖坑法
int Partion2(int* array, int left, int right)
{
	int keyIndex = GetMidDataIndex(array, left, right);
	if (keyIndex != right - 1)
		Swap(&array[keyIndex], &array[right - 1]);

	int key = array[right - 1];
	int begin = left;
	int end = right - 1;
	
	while (begin<end)
	{
		while (begin < end && array[begin] <= key)
			begin++;
		if (begin < end)
		{
			array[end] = array[begin];
			end--;
		}
		
		while (begin<end && array[end]>key)
			end--;
		if (begin < end)
		{
			array[begin] = array[end];
			begin++;
		}
	}
	if (begin != right - 1)
		array[begin] = key;
	
	return begin;
}
//3.前后指针法
int Partion3(int* array, int left, int right)
{
	int keyIndex = GetMidDataIndex(array, left, right);
	if (keyIndex != right - 1)
		Swap(&array[keyIndex], &array[right - 1]);

	int key = array[right - 1];
	int cur = left;
	int prev = cur - 1;
	
	while (cur<right)
	{
		while (array[cur] <= key && ++prev != cur)
			Swap(&array[cur], &array[prev]);
		cur++;
	}
	if (++prev != right)
		Swap(&array[prev], &array[right - 1]);

	return prev;
}

//归并排序：先划分后排序
//递归算法: 时间复杂度O(NlogN)  空间复杂度O(logN)   稳定性：稳定

//合并两个有序数组到新的数组中并且结果是有序的
void MergeData(int* array, int left, int mid, int right, int* temp)
{
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = right;
	int Index = 0;

	//合并两个有序数组到新的数组中并且结果是有序的
	while (begin1 < end1 && begin2 < end2)
	{
		if (array[begin1] <= array[begin2])
			temp[Index++] = array[begin1++];
		if (array[begin2] < array[begin1])
			temp[Index++] = array[begin2++];
	}

	while (begin1 < end1)
		temp[Index++] = array[begin1++];
	while (begin2 < end2)
		temp[Index++] = array[begin2++];
}

void _MergeSort(int* array, int left, int right,int* temp)
{
	if (right - left < 16)
		InsertSort(array, right - left);
	else
	{
		int mid = left + ((right - left) >> 1);
		_MergeSort(array, left, mid, temp);
		_MergeSort(array, mid+1, right, temp);
		MergeData(array, left, mid, right, temp);
		memcpy(array + left, temp, sizeof(array[0])*(right - left));
	}
}
void MergeSort(int* array, int size)
{
	int* temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp)
		return;

	_MergeSort(array, 0, size, temp);

	free(temp);
}
//非递归算法: 空间复杂度为O(N)   时间复杂度为O(NlogN)
//分析：先两两排序，再一组4个进行排序......
void MergeSort_op(int* array, int size)
{
	int gap = 1;
	int i;

	int* temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp)
		return;
	while (gap < size)
	{
		int left, right, mid;
		for (i = 0; i < size; i += 2 * gap)
		{
			left = i;
			mid = left + gap;
			if (mid > size)
				mid = size;
			right = mid + gap;
			if (right > size)
				right = size;

			//排序
			MergeData(array, left, mid, right, temp);
		}
		//拷贝回原空间
		memcpy(array, temp, sizeof(array[0])*size);
		//更新gap以2的倍数增长
		gap *= 2;
	}
	free(temp);
}

//C++版的归并排序：时间复杂度为O(NlogN),空间复杂度为O(N)
//利用归并的方法进行排序完成两个主要功能即可：拆分和合并
//拆分用到了比较好的方法就是利用快慢指针进行，每次找到链表的中间部分进行拆解
//合并可以利用两种方式：一种是非递归的方法另一种是递归的方法，都是可以做的
//这里用递归的方法，理解起来比较简单
#include <iostream>
using namespace std;

Definition for singly-linked list.
struct ListNode 
{
	int val;
	ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
	ListNode* MergeList(ListNode* list1, ListNode* list2)
	{
		if (list1 == NULL)
			return list2;
		if (list2 == NULL)
			return list1;
		ListNode *pHead = NULL;
		if (list1->val < list2->val)
		{
			pHead = list1;
			pHead->next = MergeList(list1->next, list2);
		}
		else
		{
			pHead = list2;
			pHead->next = MergeList(list2->next, list1);
		}
		return pHead;
	}

	ListNode* sortList(ListNode* head)
	{
		if (head == NULL || head->next == NULL)
			return head;
		ListNode* slow = head;
		ListNode* fast = head->next;
		while (fast && fast->next)
		{
			fast = fast->next->next;
			slow = slow->next;
		}
		ListNode* headb = slow->next;
		slow->next = NULL;
		return MergeList(sortList(head), sortList(headb));
	}
};


//非比较排序：
//一.计数排序
//步骤： 1：确定数据范围——分配空间
//       2：统计每个元素出现的次数
//       3：根据统计的结果将序列回收到原来的序列中
void CountSort(int* array, int size)
{
	int i = 0;
	int maxValue = array[0];
	int minValue = array[0];
	int Index = 0;
	int* pcount = NULL;
	//遍历数组得到数组的最大值和最小值
	for (i = 1; i < size; i++)
	{
		if (maxValue < array[i])
			maxValue = array[i];
		if (minValue > array[i])
			minValue = array[i];
	}
	//确定所要分配空间的大小
	int rang = maxValue - minValue + 1;
	pcount = (int*)malloc(sizeof(int)*rang);
	if (NULL == pcount)
		return;
	memset(pcount, 0, sizeof(int)*rang);//将新空间置0
	//统计每个元素出现的次数
	for (i = 0; i < size; i++)
	{
		pcount[array[i] - minValue]++;//?
	}
	//回收数据
	i = 0;
	while (i < rang)
	{
		while (pcount[i]--)
			array[Index++] = i + minValue;
		i++;
	}

	free(pcount);
}
//二.基数排序


//打印
void Print(int* array, int size)
{
	int i = 0;
	for (; i < size; i++)
	{
		printf("%d  ", array[i]);
	}
	printf("\n");
}
//测试
void Test()
{
	int array[] = { 9, 0, 4, 8, 7, 2, 3, 1, 6 ,5};
	int size = sizeof(array) / sizeof(array[0]);
	Print(array, size);
	/////*InsertSort(array, size);
	////Print(array, size);

	////InsertSort_op(array, size);
	////Print(array, size);*/

	////ShellSort(array, size);
	////Print(array, size);

	//SelectSort(array, size);
	//Print(array, size);

	/*SelectSort_op(array, size);
	Print(array, size);*/

	/*AdjustDownHeap(array, size, 0);
	Print(array, size);*/

	CountSort(array, size);
	Print(array, size);
}
排序算法——选择排序法
weixin_64534587的博客
07-13 834
选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是：在要排序的一组数中，选出最小（或最大）的一个数与第一个位置的数交换；然后在剩下的数当中再找最小（或最大）的与第二个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。所有过程都是从前向后依次找到最小（或最大）元素，而交换是跳跃式的。
快速排序法（详解）
热门推荐
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
经典排序算法
mist蒙的博客
03-20 260
冒泡排序 //关键代码 public static void sort(int array[]) { for (int i = 0; i < array.length - 1; i++) { boolean flag = false; for (int j = 0; j < array.length - 1 - i...
常见的排序算法
lipeng19930407的博客
02-09 267
今天计划整理一下常见的几种排序算法 冒泡法： 第p次冒泡，会在剩下的n-p个数字钟找到最小的min值，将其放在剩下的n-p个数字的最前面。 我的方法是找剩下中的最小值放到开头，而不是两个相邻值互相交换 代码如下： template void maopaosort(vector& a) { comparab tmp; int pos; for(int i=0
七种排序算法代码+总结（复试）
weixin_44072036的博客
04-08 212
排序！ 捋一遍最近学的排序算法 1.冒泡排序 最好时间复杂度：o（n） 平均时间复杂度: o（n^2） 最坏平均复杂度： o（n^2） 稳定 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 1010 int main() { int n; int ar...
排序算法及相关问题
m0_46141606的博客
07-19 338
排序算法 二级标题 List item 提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录排序算法二级标题前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为
常见排序算法原理及代码实现
01-05 749
排序算法 （一） 【冒泡排序】（Bubble Sort）   冒泡排序方法是最简单的排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见的经典排序算法有希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序、堆排序等。 一、希尔排序（Shell 排序法） 希尔排序法，又称宿小增量排序，是 1959 年由 D.L.Shell ...
堆排序算法详解：基于比较排序法的高效数据排列方法及其Java实现
最新发布
01-06
内容概要：本文档全面解析了堆排序这一基于比较的经典排序算法。文中详细解释了堆的概念及其特性，阐述了堆排序算法的两个关键步骤——建堆（Heapify）与排序，并提供了具体的 Java 实现代码。在建堆阶段，文档介绍...
排序算法（C语言）
u010689208的博客
03-27 221
1、冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的末尾。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样...
c语言的各类排序
qq_42321594的博客
10-27 672
黑体 null 排序的概念：1.排序就是将一组没有规律的数据按照一定的规律进行（升序/降序）排序。 2.一个元素数列如果两个元素A，B。如果在排序之前A在B的前面，在排序之后A依然在B的前面。那么我们就说这个排序算法是稳定的。 常见的排序算法： 插入排序：1.直接插入排序： 代码如下： ...
【c#】数组排序精选方法~
weixin_30488085的博客
06-18 188
2007-09-04 16:42 ★数组排序的几种方法！ 问题：数组排序（即按某种特定的顺序排列数据，如升序或降序）是最重要的计算应用之一，银行用帐号对所有的支票进行能够排序，并根据排序结果准备月底的财务报告，学校学生成绩管理系统用数组排序的方法将考试成绩从高到低进行排名，数组排序方法很多，有直接插入排序、冒泡排序、快速排序、直接选择排序，下面来详细介绍这四种基本的排序...
算法-排序（3）基础排序算法比较
04-16 941
排序的时间开销可用算法执行中的数据比较次数和数据移动次数来衡量。 不稳定的排序方法往往是按照一定的间隔移动或交换记录对象的位置，从而可能导致具有相等排序码的不同对象的前后相对位置在排序前后颠倒过来。 稳定的排序方法往往在相邻的数据对象间比较排序码，如果发生逆序才交换，具有相等排序码的不同对象在排序前后不会颠倒。 一、起泡排序算法 1.基础起泡排序算法 n-1次起泡，第i次起泡从...
Java实现各种排序
weixin_30539835的博客
08-25 76
No.1 QuickSort快排 void QuickSort(int[] l,int left,int right) { if(left<right) int pivotpos=partion(l,left,right); QuickSort(l,left,pivotpos-1); QuickSort(l,pivotpos+1,r...
南邮算法实验一：分治法
qq_45745047的博客
04-21 885
算法实验一： #include <iostream> #include <cstdlib> #include <ctime> using namespace std; void Swap(int& a, int& b) { int t = a; a = b; b = t; } template <class T> class SortableList { public: SortableList() {
【排序算法】快速排序的分析改进
Qregi的博客
03-19 9920
基本的快速排序最基本的快速排序是由C.A.R.Hoare在1960年提出的，快速排序的算法是一种分治排序算法它将数组划分为两个部分，然后分别对两个部分进行排序快速每次对数组重新排序，选择一个基准值key，然后让数组满足下面的两个个条件·a[l]， ... ，a[i - 1]之中的元素都比key值要小·a[i + 1], ... ,a[r]之中的元素都比key值要大然后通过划分来完成排序，递归的去处...
北京大学MOOC 算法基础第五周 分治算法 测试
帽帽的博客
10-14 1119
分治的基本概念： 把一个任务，分成形式和原任务相同，但规模更小的几个部分任务（通常是两个部分），分别完成，或只需要选一部完成。然后再处理完成后的这一个或几个部分的结果，实现整个任务的完成。 分治的典型应用：归并排序： 1） 把前一半排序 2)   把后一半排序 3)   把两半归并到一个新的有序数组，然后再拷贝回原数组，排序完成。 #include &lt;iostream&gt; us...
排序算法全解析：内部排序与计数排序法
第一部分，作者提到了以计数为基础的排序法，即ComparisonCountingSort。这种算法基于比较统计，通过计算每个元素小于其他元素的数量来确定其排序位置。然而，这种方法的效率低下，最佳和平均情况下的时间复杂度均为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值