• 35648

    文章

  • 23

    评论

  • 20

    友链

  • 最近新加了很多技术文章,大家多来逛逛吧~~~~
  • 喜欢这个网站的朋友可以加一下QQ群,我们一起交流技术。

排序算法 原

欢迎来到阿八个人博客网站。本 阿八个人博客 网站提供最新的站长新闻,各种互联网资讯。 喜欢本站的朋友可以收藏本站,或者加QQ:我们大家一起来交流技术! URL链接:https://www.abboke.com/jsh/2019/0725/102308.html

挑战A.I.,赢百万奖金......了解更多详情>>>

#define SIZE_OF_ARRAY(x) (sizeof(x) / sizeof(x[0]))

void swap(int &a,int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

#define OUT_PUT_DEBUG_ARRAY(x,len) do \
{\
	for (int i = 0; i < len; i++)\
	{\
		printf("%6d",x[i]);\
	}\
	printf("\r\n--------------------------\r\n");\
} while (0);


// 0.冒泡排序
// 从头开始,依次遍历所有元素,当遇到比当前元素小的,直接交换
void BubbleSort_Wrong(int *arr, int len)
{
	for (int i = 0; i < len - 1; ++i)
	{
		for (int j = i + 1; j < len; ++j)
		{
			if (arr[i] > arr[j])
			{
				swap(arr[i], arr[j]);
			}
		}
	}
}

void BubbleSort_Right(int *arr, int len)
{
	for (int i = 0; i < len - 1; ++i)
	{
		int nMax = arr[i];
		for (int j = 0; j < len - 1 - i; ++j)
		{
			if (arr[j + 1] > arr[j])
			{
				swap(arr[j + 1], arr[j]);
			}
		}
	}
}

// 1.选择排序
// 从头开始,依次遍历所有元素,找出当前坐标到结尾最小的元素,进行交换
// 思想与冒泡排序差不多,只不过交换放到了循环外,减少了交换次数
void SelectSort(int *arr, int len)
{
	for (int i = 0;i < len - 1;++i)
	{
		int k = i;
		for (int j = i + 1;j < len;++j)
		{
			//if (arr[i] > arr[j]) -- 此处错误,多谢指正@_@ @tuohaohu
			if (arr[k] > arr[j])
			{
				k = j;
			}
		}
		if (i != k)
		{
			swap(arr[i], arr[k]);
		}	
	}
}

// 2.插入排序
// 总所周知,当只有一个元素时,待排数据为有序数据
// 假定数组arr[n],当 0 < k < n时,a[0]~a[k-1]有序,a[k]~a[n-1]无序
// 此时,将arr[k]拿出来,将arr[0]~arr[k-1]从k-1开始往左遍历,如果a[j] > a[k],则将a[j]左移,指导a[j] < a[k],此时将a[k]放到a[j+1],arr[0]~arr[k]变为有序序列
// 当遍历晚arr[n]时,此时数据将为有序序列
void InsertSort(int *arr, int len)
{
	if (len <= 1)
	{
		return;
	}

	for (int i = 1; i < len;++i)
	{
		int tmp = arr[i];
		for (int j = i - 1;j >= 0;--j)
		{
			if (arr[j] >= tmp)
			{
				arr[j + 1] = arr[j];
			}
			else
			{
				arr[j + 1] = tmp;
				break;
			}
		}
	}
}


// 3.二分插入排序
// 因为直接插入排序在搜索插入位置的时候,效率很低,对于大数组,尤其不适用
// 于是采用二分插入排序,又叫折半插入排序, 二分插入排序是采用折半查找法寻找要插入的位置 
// 二分搜索:
void  BinaryInsertSort(int *arr, int len)
{
	for (int i = 1; i < len; ++i)
	{
		int tmp = arr[i];
		int iHigh = i - 1;
		int iLow  = 0;
		int iMid = 0;
		while (iLow <= iHigh)
		{
			iMid = (iLow + iHigh) / 2;
			if (tmp > arr[iMid] )
			{
				iLow = iMid + 1;
			}
			else
			{
				iHigh = iMid - 1;
			}
		}

		// 将 iMid 到 i 的数据左移
		for (int j = i; j > iMid; --j)
		{
			arr[j] = arr[j - 1];
		}
		arr[iLow] = tmp;
	}
}

// 4.归并排序
// 将待排序数据,从中间分为2段A和B,使A和B分别有序后,再将A和B使用插入排序
// 退出条件为
void MergeSort(int *arr, int beg,int end)
{
	//OUT_PUT_DEBUG_ARRAY(&arr[beg], end - beg);
	if (beg >= end)
	{
		return;
	}

	if (beg == end - 1)
	{
		if (arr[beg] > arr[beg + 1])
		{
			swap(arr[beg], arr[beg + 1]);
		}	
		return;
	}

	// 将beg到end分为2段A和B,并将A和B分别使用归并排序
	int iL1 = beg;
	int iH1 = (beg + end) / 2;
	int iL2 = iH1 + 1;
	int iH2 = end;
	MergeSort(arr, iL1, iH1);
	MergeSort(arr, iL2, iH2);
	
	// 将A 和 B 排序完毕后,合并A和B——使用插入排序 
	for (int i = iL2; i <= iH2; ++i)
	{
		int tmp = arr[i];
		for (int j = iH1 + i - iL2; j >= iL1; --j)
		{
			arr[j + 1] = arr[j];
			if (tmp > arr[j])
			{
				arr[j + 1] = tmp;
				break;
			}
		}
	}
}

// 5.快速排序
// 1.以左右两端i和j为起点,从右往左开始,找到比最左端小的数,停止坐标记为A,从左往右找到比最左端大的数,停止坐标记为A。交换A和B标记的数。
// 2.重复第一点,直到A == B,将此事的坐标所标识的值与最开始的数据交换。记此时的坐标为K
// 3.分别对 i~K-1 与 K+1 ~ j 重复上诉1、2两点
void quickSort(int *arr, int left, int right)
{
	if (left > right)
	{
		return;
	}

	int tmp = arr[left];
	int iLeft = left;
	int iRight = right;
	while (left != right)
	{
		while (right > left && (arr[right] >= tmp))
		{
			right--;
		}
		while (right > left && (arr[left] <= tmp))
		{
			left++;
		}
		if (left < right)
		{
			swap(arr[left], arr[right]);
		}		
	}

	
	arr[iLeft] = arr[left];
	arr[left] = tmp;

	quickSort(arr, iLeft, left - 1);
	quickSort(arr, left + 1, iRight);
}

 

相关文章

暂住......别动,不想说点什么吗?
  • 全部评论(0
    还没有评论,快来抢沙发吧!