C语言数据结构--排序算法

最新推荐文章于 2022-12-08 18:03:17 发布
最新推荐文章于 2022-12-08 18:03:17 发布
阅读量446 收藏 1
点赞数
文章标签： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZL1599292797/article/details/103773981
版权 
#ifndef SORT_H
#define SORT_H

#include"Head.h"
#include"List.h"
#include"Stack_Queue.h"
#include"Tree.h"

#define MAXSIZE 20
#define MAX_NUM_OF_KEY 8//关键字项数最大值,即关键字位数
#define RADIX 10//关键字基数，即关键字从最小到最大的位数
#define MAX_SAPCE 1000//

typedef int KeyType;

typedef struct {
	int key;
	int next;
}SLNode;
typedef struct {
	SLNode r[MAXSIZE];
	int length;
}SLinkListType;

typedef struct {
	KeyType keys[MAX_NUM_OF_KEY];
	int next;
}SLCell;
typedef struct {
	SLCell r[MAX_SAPCE];//静态链表可利用空间
	int keynum;//记录的当前关键字个数
	int recnum;//静态链表的当前长度
}SLList;
typedef int ArrType[RADIX];//指针数组类型

//习题结构类型
typedef enum { _Red, _White, _Blue }Flag_Color;

//创建数列
//0号位开始
void FileToSqList(SqList* L, FILE* fp);
//1号位开始
void FileToSqList_1(SqList* L, FILE* fp);
void FileToHLinkList(HLinkList* L, FILE* fp);
//直接插入排序
void InsertSort(SqList* L);
//折半插入排序
void BinaryInsertSort(SqList* L);
//2-路插入排序
void Two_WayInserSort(SqList L, SqList* T, int* first, int* final);
//表排序
void TableInsertSort(SLinkListType* L);
//希尔排序
void ShellInsert(SqList* L, int dk);
void ShellSort(SqList* L, int dlta[], int t);
//起泡排序
void Buswap(int* a, int* b);
void BubbleSort(SqList* L, ...);
//双向起泡算法
void Two_WayBubbleSort(SqList* L);
//双向起泡算法优化版
void Two_WayBubbleSort_Optimize(SqList* L);
//快速排序
int Partition(SqList* L, int low, int high);
void QSort(SqList* L, int low, int high);
void QuickSort(SqList* L);
//简单选择排序
void Simple_SelectionSort(SqList* L, ...);
//树选择排序
void Tree_SelectionSort();
//堆排序
void HeapAdjust(SqList* T, int s, int m, ...);
void HeapSort(SqList* T, ...);
//2-路归并排序
void Merge(SqList L, SqList* T, int s, int m, int t);
void MSort(SqList L, SqList* T, int s, int m);
void Two_WayMergeSort(SqList* L, int i, int j);
//基数排序
void RadixSort();
//链式基数排序
int succ(ArrType f, int i);
void Collect(SLList* L, ArrType f, ArrType e);
void Distribute(SLList* L, int i, ArrType f, ArrType e);
void Link_RadixSort(SLList* L);



#endif // !SORT_H
#ifndef SORT_H
#define SORT_H

#include"Head.h"
#include"List.h"

#define MAXSIZE 20
#define MAX_NUM_OF_KEY 8//关键字项数最大值,即关键字位数
#define RADIX 10//关键字基数，即关键字从最小到最大的位数
#define MAX_SAPCE 1000//

typedef int KeyType;

typedef struct {
	int key;
	int next;
}SLNode;
typedef struct {
	SLNode r[MAXSIZE];
	int length;
}SLinkListType;

typedef struct {
	KeyType keys[MAX_NUM_OF_KEY];
	int next;
}SLCell;
typedef struct {
	SLCell r[MAX_SAPCE];//静态链表可利用空间
	int keynum;//记录的当前关键字个数
	int recnum;//静态链表的当前长度
}SLList;
typedef int ArrType[RADIX];//指针数组类型


//直接插入排序
void InsertSort(SqList* L);
//折半插入排序
void BinaryInsertSort(SqList* L);
//2-路插入排序
void Two_WayInserSort(SqList L, SqList* T, int* first, int* final);
//表排序
void TableInsertSort(SLinkListType* L);
//希尔排序
void ShellInsert(SqList* L, int dk);
void ShellSort(SqList* L, int dlta[], int t);
//起泡排序
void Buswap(int* a, int* b);
void BubbleSort(SqList* L, ...);
//双向起泡算法
void Two_WayBubbleSort(SqList* L);
//双向起泡算法优化版
void Two_WayBubbleSort_Optimize(SqList* L);
//快速排序
int Partition(SqList* L, int low, int high);
void QSort(SqList* L, int low, int high);
void QuickSort(SqList* L);
//简单选择排序
void Simple_SelectionSort(SqList* L, ...);
//树选择排序
void Tree_SelectionSort();
//堆排序
void HeapAdjust(SqList* T, int s, int m, ...);
void HeapSort(SqList* T, ...);
//2-路归并排序
void Merge(SqList L, SqList* T, int s, int m, int t);
void MSort(SqList L, SqList* T, int s, int m);
void Two_WayMergeSort(SqList* L, int i, int j);
//基数排序
void RadixSort();
//链式基数排序
int succ(ArrType f, int i);
void Collect(SLList* L, ArrType f, ArrType e);
void Distribute(SLList* L, int i, ArrType f, ArrType e);
void Link_RadixSort(SLList* L);

#endif // !SORT_H
#ifndef SORT_C
#define SORT_C

#include"InSort.h"

//直接插入排序
void InsertSort(SqList* L) {
	int i, j;
	if ((*L).length > 1)
		for (i = 2; i <= (*L).length; i++) {
			if ((*L).elem[i] < (*L).elem[i - 1]) {
				(*L).elem[0] = (*L).elem[i];
				(*L).elem[i] = (*L).elem[i - 1];
				for (j = i - 2; (*L).elem[0] < (*L).elem[j]; --j)
					(*L).elem[j + 1] = (*L).elem[j];
				(*L).elem[j + 1] = (*L).elem[0];
			}
		}
}
//折半插入排序
void BinaryInsertSort(SqList* L) {
	int i, j, low, high, m;
	for (i = 2; i <= (*L).length; i++) {
		(*L).elem[0] = (*L).elem[i];
		low = 1;
		high = i - 1;
		while (low <= high) {
			m = (low + high) / 2;
			if ((*L).elem[0] < (*L).elem[m])	high = m - 1;
			else low = m + 1;
		}
		for (j = i - 1; j >= high + 1; --j)
			(*L).elem[j + 1] = (*L).elem[j];
		(*L).elem[high + 1] = (*L).elem[0];
	}
}
//2-路插入排序
void Two_WayInserSort(SqList L,SqList* T,int* first,int* final) {
	int i, j;
	(*T).elem[1] = L.elem[1];
	(*T).length = L.length;
	*first = 1; *final = 1;
	for (i = 2; i <= L.length; i++) {
		if (L.elem[i] < (*T).elem[1]) {
			if (!(*first - 1)) {
				*first = L.length;
				(*T).elem[*first] = L.elem[i];
			}
			else {
				for (j = *first; (*T).elem[j] < L.elem[i]; ++j)
					(*T).elem[j - 1] = (*T).elem[j];
				(*T).elem[j - 1] = L.elem[i];
				(*first)--;
			}
		}
		else {
			for (j = *final; (*T).elem[j] > L.elem[i]; --j)
				(*T).elem[j + 1] = (*T).elem[j];
			(*T).elem[j + 1] = L.elem[i];
			(*final)++;
		}
	}
}
//表排序
void TableInsertSort(SLinkListType* L) {
	int i, j;
	SLNode* p;
	(*L).r[0].next = 1;
	(*L).r[1].next = 0;
	for (i = 2; i <= (*L).length; i++) {
		p = &(*L).r[0];
		j = (*p).next;
		while ((*L).r[i].key > (*L).r[j].key) {
			p = &(*L).r[j];
			j = (*p).next;
		}
		(*p).next = i;
		(*L).r[i].next = j;
	}
}
//希尔排序
void ShellInsert(SqList* L, int dk) {
	int i, j, k;
	for (i = 1; i <= dk; i++)
		for (j = i + dk; j <= (*L).length; j += dk) {
			if ((*L).elem[j] < (*L).elem[j - dk]) {
				(*L).elem[0] = (*L).elem[j];
				(*L).elem[j] = (*L).elem[j - dk];
				for (k = j - 2 * dk; (*L).elem[0] < (*L).elem[k]; j -= dk)
					(*L).elem[k + dk] = (*L).elem[k];
				(*L).elem[k + dk] = (*L).elem[0];
			}
		}

}
void ShellSort(SqList* L, int dlta[], int t) {
	for (int k = 0; k < t; k++)
		ShellInsert(L, dlta[k]);
}
//起泡排序
void Buswap(int* a, int* b) {
	int t;
	t = *a;
	*a = *b;
	*b = t;
}
void BubbleSort(SqList* L, ...) {
	va_list ap;
	va_start(ap, L);
	char* t = va_arg(ap, char*);
	va_end(ap);
	int i, j;
	if (!strcmp("MAX", t))
		for (i = 0; i < (*L).length; i++)
			for (j = 2; j <= (*L).length - i; j++) {
				if ((*L).elem[j] > (*L).elem[j - 1])
					Buswap(&(*L).elem[j], &(*L).elem[j - 1]);
			}
	else if (!strcmp("MIN", t))
		for (i = 0; i < (*L).length; i++)
			for (j = 2; j <= (*L).length - i; j++) {
				if ((*L).elem[j] < (*L).elem[j - 1])
					Buswap(&(*L).elem[j], &(*L).elem[j - 1]);
			}
}
//双向起泡算法
void Two_WayBubbleSort(SqList* L) {
	int k, t, st, ed;
	st = 1; ed = (*L).length - 1;
	do {
		for (k = 1, t = 0; k <= ed; k++) {
			if ((*L).elem[k] > (*L).elem[k + 1]) {
				Buswap(&(*L).elem[k], &(*L).elem[k + 1]);
				t = 1;
			}
		}
		if (!t)
			break;
		for (k = ed, t = 0; k >= st + 1; k--)
			if ((*L).elem[k] < (*L).elem[k - 1]) {
				Buswap(&(*L).elem[k], &(*L).elem[k - 1]);
				t = 1;
			}
	} while (t);

}
//双向起泡算法优化版
void Two_WayBubbleSort_Optimize(SqList* L) {
	int st, ed, tag, i, j, t, k;//st起点，ed终点，tag指示正逆序，t下次循环的起点,k增量
	st = 1; ed = (*L).length;
	tag = 0;
	k = 1;
	while (1) {
		j = st;
		for (i = st, t = 0; i != ed; i += k)
			if ((*L).elem[i] > (*L).elem[i + 1]) {
				Buswap(&(*L).elem[i], &(*L).elem[i + 1]);
				t = 1;
			}
		if (!t)
			break;
		k = -k;
		st = ed + 2 * k;
		ed = j + k;
	}
}
//快速排序
int Partition(SqList* L, int low, int high) {
	(*L).elem[0] = (*L).elem[low];
	while (low < high) {
		while (low < high && (*L).elem[high] >= (*L).elem[0])
			high--;
		(*L).elem[low] = (*L).elem[high];
		while (low < high && (*L).elem[low] <= (*L).elem[0])
			low++;
		(*L).elem[high] = (*L).elem[low];
	}
	(*L).elem[low] = (*L).elem[0];
	return low;
}
void QSort(SqList* L, int low, int high) {
	if (low < high) {
		int mid = Partition(L, low, high);
		QSort(L, low, mid - 1);
		QSort(L, mid + 1, high);
	}
}
void QuickSort(SqList* L) {
	QSort(L, 1, (*L).length);
}
//简单选择排序
void Simple_SelectionSort(SqList* L, ...) {
	int i, j, pos;
	va_list ap;
	va_start(ap, L);
	char* t = va_arg(ap, char*);
	va_end(ap);
	if (strcmp(t, "MAX"))
		for (i = 1; i < (*L).length; i++) {
			int max = (*L).elem[i];
			pos = i;
			for (j = i + 1; j <= (*L).length; j++)
				if (max < (*L).elem[j]) {
					pos = j;
					max = (*L).elem[j];
				}
			if (pos != i)
				Buswap(&(*L).elem[i], &(*L).elem[pos]);
		}
	else
		for (i = 1; i < (*L).length; i++) {
			int min = (*L).elem[i];
			pos = i;
			for (j = i + 1; j <= (*L).length; j++)
				if (min > (*L).elem[j]) {
					pos = j;
					min = (*L).elem[j];
				}
			if (pos != i)
				Buswap(&(*L).elem[i], &(*L).elem[pos]);
		}
}
//树选择排序
void Tree_SelectionSort() {

}
//堆排序
void HeapAdjust(SqList* T, int s, int m, ...) {
	va_list ap;
	va_start(ap, m);
	char* t = va_arg(ap, char*);
	va_end(ap);
	int j, rc;
	rc = (*T).elem[s];
	if (!strcmp(t, "SMA")) {
		for (j = 2 * s; j <= m; j *= 2) {
			if (j < m && (*T).elem[j] <= (*T).elem[j + 1])
				++j;
			if (rc >= (*T).elem[j] || j > (*T).length)
				break;
			(*T).elem[s] = (*T).elem[j];
			s = j;
		}
	}
	else {
		for (j = 2 * s; j <= m; j *= 2) {
			if (j < m && (*T).elem[j] >= (*T).elem[j + 1])
				++j;
			if (rc <= (*T).elem[j] || j > (*T).length)
				break;
			(*T).elem[s] = (*T).elem[j];
			s = j;
		}
	}
	(*T).elem[s] = rc;
}
void HeapSort(SqList* T, ...) {
	va_list ap;
	va_start(ap, T);
	char* t = va_arg(ap, char*);
	va_end(ap);
	int i;
	for (i = (*T).length / 2; i; i--)
		HeapAdjust(T, i, (*T).length, t);
	for (i = (*T).length; i; i--) {
		Buswap(&(*T).elem[1], &(*T).elem[i]);
		HeapAdjust(T, 1, i - 1, t);
	}
}
//2-路归并排序
void Merge(SqList L,SqList* T,int s,int m,int t) {
	int i, j, k;
	for (i = s, j = m + 1, k = s; i <= m && j <= t;) {
		if (L.elem[i] > L.elem[j])	(*T).elem[k++] = L.elem[j++];
		else	(*T).elem[k++] = L.elem[i++];
	}
	while (j <= t) {
		(*T).elem[k++] = L.elem[j++];
	}
	while (i <= m)
		(*T).elem[k++] = L.elem[i++];
	//从小到大
}
void MSort(SqList L,SqList* T,int s,int m) {
	SqList R;
	InitSqList(&R);
	if (s == m)
		(*T).elem[s] = L.elem[m];
	else {
		int t = (m + s) / 2;
		MSort(L, &R, s, t);
		MSort(L, &R, t + 1, m);
		Merge(R, T, s, t, m);
	}
}
void Two_WayMergeSort(SqList* L,int i,int j) {
	MSort(*L, L, i, j);
}

//链式基数排序
int succ(ArrType f,int i) {
	while (!f[i] && i < RADIX)
		i++;
	return i;
}
void Collect(SLList* L,ArrType f,ArrType e) {
	int i, j, t;
	i = 0;
	j = succ(f, i);
	(*L).r[0].next = f[j];
	t = e[j];
	while (j < RADIX) {
		for (j = succ(f, j + 1); j < RADIX - 1 && !f[j]; j = succ(f, j + 1));
		if (f[j] && j < RADIX) {
			(*L).r[t].next = f[j];
			t = e[j];
		}
	}
	(*L).r[t].next = 0;
}
void Distribute(SLList* L,int i,ArrType f,ArrType e) {
	int p, q, j;
	q = 0; j = (*L).r[0].next;
	while (q < (*L).recnum) {
		p = (*L).r[j].keys[i];
		if (!f[p])
			f[p] = j;
		else 
			(*L).r[e[p]].next = j;
		e[p] = j;
		j = (*L).r[j].next;
		q++;
	}
}
void Link_RadixSort(SLList* L) {
	ArrType f, e;
	int i, j;
	for (j = 0; j < (*L).keynum; j++) {
		for (i = 0; i < (*L).recnum; f[i] = 0, e[i] = 0, i++);
		Distribute(L, j, f, e);
		Collect(L, f, e);
	}
}

#endif // !SORT_C

 

QiQaWgYu
关注
数据结构实现下列函数：void InsertSort(SqList &L);
06-14
试以L.r[k+1]作为监视哨改写教材10.2.1节 中给出的直接插入排序算法。其中，L.r[1..k]为待排 序记录且k<MAXSIZE。 实现下列函数： void InsertSort(SqList &L);
数据结构第四次实验-常用的内部排序算法
qq_49383677的博客
06-08 4439
1.掌握常见的内部排序算法的思想及其适用条件； 2.掌握常见的内部排序算法的程序实现；1、任务描述 设计一个内部排序算法模拟系统，利用该系统实现常用的 7 种排序算法，并测试 各种排序算法的性能。 实验内容：通过一个简单的菜单，分别实现下列排序要求，采用几组不同数据测试各排 序算法的性能（比较次数和移动次数）及稳定性。 ◆ 实现简单选择排序、直接插入排序和冒泡排序； ◆ 实现折半插入排序； ◆ 实现希尔排序算法； ◆ 实现快速排序算法（递归和非递归）； ◆ 实现堆排序算法 输入和输出： （1）输入形式：
排序代码实践
shashakira的博客
09-01 132
排序代码，部分代码省略（未保存） //排序练习 #include #define MAXSIZE 10 using namespace std; struct SqList//顺序表结构 { int r[MAXSIZE + 1];//存储排列数组，r[0]作哨兵或临时变量 int length; }; void swap(SqList*, int, int);//交换 void bubble_sort1(SqList*);//简单版冒泡排序 void bubble_sort2(SqList*);//冒泡排序
点赞狂魔
韶言大雅
04-27 728
微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。然而有这么一种人，他们会通过给自己看到的一切内容点赞来狂刷存在感，这种人就被称为“点赞狂魔”。他们点赞的标签非常分散，无法体现出明显的特性。本题就要求你写个程序，通过统计每个人点赞的不同标签的数量，找出前3名点赞狂魔。 输入格式： 输入在第一行给出一个正整数N（...
19、内部排序之快速排序
hopegrace的博客
02-27 660
内部排序指排序记录存放在计算机随机存储器中进行的排序过程，外部排序指，由于待排序的记录数量太大，以致排序过程中尚需对外存进行访问的排序过程。 一、快速排序的基本思想 1、快速排序（QuickSorting）又称分区交换排序，是对冒泡排序算法的改进，是一种基于分组进行互换的排序方法。 2、快速排序的基本思想是：从待排记录序列中任取一个记录Ri作为基准（通常取序列中的第一个记录），将所...
C语言---内部排序算法的性能分析.zip
11-16
随机产生五组一百个数，存入单链表中，对每组数进行起泡排序、直接插入排序、简单...分别输出采用各种排序算法对每组数据进行排序前的待排序序列和排序后的排序结果序列；分别输出对应5组数据，各类算法比较的结果表。
数据结构(C语言)--8种排序算法.pdf
07-09
数据结构(C语言)--8种排序算法.pdf
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构C语言课设-《内部排序算法比较》
10-24
"数据结构C语言课设-《内部排序算法比较》" 本课程设计的主要目的是比较不同的内部排序算法，包括冒泡排序、直接插入排序、简单选择排序、希尔排序、快速排序、堆排序、归并排序等。这些算法的实现都基于C语言，并...
C语言数据结构-折半插入排序
06-27
在IT领域，数据结构与算法是编程的基础，它们直接影响到程序的效率和性能。折半插入排序（Binary Insertion Sort）是一种改进的插入排序方法，它利用二分查找技术来减少比较次数，从而提高排序效率。现在我们来深入...
基数排序-数据结构
12-29
#include<stdio.h> #include<stdlib.h> #define MAX_NUM_OF_KEY 8 #define RADIX 10 #define MAX_SPACE 100 typedef struct { int keys[MAX_NUM_OF_KEY]; int key; int next; }SLCell; typedef struct { SLCell r[MAX_SPACE]; int keynum; int recnum; }SLList; typedef int ArrType[RADIX]; void Input(SLList &L); void RadixSort(SLList &L); void Distribute(SLCell r[],int i,ArrType &f,ArrType &e); void Collect(SLCell r[],int i,ArrType f,ArrType e); void Output(SLList L);
各种排序 冒泡 快速 堆 希尔 基数等九种
05-28
#include #include #define MAXSIZE 10 #define MAX_BIT 8 // 关键字最大位数 #define RADIX 10 // 关键字基数 ，此时是十进制整数的基数 #define MAX_SPACE 8 // 分配的存储空间的大小 typedef char KeyType;// define the keyType is the int typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo;// 其他数据项 }RedType; typedef struct { RedType r[MAXSIZE+1];// r[0] is for the guard int length; }SqList; // Radix Sorting struct SLNode { KeyType key[MAX_BIT]; // the key InfoType otheritems; // 其他数据项 int next; //下一个节点的下标位置 }; // 静态链表中的节点类型 struct SList { struct SLNode r[MAX_SPACE]; // 静态链表中各节点，其中r[0]为头结点 int keybit; // 关键字的位数 int recnum; // 静态链表中记录的个数 }; // 静态链表的类型 // 函数声明 void Insert_Sort ( SqList &L);// the Straight Insertion Sort void BInsert_Sort(SqList &L);// the Binary Insertion Sort void Shell_Sort(SqList &L);// Shell Sort int Partition ( SqList &L,int low,int high ); void Quick_Sort(SqList &L,int low,int high);// Quick Sort void Bubble_Sort(SqList &L); void Select_Sort( SqList &L); void Heap_Sort(SqList &L); void Merge_Sort(SqList &L);// Merging Sort void display(SqList L);// 输出显示 void main() { SqList L; L.length=MAXSIZE; int i,msg; char ch; do { system("cls"); // 清屏 cout<<"please input the data:"<<endl; for (i=1;i>L.r[i].key; } cout<<"1、直接插入排序"<<"\t"; cout<<"2、折半插入排序"<<endl; cout<<"3、希尔排序"<<"\t"; cout<<"4、冒泡排序"<<endl; cout<<"5、快速排序"<<"\t"; cout<<"6、直接选择排序"<<endl; cout<<"7、堆排序"<<"\t"; cout<<"8、归并排序"<<endl; cout<>msg; switch (msg) { case 1: Insert_Sort(L); display(L); break; case 2: BInsert_Sort(L); display(L); break; case 3: Shell_Sort(L); display(L); break; case 4: Bubble_Sort(L); display(L); break; case 5: Quick_Sort(L,1,L.length); display(L); break; case 6: Select_Sort(L); display(L); break; case 7: Heap_Sort(L); display(L); break; case 8: Merge_Sort(L); display(L); break; default: cout<<"please input 1至 8"<>msg; } cout<>ch; } while(ch=='Y'||ch=='y'); } // 直接插入排序 void Insert_Sort(SqList &L) { int i,j; for (i=2; i<=L.length; i++) { if (L.r[i].key<L.r[i-1].key)// if '<' insert the sort order { L.r[0] = L.r[i]; // see as a guard L.r[i]=L.r[i-1]; for ( j=i-2; L.r[0].key<L.r[j].key; j--)// try to find the right position { L.r[j+1]=L.r[j];// back } L.r[j+1]=L.r[0]; } } } //折半插入排序 void BInsert_Sort(SqList &L) { int i,j,low,high; for (i=2;i<=L.length; ++i) { L.r[0] = L.r[i];// access the SqList for the time being low=1; high=i-1; while ( low<=high ) { int m=( low+high )/2; if (L.r[0].key =high+1; --j) { L.r[j+1]=L.r[j]; } L.r[high+1] = L.r[0]; // insert it } } // 希尔排序 void Shell_Sort(SqList &L)// the ascending order { int d = L.length,i; while ( d>=1 ) { d=d/2; for (i = 1+d; i<=L.length; i++) if (L.r[i].key 0&&L.r[0].key <L.r[j].key; j-=d) { L.r[j+d]=L.r[j];// 将r[j]之前所有大于它的元素都后移 } L.r[j+d]=L.r[0];// 将r[i] 插入到正确位置 } } } // quick sort 快速排序 void Quick_Sort(SqList &L,int low,int high) { int pivotloc; if (low<high) { pivotloc=Partition(L,low,high);// One order divides into two Quick_Sort(L,low,pivotloc-1); Quick_Sort(L,pivotloc+1,high); } } int Partition ( SqList &L,int low,int high ) { // 对L.r[low]——L.r[high] 子序列进行一趟快速排序，返回分界线位置，即枢轴 L.r[0]=L.r[low]; int pivotkey=L.r[0].key; while (low<high ) { while (low=pivotkey) { high--; } L.r[low]=L.r[high];// while(False) while (low<high && L.r[low].key<=pivotkey) { low++; } L.r[high]=L.r[low];// while (false ) } L.r[low] =L.r[0]; return low; } void Bubble_Sort(SqList &L)// it's coming up 冒泡排序（上浮） { int i,j; int flag=1; // to flag the record whethe needs to exchange ,1 is need. i=1; while ( i<=L.length && flag==1) { flag=0; for (j=1; jL.r[j+1].key) { L.r[0]=L.r[j+1]; L.r[j+1]=L.r[j]; L.r[j]=L.r[0]; flag=1; } } i++; } } void Select_Sort( SqList &L)// 直接选择排序 { int i,j,min; for (i=1; i<= L.length; i++) { min=i; for (j=i+1; jL.r[j].key) { min=j; } } if (min!=i) { L.r[0]=L.r[i]; L.r[i]=L.r[min]; L.r[min]=L.r[0]; } } } void Heap_Adjust(SqList &L,int s, int m)// 堆调整 { // 在L.r[s...m]中记录的关键字除L.r[s].key 之外均满足堆的定义，本函数调整L.r[s]的关键字，使L.r[s...m]成为一个大顶堆 int j; L.r[0]=L.r[s]; for ( j=2*s; j<=m; j*=2 ) { // 沿key较大的孩子节点向下筛选 if (j<m &&L.r[j].key=L.r[j].key) { break; } else// 将三者中的最大值放入到根节点的位置，并用s记录此位置 { L.r[s]=L.r[j]; s=j; } } L.r[s]=L.r[0]; } void Heap_Sort(SqList &L) // 堆排序 { int i; for (i=L.length/2; i>0; i--)// build the heap { Heap_Adjust(L,i,L.length); } for (i=L.length; i>1; i--) { L.r[0]=L.r[i];// 将 堆顶记录和当前未经排序子队列（1——i）中 的 最后一个记录 交换 L.r[i]=L.r[1]; L.r[1]=L.r[0]; Heap_Adjust(L,1,i-1);// 将（1——i-1）重新调整为一个大堆 } } void Merge( RedType S[], RedType T[], int i,int m,int n) { // 将有序的S前一部分和后一部分归并为有序的T int j,k; for (j=m+1,k=i;i<=m && j<=n; ++k)// 将S中记录由小到大并入到T中 { if (S[i].key<=S[j].key) { T[k]=S[i++]; } else T[k] = S[j++]; } while(i<=m)// 将剩余的S[i...m]复制到T中 T[k++]=S[i++]; while(j<=n)// 将剩余的S[j...n]复制到T T[k++]=S[j++]; } void MSort(RedType S[],RedType T1[],int s,int t ) { // 将S[s...t]归并为T[s...t]MAXSIZE+1 RedType T2[MAXSIZE+1]; int m; if ( s==t )// 只有一个记录 { T1[s] = S[s]; } else { m=(s+t)/2; // 将S 分为2份 MSort(S,T2,s,m);// 将S归并为有序的T2 MSort(S,T2,m+1,t); // 将S归并为有序的T2 Merge(T2, T1,s,m,t); // 将T1和T2归并到T1中 } } void Merge_Sort(SqList &L)// 归并排序 { // 对顺序表L作归并排序 MSort(L.r,L.r,1,L.length); } // for Radix Sorting // 基数排序中一趟分配的算法 void Distribute (SLNode *r,int i,int f[RADIX],int e[RADIX]) { // 静态链表中的r域中记录已按key[0]——key[i-1]有序 // 本算法按关键字的第i位建立RADIX个链队列，使在同一链队列中关键字的第i位的数值相等； // f、e均为长度为RADIX的指针数组,分别指向各链队列的第一条和最后一条记录 int j,p; for (j=0; j<RADIX; j++) { f[j]=e[j]=0;// 各链队列初始化为空 } for (p=r[0].next; p; p=r[p].next ) { // p总是指向静态链表中的当前节点 j=r[p].key[i]; if (!f[j]) { f[j]=p; } else r[e[j]].next=p; e[j]=p; // 根据r[p]的关键字的第i位的值，将其归入相应的链队列，并修改相应的f、e指针 } } // 基数排序中的一趟收集的算法 void collect ( SLNode *r,int i,int f[RADIX],int e[RADIX] ) { // 本算法按关键字的第i位自小到大地将指针f[0]——f[RADIX-1] 所指向的各 链队列依次 链接成一个静态链表 int j; for ( j=0; !f[j]; j++) { r[0].next=f[j];// r[0].next 指向第一个非空链队列中的第一个节点 } int temp=e[j]; while ( j<RADIX ) { for ( j++; j<RADIX-1 && !f[j]; j++) // 找下一个非空链队列 { if (f[j]) // 链接二个队列 { r[temp].next=f[j]; temp=e[j]; } } } r[temp].next=0; // 将最后一个节点的next域设置为空，完成一趟收集 } void Radix_Sort(SList &L)// 基数排序(链式) { // 定义静态链表L，对L进行基数排序（L.r[0] 为头结点） int i; int e[RADIX],f[RADIX]; for (i=0; i<L.recnum; i++) { L.r[i].next=i+1;// 定义各节点的next 域，使之成为一个前后相连的静态链表 } L.r[L.recnum].next=0;// 定义最后一个结点的next域，使整个静态链表有效终止 for (i=0; i<L.keybit; i++) { // 按最低位优先依次对各关键字进行分配和收集 Distribute( L.r, i, f, e);// 第i躺分配 collect(L.r, i, f, e); // 第i躺收集 } } void display(SqList L) { cout<<"after the sort:"<<endl; for (int i=1;i<=L.length; i++ ) { cout<<L.r[i].key<<"\t"; if (i%5==0 ) { cout<<"\n"; } } }
实验九 排序算法的实现
ai bohang 的博客
03-01 1538
1.实验目的 熟悉排序的方法、过程及原则。掌握插入排序、快速排序、选择排序、归并排序的算法思想及实现方法，掌握其时间复杂度的分析方法。 2.实验内容 定义待排序序列的存储结构。验证插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序中各排序方法中的一、二个排序算法。 插入类排序：直接插入排序、希尔排序 交换类排序：冒泡排序、快速排序 选择类排序：简单选择排序、堆...
数据结构 内部排序（算法介绍、超详细的C++代码解释和算法评价）
最新发布
Gelercat的博客
12-08 590
讲解了内部排序的几种经典算法，用C++实现，可运行，详细注释带你看懂代码
6-1 顺序表的查找操作 (10分)
qq_45728926的博客
05-29 2119
本题要求实现一个函数，要求从顺序表中查找指定元素，并返回第一个查找成功的元素在表中的位置序号，若查找失败，则返回0； 函数接口定义： int LocateElem(SqList L,ElemType e); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int length; }SqList; 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 5 type
C语言实现基数排序 (数据结构 严蔚敏版)
u013678269的博客
03-14 599
C语言实现基数排序 (数据结构 严蔚敏版) 原代码 #include <stdio.h> #define MAX_NUM_OF_KEY 3 #define RADIX 10 #define MAX_SPACE 10 typedef struct { int keys[MAX_NUM_OF_KEY]; int next; }SLCell; typedef struct { SLCell r[MAX_SPACE]; int keynum; int recnum
基数排序
Sponge_bob_的博客
09-13 284
#include<iostream> #define MAXNUM_KEY 8 #define RADIX 10 //关键字的基数，此时是十进制整数的基数 #define MAX_SPACE 1000 typedef int KeyType; typedef struct{ KeyType keys[MAXNUM_KEY]; InfoType otheritems; int next; }SLCell;//静态链表的结点类型 typedef struct{ SLCell r[MA
SCAU------8646 基数排序
zg
05-21 1261
时间限制:1000MS 代码长度限制:10KB 题型: 编程题 语言: G++;GCC Description 用函数实现基数排序，并输出每次分配收集后排序的结果 输入格式 第一行：键盘输入待排序关键的个数n 第二行：输入n个待排序关键字，用空格分隔数据 输出格式 每行输出每趟每次分配收集后排序的结果，数据之间用一个空格分隔 输入样例 10 278 109 063 930 589 184 505 069 008 083 输出样例 930 063 083 184 505 278 008 109 589
谭浩强C语言数据结构-线性表与链式存储解析
"谭浩强C语言数据结构(“关键字”文档)共94张.pptx" 这篇资源主要涵盖了数据结构的基础知识，特别是在C语言环境下。数据结构是计算机科学中的重要概念，它研究如何组织和管理数据，以便于高效地进行操作。数据可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值