数据结构实验报告六 排序

最新推荐文章于 2024-01-16 15:20:17 发布
最新推荐文章于 2024-01-16 15:20:17 发布
阅读量8.6k 收藏 99
点赞数 16
分类专栏： 数据结构实训 文章标签： 数据结构 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_M_R_/article/details/112007581
版权

一、实验目的

1、掌握内部排序的基本算法；
2、分析比较内部排序算法的效率。

二、实验内容和要求

1.运行下面程序：

#include <stdlib.h>
#include <stdio.h>
#define MAX 50
int slist[MAX]; /*待排序序列*/

void insertSort(int list[], int n);
void createList(int list[], int *n);
void printList(int list[], int n);
void heapAdjust(int list[], int u, int v);
void heapSort(int list[], int n);

/*直接插入排序*/
void insertSort(int list[], int n)
{
	int i = 1, j = 0, node = 0, count = 1;
	printf("对序列进行直接插入排序：\n");
	printf("初始序列为：");
	printList(list, n);
	for(i = 2; i <= n; i++)
	{
		node = list[i];
		j = i - 1;
		while(j >= 0 && node < list[j])
		{
			list[j+1] = list[j];
			--j;
		}
		list[j+1] = node;
		printf("第%d次排序结果：", count++);
		printList(list, n);
	}
}
/*堆排序*/
void heapAdjust(int list[], int u, int v)
{
	int i = u, j , temp = list[i];
		j = 2 * i;
	while (j <= v)
	{
		if(j < v && list[j] < list[j+1])
			j++; /*若右孩子较大，则把j修改为右孩子的下标*/
		if(temp < list[j])
		{
			list[i] = list[j]; /*将list[j]调到父亲的位置上*/
			i = j;
			j = 2 * i; /*修改i和j的值，以便继续向下筛选*/
		}
		else
			break; /*筛选完成，终止循环*/
	}
	list[i] = temp; /*被筛结点的值放入最终位置*/
}
void heapSort(int list[], int n)
{
	int i = 0, temp = 0, count = 1;
	printf("对序列进行堆排序：\n");
	printf("初始序列为：");
	printList(list, n);
	for (i = n  / 2; i > 0; i--)
		heapAdjust(list, i, n); /*建立初始堆*/
	printf("建立的初始堆为：");
	printList(list, n);
	for(i = n ; i > 1; i--)
	{/*循环，完成堆排序*/
		temp = list[1];
		list[1] = list[i];
		list[i] = temp; /*将第一个元素同当前区间内最后一个元素对换*/
		heapAdjust(list, 1 , i-1); /*筛选出list[1]结点*/
		printf("第%d次排序结果：", count++);
		printList(list, n);
	}
}
/*生成待排序序列*/
void createList(int list[], int *n)
{
     int i = 1,a;
     printf("请输入待排序序列(长度小于50,以输入一个字符结束):\n");
     while(scanf("%d",&a)==1)
     {
        list[i] = a;
        i++;
     }
     *n=i-1;
     getchar();
}
/*输出排序结果*/
void printList(int list[], int n)
{
     int i = 1;
     for(; i <= n; i++)
     {
		 printf("  %d  ", list[i]);
		 if(i % 10 ==0 && i != 0)
			 printf("\n");
     }
	 printf("\n");
}

int main()
{
	int choice=1,length;
	while(choice!=0)
	{
		printf("\n");
		printf("***** 内部排序算法演示程序 *****\n");
		printf("\n1. 直接插入排序 \n");
		printf("\n2. 堆排序 \n");
		printf("\n0. 退出\n");
		printf("\n请选择：");
		scanf("%d", &choice);
		getchar();
        switch(choice)
		{
		case 1:
			{
				createList(slist, &length);
				insertSort(slist, length);
				break;
			}
		case 2:
			{
				createList(slist, &length);
				heapSort(slist, length);
				break;
			}
		default:choice=0;
		}
		printf("\n");
	}
    return 0;
}

输入待排序序列：49 38 65 97 13 27 49（以输入一个字符作为结束）

1） 直接插入排序运行结果（写出每一趟的状态）：

对序列进行直接插入排序：
初始序列为： 49 38 65 97 13 27 49
第1次排序结果： 38 49 65 97 13 27 49
第2次排序结果： 38 49 65 97 13 27 49
第3次排序结果： 38 49 65 97 13 27 49
第4次排序结果： 13 38 49 65 97 27 49
第5次排序结果： 13 27 38 49 65 97 49
第6次排序结果： 13 27 38 49 49 65 97
实验六（1）

2）堆排序运行结果（写出每一趟的状态）：

对序列进行堆排序：
初始序列为： 49 38 65 97 13 27 49
建立的初始堆为： 97 49 65 38 13 27 49
第1次排序结果： 65 49 49 38 13 27 97
第2次排序结果： 49 38 49 27 13 65 97
第3次排序结果： 49 38 13 27 49 65 97
第4次排序结果： 38 27 13 49 49 65 97
第5次排序结果： 27 13 38 49 49 65 97
第6次排序结果： 13 27 38 49 49 65 97
实验六（2）

2、在1题中补充希尔排序算法。

算法代码：
void shellSort(int list[], int n)
{
    int i,j,d,temp,count=1;
	printf("对序列进行希尔排序：\n");
	printf("初始序列为：");
	printList(list, n);
    for(d=n/2;d>0;d/=2)
    {
        for(i=d+1;i<=n;i++)
        {
            temp=list[i];
            j=i-d;
            while(j>=1&&temp<list[j])
            {
                list[j+d]=list[j];
                j=j-d;
            }
            list[j+d]=temp;
        }
        printf("第%d次排序结果：", count++);
        printList(list, n);
    }
}

输入待排序序列：49 38 65 97 13 27 49（以输入一个字符作为结束）

运行结果（写出每一趟的状态）：

对序列进行希尔排序：
初始序列为： 49 38 65 97 13 27 49
第1次排序结果： 49 13 27 49 38 65 97
第2次排序结果： 13 27 38 49 49 65 97
实验六（3）

3、在1题中补充快速排序算法。

算法代码：
int count=1;
int Partition(int list[], int i, int j, int n)
{
    list[0]=list[i];
    int pivotkey=list[i];
    while(i<j)
    {
        while(i<j&&list[j]>=pivotkey)
            --j;
        list[i]=list[j];
        while(i<j&&list[i]<=pivotkey)
            ++i;
        list[j]=list[i];
    }
    list[i]=list[0];
    printf("第%d次排序结果：", count++);
    printList(list, n);
    return i;
}
void quickSort(int list[], int i, int j, int n)
{
    int pivot;
    if(i<j)
    {
        pivot=Partition(list, i, j, n);
        quickSort(list,i,pivot-1,n);
        quickSort(list,pivot+1,j,n);
    }
}

输入待排序序列：49 38 65 97 13 27 49（以输入一个字符作为结束）

运行结果（写出每一趟的状态）：

对序列进行快速排序：
初始序列为： 49 38 65 97 13 27 49
第1次排序结果： 27 38 13 49 97 65 49
第2次排序结果： 13 27 38 49 97 65 49
第3次排序结果： 13 27 38 49 49 65 97
第4次排序结果： 13 27 38 49 49 65 97
实验六（4）

三、补充后完整代码

#include <stdlib.h>
#include <stdio.h>
#define MAX 50
int slist[MAX]; /*待排序序列*/

void insertSort(int list[], int n);
void createList(int list[], int *n);
void printList(int list[], int n);
void heapAdjust(int list[], int u, int v);
void heapSort(int list[], int n);
void shellSort(int list[], int n);
int Partition(int list[], int i, int j, int n);
void quickSort(int list[], int i, int j, int n);

/*直接插入排序*/
void insertSort(int list[], int n)
{
    int i = 1, j = 0, node = 0, count = 1;
    printf("对序列进行直接插入排序：\n");
    printf("初始序列为：");
    printList(list, n);
    for(i = 2; i <= n; i++)
    {
        node = list[i];
        j = i - 1;
        while(j >= 0 && node < list[j])
        {
            list[j+1] = list[j];
            --j;
        }
        list[j+1] = node;
        printf("第%d次排序结果：", count++);
        printList(list, n);
    }
}
/*堆排序*/
void heapAdjust(int list[], int u, int v)
{
    int i = u, j, temp = list[i];
    j = 2 * i;
    while (j <= v)
    {
        if(j < v && list[j] < list[j+1])
            j++; /*若右孩子较大，则把j修改为右孩子的下标*/
        if(temp < list[j])
        {
            list[i] = list[j]; /*将list[j]调到父亲的位置上*/
            i = j;
            j = 2 * i; /*修改i和j的值，以便继续向下筛选*/
        }
        else
            break; /*筛选完成，终止循环*/
    }
    list[i] = temp; /*被筛结点的值放入最终位置*/
}
void heapSort(int list[], int n)
{
    int i = 0, temp = 0, count = 1;
    printf("对序列进行堆排序：\n");
    printf("初始序列为：");
    printList(list, n);
    for (i = n  / 2; i > 0; i--)
        heapAdjust(list, i, n); /*建立初始堆*/
    printf("建立的初始堆为：");
    printList(list, n);
    for(i = n ; i > 1; i--)
    {
        /*循环，完成堆排序*/
        temp = list[1];
        list[1] = list[i];
        list[i] = temp; /*将第一个元素同当前区间内最后一个元素对换*/
        heapAdjust(list, 1, i-1);  /*筛选出list[1]结点*/
        printf("第%d次排序结果：", count++);
        printList(list, n);
    }
}
/*希尔排序*/
void shellSort(int list[], int n)
{
    int i,j,d,temp,count=1;
    printf("对序列进行希尔排序：\n");
    printf("初始序列为：");
    printList(list, n);
    for(d=n/2; d>0; d/=2)
    {
        for(i=d+1; i<=n; i++)
        {
            temp=list[i];
            j=i-d;
            while(j>=1&&temp<list[j])
            {
                list[j+d]=list[j];
                j=j-d;
            }
            list[j+d]=temp;
        }
        printf("第%d次排序结果：", count++);
        printList(list, n);
    }
}
/*快速排序*/
int count=1;
int Partition(int list[], int i, int j, int n)
{
    list[0]=list[i];
    int pivotkey=list[i];
    while(i<j)
    {
        while(i<j&&list[j]>=pivotkey)
            --j;
        list[i]=list[j];
        while(i<j&&list[i]<=pivotkey)
            ++i;
        list[j]=list[i];
    }
    list[i]=list[0];
    printf("第%d次排序结果：", count++);
    printList(list, n);
    return i;
}
void quickSort(int list[], int i, int j, int n)
{
    int pivot;
    if(i<j)
    {
        pivot=Partition(list, i, j, n);
        quickSort(list,i,pivot-1,n);
        quickSort(list,pivot+1,j,n);
    }
}
/*生成待排序序列*/
void createList(int list[], int *n)
{
    int i = 1,a;
    printf("请输入待排序序列(长度小于50,以输入一个字符结束):\n");
    while(scanf("%d",&a)==1)
    {
        list[i] = a;
        i++;
    }
    *n=i-1;
    getchar();
}
/*输出排序结果*/
void printList(int list[], int n)
{
    int i = 1;
    for(; i <= n; i++)
    {
        printf("  %d  ", list[i]);
        if(i % 10 ==0 && i != 0)
            printf("\n");
    }
    printf("\n");
}

int main()
{
    int choice=1,length;
    while(choice!=0)
    {
        printf("\n");
        printf("***** 内部排序算法演示程序 *****\n");
        printf("\n1. 直接插入排序 \n");
        printf("\n2. 堆排序 \n");
        printf("\n3. 希尔排序 \n");
        printf("\n4. 快速排序 \n");
        printf("\n0. 退出\n");
        printf("\n请选择：");
        scanf("%d", &choice);
        getchar();
        switch(choice)
        {
        case 1:
        {
            createList(slist, &length);
            insertSort(slist, length);
            break;
        }
        case 2:
        {
            createList(slist, &length);
            heapSort(slist, length);
            break;
        }
        case 3:
        {
            createList(slist, &length);
            shellSort(slist, length);
            break;
        }
        case 4:
        {
            createList(slist, &length);
            printf("对序列进行快速排序：\n");
            printf("初始序列为：");
            printList(slist, length);
            quickSort(slist, 1, length, length);
            break;
        }
        default:
            choice=0;
        }
        printf("\n");
    }
    return 0;
}
G_M_R_（已摆烂）
关注
  • 16
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验报告——排序算法设计及分析（排序单链表）
weixin_45823684的博客
01-13 3657
一、实验目的和要求 通过学习多种排序算法，体会对同一种操作多种不同的算法设计；通过比较各排序算法对于数据存储结构的要求，体会算法设计不依赖于数据存储结构，而算法实现依赖于数据存储结构:通过分析排序算法的效率，研究如何进一步提高算法性能的方法。 要求掌握每种排序算法思路、算法描述、算法设计 与算法实现手段，掌握排序算法时间复杂度和空间复杂度的分析方法，具有排序算法的设计能力。 二、实验题目 实验一：由单链表构造排序单链表 public SortedSinglyList(SinglyList&lt
数据结构实验六排序
而濡木染
06-04 3355
数据结构实验六排序 #include #include #define Maxsize 100 using namespace std; typedef int KeyType; typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo; } RedType; typ
数据结构-——排序
weixin_30273931的博客
12-11 454
#include <stdlib.h> #include <stdio.h> #define MAX 50 int slist[MAX]; /*待排序序列*/ void XierSort(int list[], int n); void insertSort(int list[], int n); void createList(i...
手敲一遍数据结构和排序算法 Java
热门推荐
xfxuezhang.cn
12-04 1万+
学习经典排序算法
数据结构实验报告（四）——查找和排序算法
半岛铁盒里
01-14 1万+
数据结构实验报告——查找和排序
数据结构排序实验
qq_52743307的博客
01-13 1558
输出共1行，共有10个整数，表示5种排序方法排序的关键字比较次数和移动次数，即为：直接插入排序比较次数、直接插入排序移动次数、冒泡排序比较次数、冒泡排序移动次数、快速排序比较次数、快速排序移动次数、简单选择排序比较次数、简单选择排序移动次数、归并排序比较次数、归并排序移动次数。快速排序：基本思想：通过一趟排序，将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，以达到整个序列有序。在算法的适当地方加入计数操作，计算关键字的比较次数和移动次数。
数据结构实验报告-排序、查找及其应用
最新发布
m0_46529566的博客
01-16 1604
本次实验主要考察排序算法及其应用，对查找的要求不高。题目一和题目三主要采取快速排序对给出的完全随机无序的数据进行排序，题目二中根据题目要求以O(n)的时间复杂度解决问题且数据范围小，采用桶排序进行排序。排序在题目中是作为一个解决问题的工具，实验的主要逻辑是基于已有序的数据来完成的。题目一中需要根据题目给出的曼哈顿距离，判断出在x轴和y轴上分析问题时独立的，互不干扰。题目二在桶排序后，相邻年龄的邮递员在桶数组中位置也是相邻的，维护一个间隔最大值即可。
数据结构实验报告（六）
cqc1161的博客
12-09 7633
数据结构实验报告（六） 一、实验名称 实验六  图的实验1——图的邻接矩阵存储实现 二、 实验目的 1、  熟练理解图的相关概念； 2、  掌握图的邻接矩阵的存储方法的实现； 3、  学会图的遍历算法 三、 实验内容 1、自己确定一个简单无向图（顶点数、和相关结点信息）利用邻接矩阵来实现存储。实现图的构造，并完成： 1）  用深度优先和广度优先两种算法对图进行遍历，输出顶点序列数
数据结构实验报告-排序.doc
08-25
数据结构实验报告-排序 本实验报告主要介绍了三种排序算法：直接插入排序、折半插入排序和希尔排序。每种排序算法都有其特点和优缺点，本报告将对这三种排序算法进行详细的介绍和分析。 一、直接插入排序 直接...
数据结构实验报告——排序.docx
12-05
数据结构实验报告主要关注的是排序算法的实现和比较。在这个实验中，学生被要求实现九种不同的排序算法，包括插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序以及基数排序（后三种是选做...
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
数据结构排序实验报告
12-17
南昌大学科学技术学院实验报告，《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法
数据结构实验报告--多关键字排序.doc
11-12
在本次数据结构实验报告中，主要涉及了多种排序算法，包括直接插入排序、希尔排序、简单选择排序、冒泡排序、快速排序、堆排序以及归并排序。这些排序算法的核心在于通过特定策略调整元素的位置，以达到排序的目的。...
数据结构实验报告 排序.doc
09-29
数据结构实验报告主要关注了排序算法的理解和实现，包括希尔排序、快速排序和堆排序这三种经典的排序算法。这些算法都是解决如何有效地组织和排列数据序列的问题，它们各自有不同的设计思路、时间复杂度和空间复杂度...
数据结构排序算法实验报告c语言
hqm793899006的博客
12-12 4118
题目描述 设计并实现一个管理系统（学生管理、图书管理、产品管理等等），系统中需包含1000条以上的记录，系统至少包含以下功能： (1) 自动生成记录信息（或者从文件中读取）； (2) 逐条显示所有记录信息； (3) 利用时间复杂度O(n2)的排序算法（例如直接插入排序或者折半插入排序）按照关键字进行排序； (4) 利用时间复杂度O(nlogn)的排序算法（例如快速排序）按照关键字进行排序； (5) 程序中统计（3）和（4）的算法在数据正序、逆序、乱序情况下的比较次数与移动次数并输出，在报告中对比较次数与移动
数据结构实验10----排序
qq_60737285的博客
07-20 694
对快速排序、大根堆排序，两种排序方法进行比较，写出大根堆排序算法。并对它们最坏、最好，平均情况进行比较分析。并列举一个实例，上机验证说明。
数据结构——排序总结
m0_52711790的博客
12-14 3165
一、排序的概念 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。（递增或递减） 二、排序的分类 一图以蔽之： 三、交换排序（省略冒泡） 1、概念 快速排序： 又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要 O(n log2 n)（大O符号）次比较。在最坏状况下则需要 O(n^2)次比较，但这种状况并不常见。事实上，快速排序 (n lo...
数据结构 实验报告01
zRNA__的博客
02-29 2059
一、实验目的和要求 完成尽可能多的数据排序，并显示运行时间。 二、实验环境 编译器：Vscode DevC++ 系统：Windows10 CPU：i5-8265U@1.60GHz 数据：int范围（排除桶排序，基数排序，计数排序） 三、实验内容 1. 选择合适的排序算法 2. 确定可排序数据长度最大值 3. 固定可排序数据内容 4. 显示运行时间 四、实验过程 4.1...
数据结构实验报告：查找和排序的应用
2码8改
01-30 1万+
                                   学生信息管理系统 一、实验目的 1、本实验可以使学生更进一步巩固各种查找和排序的基本知识。 2、学会比较各种排序与查找算法的优劣。 3、学会针对所给问题选用最适合的算法。 4、掌握利用常用的排序与选择算法的思想来解决一般问题的方法和技巧。 二、实验内容 [问题描述] 　学生信息管理系统 [基本要求] 设计一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值