数据结构简记--8

第 8 章 排序

8.1 外部排序

        外部排序是一种处理大型数据集的排序技术。当内存不足以容纳整个数据集时，就需要用到外部排序。这通常发生在需要对超过内存限制的数据进行排序的情况下，例如对数千万个记录进行排序。外部排序使用硬盘来存储和排序数据，因为硬盘容量通常比内存大得多。

        外部排序的主要步骤包括将数据拆分成多个磁盘块，将每个块读入内存并在内存中进行排序，然后将排序后的块合并成单个排好序的文件。这个过程通常需要多次读写磁盘，因此会导致显著的I/O开销。为了最小化I/O开销，外部排序算法通常会使用合并排序、快速排序、堆排序和归并排序等常用的排序算法

8.2 基数排序

        基数排序是一种非比较排序算法，它将待排序的数据按照每位数字的大小依次比较，从低位到高位进行排序。基数排序通常适用于数字较小的数据集，特别是适用于具有相同位数的数据集。由于基数排序的时间复杂度为 O(n*k)，其中 n 是数据集中的元素数目，k 是数据集中的最大数字位数，因此对于位数较少的数据集，基数排序可以表现出更好的时间效率。

        基数排序可以采用 LSD（从低位到高位）和 MSD（从高位到低位）两种方式实现。以 LSD 方式为例，它按照数字的个位、十位、百位等依次对数字进行排序。对于每一位数字，可以使用计数排序或桶排序等比较简单的排序算法来进行排序。每一轮排序之后，根据当前位数的排序结果，就可以将原数据集中的数字按照当前位数的大小重新排列。重复以上步骤，直到所有位数都排完为止。

        基数排序的优点是稳定性好（相同大小的数字出现的先后顺序不会被打乱），而且不涉及数值大小的比较，因此不会受到数值大小差异的限制。但基数排序的缺点是需要相对较多的内存空间，而且对于位数较多的数字，排序时间会变得很长。

8.3 插入排序

空间复杂度：O(1)

最好时间复杂度：O(n)

最坏时间复杂度：O(n^2)

平均时间复杂度：O(n^2)

//直接插入排序
void InsertSort(int a[],int n)
{
	int i,j,temp;
//	for(i=1;i<n;i++)       //将各元素插入已排好序的序列中 
//		if(a[i]<a[i-1])    //若a[i]关键字小于前驱 
//		{
//			temp=a[i];     //用temp暂存a[i] 
//			for(j=i-1;j>=0&&a[j]>temp;--j)  //检查所有前面已排好序的元素 
//			{
//				a[j+1]=a[j];    //所有大于temp的元素都向后挪位 
//			}
//			a[j+1]=temp;       //复制到插入位置 
//		}
	for(i=2;i<=n;i++)
		if(a[i]<a[i-1])
		{
			a[0]=a[i];
			for(j=i-1;a[0]<a[j];--j)
				a[j+1]=a[j];
			a[j+1]=a[0];
		}
}

 优化-折半插入排序

//折半插入排序
void InsertSort(int a[],int n)
{
	int i,j,low,high,mid;
	for(i=2;i<=n;i++)
	{
		a[0]=a[i];
		low=1;high=i-1;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(a[mid]>a[0])
				high=mid-1;
			else low=mid+1;
		}
		for(j=i-1;j>=high+1;--j)
			a[j+1]=a[j];
		a[high+1]=a[0];
	}	
}

8.4 希尔排序

//希尔排序 
void ShellSort(int a[],int n)
{
	int d,i,j;
	//a[0]只是暂存单元，当 j<=0时，插入位置已到
	for(d=n/2;d>=1;d=d/2)
		for(i=d+1;i<=n;++i)
			if(a[i]<a[i-d])
			{
				a[0]=a[i];
				for(j=i-d;j>0&&a[0]<a[j];j-=d)
					a[j+d]=a[j];
				a[j+d]=a[0];
			}
}

8.5 冒泡排序 

空间复杂度：O(1)

最好时间复杂度：O(n)

最坏时间复杂度：O(n^2)

平均时间复杂度：O(n^2)

//冒泡排序
void  BubbleSort(int a[],int n)
{
	int i,j,flag,temp;
	for(i=0;i<n-1;i++)
	{
		flag=0; //表示本趟冒泡排序是否发生交换的标志
		for(j=n-1;j>i;j--) //一趟冒泡过程
			if(a[j-1]>a[j]) //若逆序，则交换
			{
				temp=a[j-1];
				a[j-1]=a[j];
				a[j]=temp;
				flag=1;
			}
		if(flag==0)
			return;
	}
}

8.6 快速排序

最好空间复杂度：O(log2(n))

最坏空间复杂度：O(n)

最好时间复杂度：O(nlog2(n))

最坏时间复杂度：O(n^2)

平均时间复杂度：O(nlog2(n))

//用于划分左右子表 
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[low]=pivot;  //枢轴元素存放到最终位置 
	return low;   //返回存放枢轴的最终位置 
}
//快速排序
void QuickSort(int a[],int low,int high)
{
	if(low<high) //递归跳出的条件 
	{
		int pivotops=Partition(a,low,high);//划分
		QuickSort(a,low,pivotops-1);//划分左子表 
		QuickSort(a,pivotops+1,high);//划分右子表 
	}
}

8.7 简单选择排序

空间复杂度：O(1)

时间复杂度：O(n^2)

//简单选择排序
void SelectSort(int a[],int n)
{
	int i,j,min;
	for(i=0;i<n-1;i++)
	{
		min=i;
		for(j=i+1;j<n;j++)
			if(a[j]<a[min])
				min=j;
		if(min!=i)
		{
			int temp;
			temp=a[i];
			a[i]=a[min];
			a[min]=temp;
		}
	}
}

8.8 堆排序

空间复杂度：O(1)

时间复杂度：O(nlog2(n))

//将以k为根的子树调整为大根堆
void  HeadAdjust(int a[],int k,int len)
{
	int i;
	a[0]=a[k];
	for(i=2*k;i<=len;i*=2)
	{
		if(i<len&&a[i]<a[i+1])
			i++;
		if(a[0]>=a[i])
			break;
		else{
			a[k]=a[i];
			k=i;
		}
	}
	a[k]=a[0];
}
//建立大根堆 
void BuildMaxHeap(int a[],int len)
{
	int i;
	for(i=len/2;i>0;i--)
		HeadAdjust(a,i,len);
}
//堆排序
void HeapSort(int a[],int len)
{
	int i,temp;
	BuildMaxHeap(a,len);
	for(i=len;i>1;i--)
	{
		temp=a[i];
		a[i]=a[1];
		a[1]=temp;
		HeadAdjust(a,1,i-1);
	}
}

8.9 归并排序

空间复杂度：O(n)

时间复杂度：O(nlog2(n))

//将两个有序的数组归并
void Merge(int a[],int low,int mid,int high) 
{
	int i,j,k;
	int *b=(int *)malloc(8*sizeof(int)); //辅助数组b
	for(k=low;k<=high;k++)
		b[k]=a[k];
	for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++)
	{
		if(b[i]<=b[j])
			a[k]=b[i++];
		else
			a[k]=b[j++];
	}
	while(i<=mid)
		a[k++]=b[i++];
	while(j<=high)
		a[k++]=b[j++];	
}
//归并排序
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);
	}
}

8.10 置换-选择排序

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

void permuteSelectionSort(int arr[], int n) {
    int i, j, min_idx;

    for (i = 0; i < n - 1; i++) {
        min_idx = i;
        for (j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }

        if (min_idx != i) {
            swap(&arr[i], &arr[min_idx]);
        }
    }
}