排序

最新推荐文章于 2024-12-13 15:13:27 发布

Xu_Haocan

最新推荐文章于 2024-12-13 15:13:27 发布

阅读量224

点赞数

分类专栏： C++基础

本文链接：https://blog.youkuaiyun.com/Xu_Haocan/article/details/89156680

版权

C++基础专栏收录该内容

21 篇文章

订阅专栏

本文详细介绍了冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序和堆排序这七种经典的排序算法，包括它们的基本思想、时间复杂度及示例代码。这些算法都是从大到小进行排序，适用于不同场景的数据排列需求。

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

注：以下所有排序方法均为从下到大排序

冒泡排序

两两比较，若第i个数据比第i+1个数据大，则交换，一次遍历后最大的数据就到了最后一位；
时间复杂度为O(n^2)；
代码

//容器
//从小到大排序
template <typename T>
void sortVector(vector<T>& data)
{
	int dataSize = data.size();
	for (int i = 0; i < dataSize ; i++)
	{
		for (int j = 0; j < dataSize -  i - 1; j++)
		{
			if (data[j] > data[j + 1])
			{
				T temp;
				temp = data[j + 1];
				data[j + 1] = data[j];
				data[j] = temp;
			}
		}
	}
}

//动态数组
//从小到大排序
template<typename T>
void BubbleSort(T *elements, int n)
{
    //bool exchange = true;
    //for (int i=0; i<n && exchange; i++)
    for (int i=0; i<n; i++)
    {
        //exchange = false;
        for (int j=n-1; j>i; j--)
        {
            if (elements[j] < elements[j-1])
            {
                T temp = elements[j];
                elements[j] = elements[j - 1];
                elements[j - 1] = temp;
                //exchange = true;
            }
        }
    }
}

选择排序

遍历，找到最下的数，和第一位交换；
时间复杂度为O(n^2)；
代码

// 选择排序
void SelectionSort(int arr[], int length)
{
	for (int i = 0; i < length; i++)
	{
		int index = i;
		for (int j = i+1; j < length; j++)
		{
			if (arr[j] < arr[index])
			{
				index = j;
			}
		}
		if (index == i)
			continue;
		else
		{
			int temp;
			temp = arr[index];
			arr[index] = arr[i];
			arr[i] = temp;
		}
	}
}

插入排序

基本思想为将无序序列插入到有序序列中；
例如，arr=[4,2,8,0,5,1]，可以认为4是有序序列，2,8,0,5,1无序序列
2<4，所以，2,4为有序序列，8,0,5,1为无序序列
8>4，所以，2,4,8为有序序列，0,5,1为无序序列
……
时间复杂度为O(n^2)；
代码

// 插入排序
void InsertSort(int arr[], int length)
{
	for (int i = 1; i < length; i++)
	{
		int j;
		if (arr[i] < arr[i - 1])
		{
			int temp = arr[i];
			for (j = i - 1; j >= 0 && temp < arr[j]; j--)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

希尔排序

插入排序的优化版本；
先将待排记录序列分割成为若干子序列分别进行插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行一次直接插入排序；
代码

// 希尔排序
void ShellSort(int arr[], int length)
{
	int increasement = length;
	int i, j, k;
	do
	{
		// 确定分组的增量
		increasement = increasement / 3 + 1;
		for (i = 0; i < increasement; i++)
		{
			for (j = i + increasement; j < length; j += increasement)
			{
				if (arr[j] < arr[j - increasement])
				{
					int temp = arr[j];
					for (k = j - increasement; k >= 0 && temp < arr[k]; k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}

快速排序

基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序；
具体做法为：设置两个指针low和high分别指向待排序列的开始和结尾，记录下基准值baseval(待排序列的第一个记录)，然后先从high所指的位置向前搜索直到找到一个小于baseval的记录并互相交换，接着从low所指向的位置向后搜索直到找到一个大于baseval的记录并互相交换，重复这两个步骤直到low=high为止；
代码

int PartSort(int* arr, int left, int right)
{
	int key = arr[right];
	while (left < right)
	{
		while (left < right && arr[left] <= key)
		{
			++left;
		}
		swap(arr[left], arr[right]);
		while (left < right && arr[right] > key)
		{
			--right;
		}
		if (arr[left] != arr[right])
		{
			swap(arr[left], arr[right]);
		}
	}
	arr[left] = key;
	return left;
}

void QuickSort(int* arr, int left, int right)
{
	assert(arr);
	if (left < right)
	{
		int div = PartSort(arr, left, right);
		QuickSort(arr, left, div - 1);
		QuickSort(arr, div + 1, right);
	}
}

归并排序

将两个或两个以上的有序序列组合成一个新的有序表。假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并；
代码

// 归并排序
void MergeSort(int arr[], int start, int end, int * temp)
{
	if (start >= end)
		return;
	int mid = (start + end) / 2;
	MergeSort(arr, start, mid, temp);
	MergeSort(arr, mid + 1, end, temp);
 
	// 合并两个有序序列
	int length = 0; // 表示辅助空间有多少个元素
	int i_start = start;
	int i_end = mid;
	int j_start = mid + 1;
	int j_end = end;
	while (i_start <= i_end && j_start <= j_end)
	{
		if (arr[i_start] < arr[j_start])
		{
			temp[length] = arr[i_start]; 
			length++;
			i_start++;
		}
		else
		{
			temp[length] = arr[j_start];
			length++;
			j_start++;
		}
	}
	while (i_start <= i_end)
	{
		temp[length] = arr[i_start];
		i_start++;
		length++;
	}
	while (j_start <= j_end)
	{
		temp[length] = arr[j_start];
		length++;
		j_start++;
	}
	// 把辅助空间的数据放到原空间
	for (int i = 0; i < length; i++)
	{
		arr[start + i] = temp[i];
	}
}

堆排序

每个结点的值都大于等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于等于其左右孩子结点的值，称为小顶堆；
堆排序(Heap Sort)是利用堆进行排序的方法。其基本思想为：将待排序列构造成一个大顶堆(或小顶堆)，整个序列的最大值(或最小值)就是堆顶的根结点，将根节点的值和堆数组的末尾元素交换，此时末尾元素就是最大值(或最小值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值(或次小值)，如此反复执行，最终得到一个有序序列；
代码

/*
	@param arr 待调整的数组
	@param i 待调整的结点的下标
	@param length 数组的长度
*/
void HeapAdjust(int arr[], int i, int length)
{
	// 调整i位置的结点
	// 先保存当前结点的下标
	int max = i;
	// 当前结点左右孩子结点的下标
	int lchild = i * 2 + 1;
	int rchild = i * 2 + 2;
	if (lchild < length && arr[lchild] > arr[max])
	{
		max = lchild;
	}
	if (rchild < length && arr[rchild] > arr[max])
	{
		max = rchild;
	}
	// 若i处的值比其左右孩子结点的值小，就将其和最大值进行交换
	if (max != i)
	{
		int temp;
		temp = arr[i];
		arr[i] = arr[max];
		arr[max] = temp;
		// 递归
		HeapAdjust(arr, max, length);
	}
}
 
// 堆排序
void HeapSort(int arr[], int length)
{
	// 初始化堆
	// length / 2 - 1是二叉树中最后一个非叶子结点的序号
	for (int i = length / 2 - 1; i >= 0; i--)
	{
		HeapAdjust(arr, i, length);
	}
	// 交换堆顶元素和最后一个元素
	for (int i = length - 1; i >= 0; i--)
	{
		int temp;
		temp = arr[i];
		arr[i] = arr[0];
		arr[0] = temp;
		HeapAdjust(arr, 0, i);
	}
}