数据结构中的排序算法

1.插入排序

1.1直接插入排序

void InsertSort(ElemType A[],int n) {
	int i,j;
	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];
		}
	}
}

1.2折半插入排序

void InsertSort(ElemType A[],int n) {
	int i,j,low,high,mid;
	//依次将A[2]~A[n]插入到前面已排好的序列中
	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];
	}
}

1.3希尔排序

void ShellSort(ElemType A[],int n) {
	int i,j,dk;
	//依次将A[2]~A[n]插入到前面已排好的序列中
	for(dk=n/2; dk>=1; dk=dk/2) {
		for(i=dk+1; i<=n; ++i) {
			if(A[i]<A[i-dk]) {
				A[0]=A[i];
				for(j=i-dk; j>0&&A[0]<A[j]; j=j-dk) {
					A[j+dk]=A[j];
				}
				A[j+dk]=A[0];
			}
		}
	}
}

2.交换排序

2.1冒泡排序

void BubbleSort(ElemType 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-1]>A[j]) {
				swap(A[j-1],A[j]);
				flag=true;
			}
		}
		if(flag==false)
			return;
	}
}

2.2快速排序（重点）

int Partition(ElemType A[],int low, int high) {
	ElemType pivot=A[low];
	while (low < high) {
		while (A[high]>=pivot&& low < high)
			--high;
		A[low]=A[high];
		while (A[low]<=pivot&& low < high)
			++low;
		A[high]=A[low];
	}
	A[low]=pivot;
	return low;
}
void QuickSort(ElemType A[],int low, int high) {
	if(low<high) {
		int pivotpos=Partition(A,low,high);
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}

3.选择排序

2.1简单选择排序

void selectSort(ElemType  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)
			swap(A[i],A[min]);
	}
}

2.2堆排序

大根堆：根结点的值>左、右子树结点的值

void BuildMaxHeap(ElemType A[],int len) {
	for(int i=len/2; i>0; i--)
		HeadAdjust(A,i,len);
}
void HeadAdjust(ElemType A[],int k,int len) {
	A[0]=A[k];
	for(int 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 HeapSort(ElemType A[],int len) {
	BuildMaxHeap(A,len);
	for(int i=len; i>1; i--) {
		Swap(A[i],A[1]);
		HeadAdjust(A,1,i-1);
	}
}

4.二路归并排序

5.基数排序

移动次数与初始排列序列无关，不需要进行关键字的比较，分配和收集两步操作（最高位优先法、最低位优先法）

6.外部排序

增大归并路数，多路平衡归并，败者树
减少归并段个数，置换-选择排序，最佳归并段