数据结构:排序算法之交换排序(冒泡排序、快速排序)

本文介绍了冒泡排序和快速排序的基本实现,并提出了两种排序算法的优化方案。对于冒泡排序,通过记录每次交换的位置来减少不必要的比较;对于快速排序,则采用三数取中法选择枢纽元并使用迭代而非递归的方式进行排序。

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

1、冒泡

void bubbleSort(int a[], int n){
	for(int i =0 ; i< n-1; ++i) {
		for(int j = 0; j < n-i-1; ++j) {
			if(a[j] > a[j+1])
			{
				int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
			}
		}
	}
}

/*1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
改进后算法如下:
*/
void Bubble_1 ( int r[], int n) {
	int i= n -1;  //初始时,最后位置保持不变
	while ( i> 0) { 
		int pos= 0; //每趟开始时,无记录交换
		for (int j= 0; j< i; j++)
			if (r[j]> r[j+1]) {
				pos= j; //记录交换的位置 
				int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
			} 
		i= pos; //为下一趟排序作准备
	 } 
}

/*2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。
改进后的算法实现为:
*/
void Bubble_2 ( int r[], int n){
	int low = 0; 
	int high= n -1; //设置变量的初始值
	int tmp,j;
	while (low < high) {
		for (j= low; j< high; ++j) //正向冒泡,找到最大者
			if (r[j]> r[j+1]) {
				tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
			} 
		--high;					//修改high值, 前移一位
		for ( j=high; j>low; --j) //反向冒泡,找到最小者
			if (r[j]<r[j-1]) {
				tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;
			}
		++low;					//修改low值,后移一位
	} 
}


2、快速排序

#include <iostream>
#include <stack>
using namespace std;


int GetKeyIndex(int array[], int left, int right)
{
	int mid = left + ((right - left)>>1);
	if(array[left] < array[right])
	{
		if(array[mid] < array[left])
			return left;
		if(array[mid] > array[right])
			return right;
		else
			return mid;
	}
	else
	{
		if(array[mid] < array[right])
			return right;
		else if(array[mid] > array[left])
			return left;
		else
			return mid;
	}
}
 


int partion(int array[], int left, int right)
{
	int begin = left;
	int end = right-1;
	//三个数取中间
	int keyIndex = GetKeyIndex(array, left, right);
	if(keyIndex != right)
	{
		std::swap(array[keyIndex], array[right]);
	}

	int key = array[right];

	while( begin < end )
	{
		while( begin < end && array[begin] <= key)
			begin++;

		while( begin < end && array[end] > key)
			end--;

		if(begin < end)
		{
			std::swap(array[begin], array[end]);
			begin++;
		}
	}
	if(begin != right && array[begin] > array [right])
	{
		swap(array[begin], array [right]);
		return begin;
	}
	return right;
}
 

void QuickSort(int array[], int left, int right)
{

	if(left < right)
	{
	   int div = partion(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}
 
 /*
 int partion2(int array[], int left, int right)
{
	int begin = left;
	int end = right;
	////三个数取中间
	//int keyIndex = GetKeyIndex(array, left, right);
	//if(keyIndex != right)
	//{
	//	std::swap(array[keyIndex], right);
	//}
	int key = array[right];

	while( begin < end )
	{
		while( begin < end && array[begin] <= key)
			begin++;
		std::swap(array[begin], array[end]);

		while( begin < end && array[end] > key)
			end--;
		std::swap(array[begin], array[end]);
	}
	return begin;
}
 

void QuickSort(int array[], int left, int right)
{

	if(left < right)
	{
	   int div = partion2(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

int partion3(int array[], int left, int right)
{
	int begin = left;
	int end = right;
	
	int key = array[left];

	while( begin < end )
	{

		while( begin < end && array[end] >= key)
			end--;
		if(begin < end)
		{
			array[begin] = array[end];
			begin++;
		}

		while( begin < end && array[begin] <= key)
			begin++;
		if(begin < end)
		{
			array[end] = array[begin];
			end--;
		}
	}
	array[begin] = key;
	return begin;
}


void QuickSort(int array[], int left, int right)
{
	if(left < right)
	{
	   int div = partion3(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

int partion4(int array[], int left, int right)
{
	int Cur = left;
	int Prev = Cur - 1;
	
	int key = array[right];
	while(Cur <= right)
	{
		if(array[Cur] < key && ++Prev != Cur)
			std::swap(array[Prev], array[Cur]);
		 ++Cur;
	}
	std::swap(array[++Prev], array[right]);
	return Prev;
}

void QuickSort(int array[], int left, int right)
{
	if(left < right)
	{
	   int div = partion4(array, left, right);
	   QuickSort(array, left, div - 1);
	   QuickSort(array, div + 1, right);
	}
}

void QuickSort_nor(int *array, int size)
{
	stack<int> s;
	s.push(size-1);
	s.push(0);
	while(!s.empty())
	{
		int left = s.top();
		s.pop();
		int right = s.top();
		s.pop();

		if(left < right)
		{
			int div = partion3(array, left, right);
			s.push(right);
			s.push(div +1);
			s.push(div -1);
			s.push(left);
		}

	}
}
*/ 


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值