九、排序（未完）

排序概论

• 【排序】：n个记录的序列为{r1,r2,…,rn}，其相应的关键字分别为{k1,k2,…,kn}，需确定1,2,…,n的一种排列p1,p2,…pn,使其相应的关键字满足kp1<=kp2<=…<=kpn非递减（或非递增）关系，即使得序列成为一个按关键字有序的序列{rp1,rp2,…rpn}
• 【稳定性】：ki=kj(1<=i<=n,1<=j<=n,i!=j)，且在排序前的序列中ri领先于rj(即i<j)
  • 如果排序后ri仍领先于rj，则称所用的排序方法是稳定的；
  • 若可能使得排序后的序列中rj领先ri，则称所用的排序方法是不稳定的
• 影响排序算法性能的因素
  • 时间性能
  • 辅助空间
  • 算法的复杂性
• 【内排序】：排序整个过程中，待排序列所有记录全部放置在内存中
• 【外排序】：排序记录多，不能同时放入内存，整个排序过程需要在内外存之间多次交换数据

排序所用顺序表结构

#define MAXSIZE 10
typedef struct{
	int r[MAXSIZE+1];           // r[0]为哨兵
	int length;
}SqList;

数组两元素交换

void swap(SqList *L,int i,int j){
	int temp=L->r[i];
	L->r[i]=L->r[j];
	L->r[j]=temp;
}

冒泡排序————O(n²)

• 冒泡排序算法

void BubbleSort(SqList* L) {
	int i, j;
	for (i = 1; i < L->length; i++) {
		for (j=L->length-1;j>=j;j--)
		{
			if (L->r[j] > L->r[j + 1]) {
				swap(L, j, j + 1);
			}
		}
	}
}

• 冒泡排序算法优化：
  • 某次冒泡发现没有任何数据交换，说明序列已经有序

void BubbleSort(SqList* L) {
	int i, j;
	Status flag=TRUE;               // flag作为标记
	for (i = 1; i < L->length && flag; i++) {
		flag=FALSE;
		for (j=L->length-1;j>=j;j--)
		{
			if (L->r[j] > L->r[j + 1]) {
				swap(L, j, j + 1);
				flag=TRUE;          // 有交换则为TRUE
			}
		}
	}
}

简单选择排序——O(n²)

void SelectSort(SqList* L) {
    int i，j, min;
    fot(i = 1; i < L->length; i++) {
        min = i;
        for (j = i + 1; j <= L->length; j++) {
            if (L->r[min] > L->r[j]) {
                min = j;
            }
        }
        if (i != min)
            swap(L, i, min);
    }
}

直接插入排序——O(n²)

void InsertSort(SqList* L) {
	int i, j;
	for (i = 2; i <= L->length; i++) {
		if (L->r[i] < L->r[i - 1]) {
			L->r[0] = L->r[i];         // 设置哨兵
			for (j = i - 1; L->r[j] > L->r[0]; j--) {
				L->r[j + 1] = L->r[j];
			}
			L->r[j + 1] = L->r[0];
		}
	}
}

希尔排序————O(n^1.3)

void ShellSort(SqList* L)
{
	int i, j;
	int increment = L->length;
	do {
		increment = increment / 3 + 1;   // 增量序列
		for (i = increment + 1; i <= L->length; i++) {
			if (L->r[i] < L->r[i - increment]) {
				L->r[0] = L->r[i];
				for (j = i - increment; j > 0 && L->r[0] < L->r[j]; j -= increment) {
					L->r[j + increment] = L->f[j];
				}
				L->r[j + increment] = L->r[0];
			}
		}
	} while (increment > 1);
}

堆排序—————O(nlogn)

// 对顺序表L进行堆排序
void HeapSort(SqList* L) {
	int i;
	for (i = L->length / 2; j > 0; i++) {
		HeapAdjust(L, i, L->length);
	}
	for (i = L->length; i > 1; i--) {
		swap(L, 1, i);
		HeapAdjust(L, 1, i - 1);
	}
}
// 调堆
void HeapAdjust(SqList* L, int s, int m) {
	int temp, j;
	for (j = 2 * s; j<=m; j *= 2) {
		if (j < m && L->r[j] < L->r[j + 1])
			++j;
		if (temp >= L->r[j])
			break;
		L->r[s] = L->r[j];
		s = j;
	}
	L->r[s] = temp;
}

归并排序————O(nlogn)

void MergeSort(SqList* L) {
	MSort(L->r, L - r, l, L->length);
}

void MSort(int SR[], int TR1[], int s, int t) {
	int m;
	int TR2[MAXSIZE + 1];
	if (s == t)
		TR1[s] = SR[s];
	else {
		m = (s + t) / 2;
		MSort(SR, TR2, s, m);
		MSort(SR, TR2, m + 1, t);
		Merge(TR2, TR1, s, m, t);
	}
}

void Merge

快速排序————O(nlogn)