数据结构 多种内部排序算法的应用

输入学生数据，每个学生有学号、姓名、成绩，无序输入    按照学生的成绩 对学生进行排序 

这里有8个算法（有空会修改为9个）

有基于插入的  直接插入排序  二分寻找插入排序  希尔排序

有基于交换的  冒泡排序     快速排序

有基于选择的  简单选择排序  堆排序（树形选择排序）

有基于合并的  归并排序

还有一个可能会因为关键字类型而限制的简单暴力   桶排序

这些都是基本排序算法原理         其实都不如c++算法库里提供的sort好用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct {
	int NO;
	char name[20];
	int score;
}student;
typedef struct {
	student stu[101];
	int num;
}SqList;

// 直接插入排序 
void straight_insert(SqList* L) {
	for (int i = 2; i <= L->num; i++) {
		L->stu[0] = L->stu[i];
		int j = i - 1;
		while (L->stu[j].score > L->stu[0].score) {
			L->stu[j + 1] = L->stu[j];
			j--;
		}
		L->stu[j + 1] = L->stu[0];
	}
}
// 二分查找插入排序  
void half_search_insert(SqList* L) {
	for (int i = 2; i <= L->num; i++) {
		L->stu[0] = L->stu[i];
		int low = 1, high = L->num, mid;
		while (low <= high) {
			mid = (low + high) / 2;
			if (L->stu[mid].score < L->stu[0].score)
				low = mid + 1;
			else
				high = mid - 1;
		}
		int j = i - 1;
		while (j >= high + 1) {//j >= high + 1  
			L->stu[j + 1] = L->stu[j];
			j--;
		}
		L->stu[high + 1] = L->stu[0];
	}
}

// 希尔排序（多次间隔插入排序） 
// 一次希尔排序 
void shell_insert(SqList* L, int d) {
	for (int i = d + 1; i <= L->num; i++) {
		L->stu[0] = L->stu[i];
		int j = i - d;
		while (L->stu[j].score > L->stu[0].score) {
			L->stu[j + d] = L->stu[j];
			j -= d;
		}
		L->stu[j + d] = L->stu[0];
	}
}
void shell_sort(SqList* L, int a[], int t) {
	for (int i = 0; i < t; i++)
		shell_insert(L, a[i]);
}

//冒泡排序  
void popo_sort(SqList* L) {
	bool flag = true;
	for (int i = 1; i < L->num && flag; i++) {
		flag = false;
		for (int j = 1; j <= L->num - i; j++) {
			if (L->stu[j].score > L->stu[j + 1].score) {
				L->stu[0] = L->stu[j];
				L->stu[j] = L->stu[j + 1];
				L->stu[j + 1] = L->stu[0];
			}
			flag = true;
		}
	}
}

//快速排序  递归版  
//单次快排 查找枢轴位置  
//int locate_key(SqList* L, int low, int high) {
//	L->stu[0] = L->stu[low];
//	int key = L->stu[0].score;//枢轴  
//	while (low < high) {
//		while (low < high && L->stu[high].score >= key)
//			high--;
//		L->stu[low] = L->stu[high];
//
//		while (low < high && L->stu[low].score <= key)
//			low++;
//		L->stu[high] = L->stu[low];
//	}
//	L->stu[low] = L->stu[0];
//	return low;//枢轴位置  
//}
int locate_key(SqList* L, int low, int high) {
	L->stu[0] = L->stu[low];
	int key = L->stu[0].score;//枢轴  
	do {
		while (key <= L->stu[high].score && high > low)
			high--;
		if (high > low) {
			L->stu[low] = L->stu[high];
			low++;
		}
		while (L->stu[low].score <= key && high > low)
			low++;
		if (high > low) {
			L->stu[high] = L->stu[low];
			high--;
		}
	} while (low != high);
	L->stu[low] = L->stu[0];
	return low;//枢轴位置  
}
void quick_sort(SqList* L, int low, int high) {
	if (low < high) {
		int loc = locate_key(L, low, high);
		quick_sort(L, low, loc - 1);
		quick_sort(L, loc + 1, high);
	}
}

//简单选择排序 
void select_sort(SqList* L) {
	for (int i = 1; i < L->num; i++) {
		int k = i;
		for (int j = i + 1; j <= L->num; j++)
			if (L->stu[j].score < L->stu[k].score)
				k = j;
		L->stu[0] = L->stu[k];
		L->stu[k] = L->stu[i];
		L->stu[i] = L->stu[0];
	}
}

//堆排序（树形选择排序） 
//建立大根堆 
void build_heap(SqList* L, int low, int high) {
	student root = L->stu[low];//根 
	for (int j = 2 * low; j <= high; j *= 2) {
		if (j < high&& L->stu[j].score < L->stu[j + 1].score)
			j++;
		if (root.score >= L->stu[j].score)
			break;
		L->stu[low] = L->stu[j];
		low = j;
	}
	L->stu[low] = root;
}
void heap_sort(SqList* L) {
	for (int i = L->num / 2; i > 0; i--)
		build_heap(L, i, L->num);
	for (int i = L->num; i > 1; i--) {
		L->stu[0] = L->stu[1];
		L->stu[1] = L->stu[i];
		L->stu[i] = L->stu[0];

		build_heap(L, 1, i - 1);
	}
}

//归并排序 
void merge(student sr[], student tr[], int i, int m, int n) {
	//sr[i...m]和 sr[m+1...n]归并到 tr [i...n]
	int j, k;
	for (j = m + 1, k = i; i <= m && j <= n; k++)
		if (sr[i].score < sr[j].score)
			tr[k] = sr[i++];
		else tr[k] = sr[j++];
	//剩余的  
	while (i <= m)
		tr[k++] = sr[i++];
	while (j <= n)
		tr[k++] = sr[j++];
}
void msort(student sr[], student tr[], int s, int t) {
	//sr[ s...t]归并排序到 tr[s...t] 
	if (s == t) tr[s] = sr[s];
	else {
		int m = (s + t) / 2;
		student tr2[100];
		msort(sr, tr2, s, m);
		msort(sr, tr2, m + 1, t);
		merge(tr2, tr, s, m, t);
	}
}
void MergeSort(SqList* L) {
	msort(L->stu, L->stu, 1, L->num);
}
void show(SqList L) {
	for (int i = 1; i <= L.num; i++) {
		printf("%d %c %d\n", L.stu[i].score, L.stu[i].name[0],L.stu[i].NO);
	}
	printf("\n");
}

int main()
{
	SqList L;
	int a[6] = { 3,1,5,7,6,2 };
	L.num = 6;
	for (int i = 1; i <= 6; i++) {
		L.stu[i].score = a[i - 1];
		L.stu[i].name[0] = 'A' + i;
		L.stu[i].NO=1000+i;
	}
	show(L);
	//	straight_insert(&L);

	//	half_search_insert(&L);

	//	int dk[3]={4,2,1};
	//	shell_sort(&L,dk,3);

	//	popo_sort(&L);

	//	quick_sort(&L,1,6);

	//	select_sort(&L);

	//	heap_sort(&L);

	//	MergeSort(&L);
	show(L);

	return 0;
}