内部排序

最新推荐文章于 2024-09-21 22:51:29 发布

张小张00

最新推荐文章于 2024-09-21 22:51:29 发布

阅读量748

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/zj20320/article/details/52267041

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

内部排序：是指在排序期间元素全部存放在内存中的排序（本节例中所有排序均为升序排序）

外部排序：是指在排序期间

一、插入排序

1、直接插入排序：每次将一个待排序的记录，按其关键字的大小插入到前面已经排好序的子序列中，直到全部记录插入完成。代码如下：

void InsertSort(int A[],int n)
{
	for(int i=2;i<n;i++)
	{
		if(A[i]<A[i-1])
		{
			A[0]=A[i];
			int j;
			for(j=i-1;A[0]<A[j];j--)
				A[j+1]=A[j];
			A[j+1]=A[0];
		}
	}
}

2、希尔排序：先将待排序表分割成若干个形如L[i,i+d,i+2d,…,i+kd]的“特殊”子表，分别进行直接插入排序，当整个表中元素已呈“基本有序”时，再对全体记录进行一次直接插入排序。

目前为止尚未求得一个最好的增量序列，希尔提出的方法是d(1)=n/2,d(i+1)=d(i)/2。

希尔排序和直接插入排序的区别有以下：

a、前后记录位置的增量是k，不是1

b、A[0]只是暂存单元，不是哨兵，当j<0时，插入位置已到

代码如下：

void ShellSort(int A[],int n)
{
	for(int k=n/2;k>0;k=k/2)//增量序列
	{
		//将A[i]插入到有序增量子表中
		for(int i=k+1;i<n;i++)
		{
			if(A[i]<A[i-k])
			{
				A[0]=A[i];//暂存
				int j;
				for(j=i-k;j>0&&A[0]<A[j];j-=k)
					A[j+k]=A[j];
				A[j+k]=A[0];
			}
		}
	}
}

二、交换排序

1、冒泡排序：假设待排序列表长为n，从后往前（或从前往后）两两比较相邻元素值，若为逆序则交换，直到序列比较完，这是一趟冒泡排序，结果将最小的元素交换到待排序列的第一个位置。下一趟排序时，前一趟最小元素不再参与比较，待排序列减少一个元素。直到一趟排序完成没有任何元素进行了交换，算法终止。代码如下：

void BubbleSort(int A[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		bool flag=false;//记录一趟排序是否有元素交换
		for(int j=n-1;j>i;j--)//一趟冒泡排序
		{
			if(A[j]<A[j-1])//需要交换
			{
				int temp=A[j];
				A[j]=A[j-1];
				A[j-1]=temp;
				flag=true;
			}
		}
		if(!flag)
			return;
	}
}

2、快速排序：基于分治法，在待排序列L[1…n]中任取一个元素pivot作为基准，通过一趟排序将待排序表划分成独立两部分L[1…k-1]和L[k+1…n]，使得L[1…k-1]中所有元素小于等于pivot，L[k+1…n]中所有元素大于等于pivot，则pivot放在了其最终位置L(k)上，这个过程为一趟快速排序。代码如下：

//方法一：两个下标分别从首、尾向中间扫描
int Partition(int A[],int low,int high)
{
	int pivot=A[low];//以当前表的第一个值作为枢轴值，对表进行划分
	while(low<high)
	{
		while(low<high&&A[high]>=pivot) high--;
		A[low]=A[high];
		while(low<high&&A[low]<=pivot) low++;
		A[high]=A[low];
	}
	A[high]=pivot;
	return low;//返回存放枢轴的最终位置
}

//方法二：两个指针索引一前一后逐步向后扫描
int Partition(int A[],int low,int high)
{
	int pivot=A[high];
	int i=low-1;
	int temp;
	//从前向后
	for(int j=low;j<high;j++)
	{
		//A[i]待交换的位置,A[j]找到比pivot小的值放置A[i]处
		if(A[j]<=pivot)
		{
			i++;
			temp=A[i];
			A[i]=A[j];
			A[j]=temp;
		}
	}
	i+=1;
	temp=A[high];
	A[high]=A[i];
	A[i]=temp;
	return i;//A[low…i-1]的相对位置不变
}

void QuickSort(int A[],int low,int high)
{
	if(low<high)
	{
		int pivotpos=Partition(A,low,high);
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}

三、选择排序

1、简单选择排序：第1趟在后边的n个待排序元素（A[0]~A[n-1]）中选取关键字最小的元素，作为有序子序列的第1个（A[0]）个元素，然后后边的每一趟都减少一个元素，即上一趟中挑选出的最小元素，在后边剩下元素中选取最小元素。直到第n-1趟完成，待排序元素只剩下1个元素就不用再选了。代码如下：

void SelectSort(int A[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		int min=i;
		for(int j=i+1;j<n;j++)
			if(A[min]>A[j]) min=j;
		if(min!=i)
		{
			int temp=A[min];
			A[min]=A[i];
			A[i]=temp;
		}
	}
}

2、堆排序

堆的定义如下：n个关键字序列L[1…n]称为堆，当且仅当序列满足：1<=i<=n/2

（1）L[i]<=L[2i] 且 L[i]<=L[2i+1] --小根堆

（2）L[i]>=L[2i] 且 L[i]>=L[2i+1] --大根堆
构造初始堆：从最后一个非叶子结点起n/2，对当前子树进行筛选，使该子树称为堆。之后依次向前对各结点为根的子树进行筛选，交换后可能会破坏下一级堆，于是继续采用相同方法构造下一级堆，直至该结点的子树构成对为止（向下调整）。反复利用以上筛选直到根结点。

堆排序：通常输出堆顶元素后，将堆底元素送入堆顶，此时根结点不满足性质，将堆顶元素向下调整使其保持堆的性质（向下调整）。

堆插入：先将新结点放在堆的末端，再对这个新结点执行向上调整操作。

所以，堆最重要的操作就是向上调整（AdjustUp）和向下调整（AdjustDown）。代码如下：

//构建一棵大根堆
void BuildMaxHeap(int A[],int len)
{
	for(int i=len/2;i>=1;i--)//从最后一个非叶子结点开始
		AdjustDown(A,i,len);
}

//对非叶子结点i向下调整
void AdjustDown(int A[],int k,int len)
{
	A[0]=A[k];//暂存
	for(int i=2*k;i<=len;i=i*2)//沿较大的子结点向下筛选
	{
		//根为A[k]，子结点较大者为A[i]
		if(i<len&&A[i]<A[i+1])//选择较大的子结点与根结点替换并向下筛选
			i++;
		if(A[0]>=A[k])//满足大根堆的条件,终止向下筛选
			break;
		else
		{
			A[k]=A[i];
			k=i;
		}
	}
	A[k]=A[0];
}

//参数k为向上调整的结点，也是堆的元素个数
void AdjustUp(int A[],int k)
{
	A[0]=A[k];
	int i=k/2;
	while(i>0&&A[i]>=A[0])//根结点大于子结点满足大根堆性质跳出循环
	{
		//继续向上调整
		A[k]=A[i];
		k=i;
		i=i/2;
	}
	A[k]=A[0];//最终位置
}

void HeapSort(int A[],int len)
{
	BuildMaxHeap(A,len);//构造大根堆
	for(int i=len;i>1;i--)
	{
		//输出堆顶元素并和堆底元素交换
		cout<<A[1]<<" ";
		return;
		//令根结点为最大叶子结点
		A[1]=A[i];
		AdjustDown(A,1,i-1);
	}
}

四、归并排序

二路归并排序：假定待排序表含有n个记录，则可以视为n个有序的子表，每个子表长度为1，然后两两合并，得到n/2个长度为2或为1的有序表，再两两合并…如此重复，直至合并成一个长度为n的有序表。代码如下：

void MergeSort(int A[],int low,int high)
{
	if(low<high)
	{
		int mid=(low+high)/2;//从中间划分两个子序列
		MergeSort(A,low,mid);//对左侧子序列进行递归排序
		MergeSort(A,mid+1,high);//对右侧子序列进行递归排序
		Merge(A,low,mid,high);//将前后相邻的两个有序表归并为一个有序表，需要一个辅助数组
	}
}

关于Merge()函数有两种方法：

第一种：使用一个辅助数组brr[]保存原数组的内容

//使用一个辅助数组brr[]保存原数组的内容
void Merge(int arr[],int low,int mid,int high)
{
	int i,j,k;
	int *brr=(int *)malloc(SIZE*sizeof(int));
	for(i=low;i<=high;i++)
		brr[i]=arr[i];
	for(i=low,j=mid+1,k=low;i<=mid&&j<=high;)
	{
		if(brr[i]<=brr[j])
			arr[k++]=brr[i++];
		else 
			arr[k++]=brr[j++];
	}
	while(i<=mid)
		arr[k++]=brr[i++];
	while(j<=high)
		arr[k++]=brr[j++];
	free(brr);
}

第二种：原地归并排序，不需要辅助数组。

//将数组长度为n的逆序
void reverse(int arr[],int n)
{
	int i=0,j=n-1;
	while(i<j)
	{
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
		i++;j--;
	}
}

//将含有n个元素的数组向左循环移位i个位置
void exchange(int arr[],int n,int i)
{
	reverse(arr,i);
	reverse(arr+i,n-i);
	reverse(arr,n);
}

//原地归并排序，不需要辅助数组
void Merge(int arr[],int low,int mid,int high)
{
	int i=low,j=mid+1,k=high;
	while(i<j&&j<=k)
	{
		int step=0;
		while(i<j&&arr[i]<=arr[j])
			i++;
		while(j<=k&&arr[i]>=arr[j])
		{
			j++;
			step++;
		}
		exchange(arr+i,j-i,j-i-step);
		i=i+step;
	}
}

多路归并排序：对于大文件的排序，待排序列的记录存储在外部存储器上，待排序列无法存入内存，需要在内存和外存之间进行多次数据交换，以达到整个文件的目的。多路归并排序可以将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存完成排序，然后对已排好序的子文件进行归并排序。但在k个归并段中选取最小的记录需要比较次数为k-1，为了降低选出每个记录需要比较次数，引入“败者树”的概念。

算法比较：

在初始序列基本有序时，插入排序最优，其次是冒泡排序，最差的是快速排序。

其中插入和冒泡是因为，如初始序列：123456798

冒泡需要第二趟遍历发现没有元素交换才判断已经有序了。

算法种类	最好情况	平均情况	最坏情况	空间复杂度	是否稳定
直接插入排序	O(n)	O(n*n)	O(n*n)	O(1)	是
冒泡排序	O(n)	O(n*n)	O(n*n)	O(1)	是
简单选择排序	O(n*n)	O(n*n)	O(n*n)	O(1)	否
希尔排序				O(1)	否
快速排序	O(nlongn)	O(nlongn)	O(n*n)	O(1)	否
堆排序	O(nlongn)	O(nlongn)	O(nlongn)	O(1)	否
二路归并排序	O(nlongn)	O(nlongn)	O(nlongn)	O(n)	是