排序1 O(nlogn)

nlogn的排序:堆排,快排,归并 

堆排序(英语:Heapsort)是指利用这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。 

	void adjustHeap(int a[], int i, int size)
	{
		//int max;
		int l = 2 * i + 1;
		int r = 2 * i + 2;
		int max = i;
		//vs 2017 会检测&&右边的,故不能将l < size&& a[l] > a[max]书写
		if (l < size) {
			if ( a[l] > a[max])
				max = l;
		}
		if (r < size) {
			if ( a[r] > a[max])
				max = r;
		}
		if (max != i)
		{
			::std::swap(a[i], a[max]);
			adjustHeap(a, max, size);
		}
	}

	void heapSort(int a[],int size)
	{
		for (int i = size / 2 - 1; i >=0; i--)
		{
			adjustHeap(a, i, size);
		}
		for (int i = size-1;i >= 0; i--)
		{
			swap(a[0], a[i]);
			adjustHeap(a, 0, i);
		}
	}

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法

它重复地走访过要排序的元素列,依次比较两个相邻的元素,如果他们的顺序(如从大到小、首字母从A到Z)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换,也就是说该元素列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列),就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样,故名“冒泡排序”。

 

	void bubbleSort(int a[], int size)
	{
		for (int i = 0; i < size - 1; i++)
		{
			for (int j = 0; j < size - i - 1; j++)
			{
				if (a[j] > a[j + 1])
					::std::swap(a[j + 1], a[j]);
			}
		}
	}

快速排序(Quicksort):通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

快速排序(Quicksort)是对冒泡排序的一种改进。

 

 

	int quickSortPart(int a[],int left,int right)
	{
		int temp = a[right];
		while (left<right)
		{
			while (left<right&&a[left]<temp )
			{
				left++;
			}
			a[right] = a[left];
			while (left < right&&a[right] >=temp)
			{
				right--;
			}
			a[left] = a[right];
		}
		a[right] = temp;
		return right;
	}
	void quickSort(int a[], int left, int right)
	{
		if (left<right)
		{
			int mid = quickSortPart(a, left, right);
			quickSort(a, left, mid - 1);
			quickSort(a, mid + 1, right);
		}
	}

 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并

void MergeData(int* arr, int left, int mid, int right, int* tmp) {
		int index = left;
		int p = left, q = mid;	 // 双指针遍历
		// 待排区间===[left , right)
		// 左有序区间[left, mid)         右有序区间[mid, right) 
		while (p < mid && q < right) {
			if (arr[p] <= arr[q]) {
				tmp[index++] = arr[p++];
			}
			else {
				tmp[index++] = arr[q++];
			}
		}
		while (p < mid) {
			tmp[index++] = arr[p++];
		}
		while (q < right) {
			tmp[index++] = arr[q++];
		}
		for (int i = left; i < right; i++) {
			// [left, right)内的数列已全部有序
			arr[i] = tmp[i];
		}
	}
	void _MergeSort(int* arr, int left, int right, int* tmp) {
		if (right - left > 1) {
			int mid = left + ((right - left) >> 1);
			// 1.排左区间
			_MergeSort(arr, left, mid, tmp);
			// 2.排右区间
			_MergeSort(arr, mid, right, tmp);
			// 3.归并
			MergeData(arr, left, mid, right, tmp);
		}
	}
	void MergeSort(int* arr, int size) {
		int* tmp = (int*)malloc(sizeof(int) * size);
		if (tmp == NULL) {
			cout<<"error"<<endl;
			return;
		}
		_MergeSort(arr, 0, size, tmp);
		free(tmp);
	}

 

### 快速排序算法的时间复杂度为 O(n log n) 的实现与分析 快速排序是一种基于分治法的高效排序算法,其核心思想是通过选取一个“枢纽元”(pivot),将待排序数组划分为两部分:一部分小于等于 pivot,另一部分大于等于 pivot。随后对这两部分递归调用快速排序。 #### 1. 快速排序的核心过程 快速排序的主要操作包括: - **选择枢纽元**:通常可以选择数组的第一个元素、最后一个元素或者中间位置的元素作为枢纽元。 - **划分数组**:将数组中小于等于枢纽元的部分放到左侧,大于枢纽元的部分放到右侧。 - **递归排序**:对左右两侧子数组分别重复上述过程,直到子数组长度为 1 或者为空为止。 以下是 Python 中的一个典型实现: ```python def quick_sort(arr): if len(arr) <= 1: return arr else: # 选择枢纽元 pivot = arr[len(arr) // 2] # 划分子数组 left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] # 递归排序并合并结果 return quick_sort(left) + middle + quick_sort(right) # 测试代码 arr = [3, 6, 8, 10, 1, 2, 1] print(quick_sort(arr)) ``` #### 2. 时间复杂度分析 快速排序的时间复杂度取决于分区过程中数组被分割的程度。具体来说: - **最好情况**:如果每次都能均匀地将数组分成大小相等的两半,则递推关系为 \(T(n) = 2T(n/2) + O(n)\),最终时间复杂度为 \(O(n \log n)\)[^3]。 - **最坏情况**:当分区极度不平衡时(例如每次都选最小或最大值作为枢纽元),则递推关系变为 \(T(n) = T(n-1) + O(n)\),此时时间复杂度退化至 \(O(n^2)\)[^4]。 - **平均情况**:假设枢纽元的选择较为随机,那么大多数情况下能够接近理想状态,因此平均时间复杂度仍为 \(O(n \log n)\)[^3]。 为了降低最坏情况发生的概率,实际应用中可以采用更优的策略来选择枢纽元,比如三数取中法(median-of-three method)[^2]。 #### 3. 空间复杂度 尽管快速排序是一个原地排序算法,但由于递归调用栈的存在,其空间复杂度主要由递归深度决定。在最优情况下,递归树的高度为 \(\log n\),对应的空间复杂度为 \(O(\log n)\);而在最差情况下,递归深度可能达到 \(n\) 层,从而导致空间复杂度上升到 \(O(n)\)[^2]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值