HDUOJ #2020 绝对值排序+总结排序

拿到这道题看着很简单，可是却很难下手，把之前学的排序什么的都忘得差不多了

所以又回去复习一下排序算法，在这总结一下。

首先定义排序算法中的抽象数据类型，例子中keytype是int型

struct DataType{
    KeyType key;
}；

1.插入排序（从初始有序的子集合开始不断把新的数据元素插入已排列有序子集合的合适位置）

1.1直接插入排序（顺序插入，倒着比）

void InsertSort(DataType a[],int n)
{
	int i,j;
	DataType temp;
	for(i=0;i<n-1;i++){
		temp=a[i+1];
		j=i;
		while(j>-1 && temp.key<a[j].key){
			a[j+1]=a[j];
			j--;
		}
		a[j+1]=temp;
	}
}

1.2希尔排序（分组用直接插入法，小组的个数逐次缩小）

void ShellSort(DataType a[],int n,int d[],int numOfD) //d[]为增量数组
{
	int i,j,k,m,span;
	DataType temp;
	for(m=0;m<numOfD;m++){
		span=d[m];
		for(k=0;k<span;k++){   //span个小组
			for(i=k;i<n-span;i=i+span){ //增量是span而不是1
				temp=a[i+span];
				j=i;
				while(j>-1&& temp.key<a[j].key){
					a[j+temp]=a[j];
					j=j-span;
				}
				a[j+span]=temp
			}
		}
	}
}

2.选择排序（待排数组中选取最小（大）的放到最前（后）面）

2.1 直接选择排序

void SlectSort(DataType a[],int n){
	int i,j,small;
	DataType temp;

	for(i=0;i<n-1;i++){
		small=i;   //small是最小值的位置
		for(j=i+1;j<n;j++){
			if(a[j].key<a[small].key){small=j;}
		}//在i+1-n之间选择最小的

		if(small!=i){
			temp=a[i];              //交换i和最小的
			a[i]=a[small];
			a[small]=temp;
		}
	}
}

2.2堆排序

首先创建最大堆，从也在节点开始看，每个分叉，最大值都要在根节点上，从而调整。

排序：堆顶a[0]和当前最大堆的最后一个元素互换，最大堆个数减一；

代码比较复杂，暂时不贴上来。

3.交换排序

3.1冒泡排序

n个数据，循环n-1躺，每一趟比较相邻元素，逆序则交换，最后一个值为最大值，数组长度减一，再走一趟

void BubbleSort(DataType a[],int n){
	int i,j,flag=1;
	DataType temp;

	for(i=1;i<n&&flag==1;i++){
		flag=0;  //有交换的即为1，没交换说明顺序排好了

		for(j=0;j<n-i;j++){ //相当于末尾i-1个数排好顺序了，因为交换i-1和i交换，所欲只需要走到i-1；
			if(a[j].key>a[j+1].key){
				flag=1;
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
}

3.2快速排序

二叉树结构的交换排序

void QuickSort(DataType a[],int low,int high){
	int i=low,j=high;
	DataType temp=a[low];

	while(i<j){ //low<high的时候
		while(i<j&&temp.key<=a[j].key)j--;    //从数组右端开始扫描
		if(i<j){
			a[i]=a[j];
			i++;
		}

		while(i<j&& a[i].key<temp.key)i++; // 扫描左端
		if(i<j){
			a[j]=a[i];
			j--;
		}
	}
	a[i]=temp;
	if(low<i)QuickSort(a,low,i-1);
	if(i<high)QuickSort(a,j+1,high);
}

4.归并排序

主要是二路归并排序

5.基数排序（分好桶，桶中数据先进先出，对数的每一位做模运算。）

稳定的排序：直接插入排序，冒泡排序，归并排序，基数排序

时间优的排序：堆排序，快速排序，归并排序  O(nlog2n)

#2020

在比较的时候加上abs()函数

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

int shu[106];

void QuickSort(int a[],int low,int high){
	int i=low,j=high;
	int temp=a[low];

	while(i<j){ //low<high的时候
		while(i<j&&abs(temp)<=abs(a[j]))j--;    //从数组右端开始扫描
		if(i<j){
			a[i]=a[j];
			i++;
		}

		while(i<j&& abs(a[i])<abs(temp))i++; // 扫描左端
		if(i<j){
			a[j]=a[i];
			j--;
		}
	}

	a[i]=temp;
	if(low<i)QuickSort(a,low,i-1);
	if(i<high)QuickSort(a,j+1,high);
}

int main()
{
	int n,t;
	int flag=0;
	while(cin>>n &&n){
		for(int i=0;i<n;i++){
			cin>>shu[i];
		}
		

		QuickSort(shu,flag,n-1);

		for(int i=n-1;i>0;i--){
			cout<<shu[i]<<" ";
		}
		cout<<shu[0]<<endl;
	}

}