c语言内部排序实验报告,几种常见内部排序算法分析与实现(C语言描述)

最新推荐文章于 2023-03-10 11:16:51 发布
最新推荐文章于 2023-03-10 11:16:51 发布
阅读量778 收藏
点赞数
文章标签： c语言内部排序实验报告

1. 插入排序

1.1 算法思想

插入排序算法的主要思想是:

1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未

排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排

序 部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为

整个待排序序列.

2) 从B中取第一个元素(b), 然后从后往前依次从A中取出元素(a)与b比较, 若b

a往后移动一个位置; 否则, 为b找到了其正确位置(a的位置的下一个位置), 把b放入

该位置(记住: A是已经排序好的).

3) 对A增加一个元素: b, 对B减少一个元素: b.

4) 重复 2 - 3 步骤, 直至B为空.

1.2 实现

[cpp] view plain

copy

// #c---

/*==========================================================================*

* @Description:

* 插入排序

*

* @Param base

* @Param nmemb

* @Param size

* @Param compar

*==========================================================================*/

void Sort_insertSort(void *base, size_t nmemb, size_t size,

int(*compar)(const void *, const void *))

{

#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )

assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);

char *i, *j, t, *b, *e;

char *bot = (char*)base;

char *top = bot + nmemb * size;

for ( i = bot + size; i < top; i += size )

{

for ( j = i; (j-=size) >= bot && compar(i, j) < 0; )

{ }

if ( i != (j+=size) )

{

for ( b = j, e = i-1; b < e; b++, e-- )

SWAP(*b, *e, t);

for ( b = i, e = i+size-1; b < e; b++, e-- )

SWAP(*b, *e, t);

for ( b = j, e = i+size-1; b < e; b++, e-- )

SWAP(*b, *e, t);

}

}

#undef SWAP

}

// #c---end

1.3 算法复杂度分析

从插入排序的算法思想中, 我们很容易得知其空间复杂度为 O(1), 时间复杂度为 O(N^2).

2. 选择排序

2.1 算法思想

选择排序算法的主要思想是:

1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未

排序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排

序部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整

个待排序序列.

2) 遍历B中的每一个元素, 找到B中的最小元素(b), 把b与A之后的那个元素交换.

3) 对A增加一个元素: b, 对B减少一个元素: b.

4) 重复 2 - 3 步骤, 直至B为空.

2.2 实现

[cpp] view plain

copy

// #c---

/*==========================================================================*

* @Description:

* 选择排序

*

* @Param base

* @Param nmemb

* @Param size

* @Param compar

*

*==========================================================================*/

void Sort_selectSort(void *base, size_t nmemb, size_t size,

int(*compar)(const void *, const void *))

{

#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )

assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);

int s;

char t, *i, *j, *min;

char *left = base;

char *right = left + (nmemb - 1) * size;

for ( i = left; i <= right - size; i += size )

{

min = i;

for ( j = i + size; j <= right; j += size )

{

if ( compar(j, min) < 0 )

min = j;

}

if ( i != min )

for ( s = 0; s < size; s++ )

SWAP(*(i+s), *(min+s), t);

}

#undef SWAP

}

// #c---end

2.3 算法复杂度分析

选择排序的空间复杂度为 O(1), 时间复杂度为 O(N^2).

3. 冒泡排序

3.1 算法思想

冒泡排序算法的主要思想是:

1) 把要排序的序列分为两部分: 已排序部分(A)和未排序部分(B); 由于已排序部分和未排

序部分有显示的位置分隔, 我们也可以将已排序部分称之为序列的前部分, 将未排序

部分称之为序列的后部分. 显然在算法开始前, 已排序部分为空, 未排序部分为整个

待排序序列.

2) 对B进行从后往前遍历, 取所有相邻的两个元素对(b1和b2, b1较靠后, b2较靠前)作比

较; 若b1

置到了正确的位置上.

3) 对A增加一个元素: b, 对B减少一个元素: b.

4) 重复 2 - 3 步骤, 直至B为空.

3.2 实现

[cpp] view plain

copy

// #c---

/*==========================================================================*

* @Description:

* 冒泡排序

*

* @Param base

* @Param nmemb

* @Param size

* @Param compar

*

*==========================================================================*/

void Sort_bubbleSort(void *base, size_t nmemb, size_t size,

int(*compar)(const void *, const void *))

{

#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )

assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);

int s, isSwap;

char t, *i, *j;

char *left = base;

char *right = base + (nmemb - 1) * size;

for ( i = left; i < right; i += size )

{

isSwap = 0;

for ( j = right; j > i; j -= size )

{

if ( compar(j, j-size) < 0 )

{

isSwap = 1;

for ( s = 0; s < size; s++ )

SWAP(*(j+s), *(j-size+s), t);

}

}

if ( isSwap == 0 )

break;

}

#undef SWAP

}

// #c---end

3.3 算法复杂度分析

冒泡排序的空间复杂度为 O(1), 时间复杂度为 O(N^2).

4. 合并排序

4.1 算法思想

1) 将序列分为两个子序列.

2) 对两个子序列递归地进行合并排序.

3) 把此两个子序列(已排序)合并为一个有序序列.

4.2 实现

[cpp] view plain

copy

// #c---

/*==========================================================================*

* @Description:

* 合并排序之合并例程

*

* @Param left

* @Param center

* @Param right

* @Param size

* @Param compar

* @Param tmparray

*

*==========================================================================*/

static void SortST_memge(char *left, char *center, char *right, int size,

int(*compar)(const void *, const void *), char *tmparray)

{

#define COPY_SIZE(d, s) \

do { \

for ( i = 0; i < size; i++ ) \

*((d) + i) = *((s) + i); \

} while ( 0 )

int i;

char *Lright = center;

char *Rright = right;

char *Lpcur = left;

char *Rpcur = center + size;

char *Tpcur = tmparray;

for ( ; Lpcur <= Lright && Rpcur <= Rright; Tpcur += size )

{

if ( compar(Lpcur, Rpcur) < 0 )

{

COPY_SIZE(Tpcur, Lpcur);

Lpcur += size;

}

else

{

COPY_SIZE(Tpcur, Rpcur);

Rpcur += size;

}

}

for ( ; Lpcur <= Lright; Lpcur += size, Tpcur += size )

COPY_SIZE(Tpcur, Lpcur);

for ( ; Rpcur <= Rright; Rpcur += size, Tpcur += size )

COPY_SIZE(Tpcur, Rpcur);

for ( Lpcur = left; Lpcur <= right; Lpcur += size, tmparray += size )

COPY_SIZE(Lpcur, tmparray);

#undef COPY_SIZE

}

/*==========================================================================*

* @Description:

* 合并排序

*

* @Param left

* @Param right

* @Param size

* @Param compar

* @Param tmparray

*

*==========================================================================*/

static void Sort_mergeSort_priv(char *left, char *right, int size,

int(*compar)(const void *, const void *), char *tmparray)

{

if ( left < right )

{

char *center = left + ((right - left) / size / 2) * size;

Sort_mergeSort_priv(left, center, size, compar, tmparray);

Sort_mergeSort_priv(center + size, right, size, compar, tmparray);

SortST_memge(left, center, right, size, compar, tmparray);

}

}

/*==========================================================================*

* @Description:

* 合并排序驱动例程

*

* @Param base

* @Param nmemb

* @Param size

* @Param compar

*

*==========================================================================*/

void Sort_mergeSort(void *base, size_t nmemb, size_t size,

int(*compar)(const void *, const void *))

{

assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);

char *left = base;

char *right = base + (nmemb - 1) * size;

char *tmparray;

tmparray = malloc(nmemb * size);

if ( tmparray == NULL )

return;

Sort_mergeSort_priv(left, right, size, compar, tmparray);

free(tmparray);

}

// #c---end

4.3 算法复杂度分析

归并排序算法是运用分治思想的典范, 其空间复杂度为 O(N), 时间复杂度为 O(NlogN).

5. 快速排序

5.1 算法思想

1) 从输入序列中任意选取一个元素(k)作枢纽元;

2) 遍历整个序列, 对于小于等于k的元素放在左边(L), 对于大于k的元素放在右边(R);

3) 对子序列L和R递归地进行快速排序; 直到序列中只有一个若零个元素, 退出递归.

5.2 实现

[cpp] view plain

copy

// #c---

/*==========================================================================*

* @Description:

* 取三者间的中间值

*

* @Param left

* @Param right

* @Param size

* @Param compar

*

* @Returns:

*==========================================================================*/

static char* Sort_median3(char *left, char *right, int size,

int(*compar)(const void *, const void *))

{

#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )

int s;

char t;

// char *center = left + (right - left) / 2; // 错误!!

// 每一步计算都必须取整! 才不至于最后的结果位于字节内!

char *center = left + (((right - left) / size) / 2) * size;

if ( compar(left, center) > 0 )

for ( s = 0; s < size; s++ )

SWAP(*(left+s), *(center+s), t);

if ( compar(left, right) > 0 )

for ( s = 0; s < size; s++ )

SWAP(*(left+s), *(right+s), t);

if ( compar(center, right) > 0 )

for ( s = 0; s < size; s++ )

SWAP(*(center+s), *(right+s), t);

for ( s = 0; s < size; s++ )

SWAP(*(center+s), *(right-size+s), t);

return right - size;

#undef SWAP

}

/*==========================================================================*

* @Description:

* 快速排序

*

* @Param left

* @Param right

* @Param size

* @Param compar

*==========================================================================*/

static void Sort_quicklySort_priv(char *left, char *right, int size,

int(*compar)(const void *, const void *))

{

#define SWAP(a, b, t) ( (t)=(a), (a)=(b), (b)=(t) )

int s;

char t, *i, *j, *pivot;

if ( left + SORT_CUTOFF * size <= right )

{

pivot = Sort_median3(left, right, size, compar);

i = left;

j = right - size;

for ( ; ; )

{

for ( i += size; compar(i, pivot) < 0; i += size ) { }

for ( j -= size; compar(j, pivot) > 0; j -= size ) { }

if ( i < j )

{

for ( s = 0; s < size; s++ )

SWAP(*(i+s), *(j+s), t);

}

else

break;

}

for ( s = 0; s < size; s++ )

SWAP(*(i+s), *(right-size+s), t);

Sort_quicklySort_priv(left, i - size, size, compar);

Sort_quicklySort_priv(i + size, right, size, compar);

}

else

Sort_insertSort(left, (right-left)/size + 1, size, compar);

#undef SWAP

}

/*==========================================================================*

* @Description:

* 快速排序驱动例程

*

* @Param base

* @Param nmemb

* @Param size

* @Param compar

*==========================================================================*/

void Sort_quicklySort(void *base, size_t nmemb, size_t size,

int(*compar)(const void *, const void *))

{

assert(base != NULL && nmemb >= 1 && size >= 1 && compar != NULL);

if ( nmemb <= 1 )

return;

if ( nmemb >= SORT_CUTOFF )

Sort_quicklySort_priv(base, base + (nmemb-1)*size, size, compar);

else

Sort_insertSort(base, nmemb, size, compar);

}

// #c---end

5.3 算法复杂度分析

快速排序算法也是运用分治思想, 其空间复杂度为 O(1), 时间复杂度为 O(NlogN).

本文出自：亿恩科技【www.enkj.com】

晓剑15703836037
关注
c语言选择排序法实验报告,排序算法设计和比较实验报告.doc
weixin_35336727的博客
05-22 624
排序算法设计和比较实验报告《数据结构》实验报告五专业： 自动化 班级： 0710 学号： 0901071002 姓名： 日期： 2009. 12.15 程序：排序算法设计比较实验　排序算法问题描述：利用直接插入排序、冒泡排序、快速排序二、程序设计...
数据结构实验：内部排序算法的性能分析
littlekingw的博客
08-15 5689
文章目录前言一、问题描述二、问题分析三、实验结果及分析（1）实验数据描述（2）实验结果（3）性能分析四、源代码 前言 记录下本学期的数据结构实验 本实验主要集中于比较几种内部排序算法 提示：以下是本篇文章正文内容，下面案例可供参考 一、问题描述 设计一个程序，对各种内部排序算法的关键字比较次数和移动次数进行比较。具体要求如下： ⑴ 编程实现内部排序算法：编程实现直接插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，堆排序，归并排序算法。 ⑵ 要求数据规模：待排序数据类型不限（整型或浮点型），读取..
十大经典排序算法(Java版本)
程序IT圈
04-21 421
本文来源：https://github.com/hustcc/JS-Sorting-Algorithm上篇文章分享了排序算法(Python版本):最常见的排序算法（Python版）,很多...
数据结构c语言版快速排序（实验报告）
07-22
键盘输入杂乱数列，编写程序进行一趟快速排序，并输出结果。
快速排序c语言实验报告,《算法设计与分析》实验报告快速排序.doc
weixin_33803878的博客
05-23 1343
《算法设计与分析》实验报告快速排序.doc〈〈算法分析与设计〉〉实验报告题目：快速排序姓名：于文静班级：计科H203学号：201216010230指导教师：斬小波完成时间：2015-04-06一、实验题1=1用递归分治法编写Hoare快速排序算法二、实验目的理解时间复杂度的概念。深入地掌握C语言编程。通过编程直观地理解算法分析的意义三、实验要求TOC \o "1-5" \h \z 请使用递归分治法...
各种内部排序方法及其比较实验报告
耗子煨汁的博客
12-11 5595
一、实验目的 掌握各种内部排序的方法并通过实验能够根据不同问题的要求选择合适的排序方法 二、实验内容1 问题描述 定义一个无序序列，使用直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序方法使之有序； 数据结构及算法设计 程序实现 测试 三、实验内容2 问题描述 对直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序进行性能比较； 数据结构及算法设计 运用clock函数计算各类排序花费的时间 clock_t为CPU时钟计时单元
数据结构(C语言版)实验报告-(内部排序算法比较).pdf
最新发布
08-14
《数据结构(C语言版)实验报告——内部排序算法比较》主要关注了六种常见的内部排序算法，即起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序和堆排序，并通过实验来比较这些算法在处理随机数据时的关键字...
广东工业大学_数据结构（内部排序算法）实验报告
06-06
广东工业大学的数据结构实验报告重点关注了几种常见的内部排序算法，包括直接插入排序、选择排序和快速排序。这些算法在不同的场景下具有不同的性能特征。 **直接插入排序**是一种简单直观的排序方法，适用于小规模...
C语言实现与比较五种排序算法
这部分会展示每种排序算法对同一组数据的执行时间及比较次数，通过对比分析不同算法的效率。 五、总结与致谢 最后，报告会总结实验的整体体验，可能包括对各种排序算法优缺点的总结，以及对未来改进的思考。此外，...
排序算法设计与分析实践报告
qq_55582202的博客
09-16 2120
20级陈柏延 10205501441 内容与设计思想 1.设计一个数据生成器，输入参数包括N, s, t, T；可随机生成一个大小为N、数值范围在[s, t]之间、类型为T的数据集合；T包括三种类型（顺序递增、顺序递减、随机取值） 2.编程实现merge sort算法和insertion sort算法。（以下测试都使用第1步的数据生成器） 3.对于顺序递增类型的数据集合而言，在不同数据规模情况下（数据规模为10^2, 10^3, 10^4, 10^5）下，两种算法的运行时间各是多少？
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
C语言 选择排序法
03-16
C语言 排序法 选择排序法
7种简单排序算法的C语言实现
05-19
在VS2005中实现的排序算法，包括：冒泡，插入，选择，希尔，快速，归并，堆排序等。
数据结构排序算法实验报告c语言
hqm793899006的博客
12-12 4191
题目描述 设计并实现一个管理系统（学生管理、图书管理、产品管理等等），系统中需包含1000条以上的记录，系统至少包含以下功能： (1) 自动生成记录信息（或者从文件中读取）； (2) 逐条显示所有记录信息； (3) 利用时间复杂度O(n2)的排序算法（例如直接插入排序或者折半插入排序）按照关键字进行排序； (4) 利用时间复杂度O(nlogn)的排序算法（例如快速排序）按照关键字进行排序； (5) 程序中统计（3）和（4）的算法在数据正序、逆序、乱序情况下的比较次数与移动次数并输出，在报告中对比较次数与移动
c语言程序设计排序算法实验报告,排序算法的实验报告.doc
weixin_34875640的博客
05-17 1337
排序算法的实验报告数据结构实验报告八种排序算法实验报告实验内容编写关于八种排序算法的C语言程序，要求包含直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。实验步骤各种内部排序算法的比较：八种排序算法的复杂度分析(时间与空间)。八种排序算法的C语言编程实现。八种排序算法的比较，包括比较次数、移动次数。稳定性，时间复杂度和空间复杂度?比较时间复杂度函数的情况：时间复...
Java实现八大排序算法
weixin_30342209的博客
02-05 789
本文对常见的排序算法进行了总结。 常见排序算法如下： 直接插入排序 希尔排序 简单选择排序 堆排序 冒泡排序 快速排序 归并排序 基数排序 它们都属于内部排序，也就是只考虑数据量较小仅需要使用内存的排序算法，他们之间关系如下： \[ \begin{cases}内部排序 \begin{cases}插入排序\begin{cases}直接插入排序\\希尔排序\end{cases}\\选择排序\be...
数据结构和算法-003 数组排序 选择排序
weixin_34204057的博客
06-05 97
选择排序1选择排序编辑思想n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：①初始状态：无序区为R[1..n]，有序区为空。②第1趟排序在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。……③第i趟排序第i趟排序开始时，当...
快速排序实验报告 c语言,快速排序算法c语言实验报告.docx
weixin_32896083的博客
05-18 600
快速排序算法c语言实验报告实验六：冒泡法排序　　物理学416班赵增月F12XX日期：XX年10月31日　　一·实验目的1.熟练掌握程序编写步骤；　　2.学习使用冒泡法和选择法排序；　　3.熟练掌握数组的定义和输入输出方法。　　二·实验器材　　1.电子计算机；　　三·实验内容与流程　　1.流程图　　冒泡法　　(2)选择法2.输入程序如下：冒泡法#includevoidmain(){inta[10];...
《算法分析与设计》排序算法性能测试实验报告
m0_53295129的博客
03-10 1738
排序算法性能测试
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值