GDPU 数据结构 天码行空13

2024-01-25 11:20

本文主要是介绍GDPU 数据结构 天码行空13,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

  • 一、【实验目的】
  • 二、【实验内容】
  • 三、实验源代码
  • 四、实验结果
  • 五、实验总结

一、【实验目的】

(1) 理解插入排序算法的实现过程;

(2)理解不同排序算法的时间复杂度及适用环境;

(3)了解算法性能测试的基本方法。

二、【实验内容】

1、以下是一个通过随机数来测试排序算法运行时间的程序,中间留出了加入排序算法的部分。其中可以通过修改RANDNUM的值来更改测试的数据量:

#include "stdio.h"
#include <stdlib.h>
#include <time.h>
#define RANDNUM 10000 //随机数的个数
void main()
{ int iRandNum[RANDNUM];//存放随机数clock_t first,second; //记录开始和结束时间(以毫秒为单位)int i;for(i=0;i<RANDNUM;i++){//产生1万个随机数iRandNum[i]=rand()%RANDNUM;}first=clock(); //开始时间//此处加入排序程序second=clock();//结束时间//显示排序算法所用的时间
}

2、从选择、交换、插入排序算法中任选至少3种排序算法(希尔排序、快速排序、堆排序三选二),在无序状态下进行多次运行,记录运行时间,并比较测试结果。
提示:在程序的实现过程中要用到以下函数,请大家在实验之前自学这几个函数的用法:

1)随机函数rand()

  1. 时间函数clock()

实验参考界面如下(此界面测试数据仅选用了两种算法,提交的报告以实验要求为准。):

在这里插入图片描述

三、实验源代码

#include "stdio.h"
#include <iostream>
#include<cstring>
#include <stdlib.h>
#include <time.h>
using namespace std;int N = 10000; //随机数的个数//插入入排序
void insertSort(int arr[])
{int n = N;for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;// 将 key 插入到已排序的序列中while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j--;}arr[j + 1] = key;}
}//希尔排序
void shellSort(int arr[]) {int n = N;int i, j, gap, temp;for (gap = n / 2; gap > 0; gap /= 2) {for (i = gap; i < n; i++) {temp = arr[i];for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {arr[j] = arr[j - gap];}arr[j] = temp;}}
}//快速排序
void quickSort(int s[], int l, int r)
{if (l < r){//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1int i = l, j = r, x = s[l];while (i < j){while(i < j && s[j] >= x) // 从右向左找第一个小于x的数j--;  if(i < j) s[i++] = s[j];while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数i++;  if(i < j) s[j--] = s[i];}s[i] = x;quickSort(s, l, i - 1); // 递归调用 quickSort(s, i + 1, r);}
}//堆排序
void swap(int *a, int *b) {int temp = *b;*b = *a;*a = temp;
}void max_heapify(int arr[], int start, int end) {// 建立父節點指標和子節點指標int dad = start;int son = dad * 2 + 1;while (son <= end) { // 若子節點指標在範圍內才做比較if (son + 1 <= end && arr[son] < arr[son + 1]) // 先比較兩個子節點大小,選擇最大的son++;if (arr[dad] > arr[son]) //如果父節點大於子節點代表調整完畢,直接跳出函數return;else { // 否則交換父子內容再繼續子節點和孫節點比較swap(&arr[dad], &arr[son]);dad = son;son = dad * 2 + 1;}}
}void heapSort(int arr[], int len) {int i;// 初始化,i從最後一個父節點開始調整for (i = len / 2 - 1; i >= 0; i--)max_heapify(arr, i, len - 1);// 先將第一個元素和已排好元素前一位做交換,再重新調整,直到排序完畢for (i = len - 1; i > 0; i--) {swap(&arr[0], &arr[i]);max_heapify(arr, 0, i - 1);}
}
//输出数组 a 的前20为元素,元素不足20个则输出全部
void print(int a[])
{int n =  N < 20 ? N : 20;for(int i=0;i<n;i++)cout << a[i] << " ";cout << endl;
}//产生随机数填充a数组
void init(int a[])
{for(int i=0;i<N;i++)a[i]=rand()%1000000;
}double getQuickSortTime(int a[])
{
//	cout << "排序前数组的前20位元素:\n";
//	print(a);clock_t first,second; //记录开始和结束时间(以毫秒为单位)first=clock(); //开始时间quickSort(a,0,N-1);second=clock();//结束时间
//	cout << "排序后数组的前20位元素:\n";
//	print(a);return (double)(second - first) / CLOCKS_PER_SEC;
}double getShellSortTime(int a[])
{clock_t first,second; //记录开始和结束时间(以毫秒为单位)
//	cout << "排序前数组的前20位元素:\n";
//	print(a);first=clock(); //开始时间shellSort(a);second=clock();//结束时间
//	cout << "排序后数组的前20位元素:\n";
//	print(a);return (double)(second - first) / CLOCKS_PER_SEC;
}double getHeapSortTime(int a[])
{clock_t first,second; //记录开始和结束时间(以毫秒为单位)
//	cout << "排序前数组的前20位元素:\n";
//	print(a);first=clock(); //开始时间heapSort(a,N);second=clock();//结束时间
//	cout << "排序后数组的前20位元素:\n";
//	print(a);return (double)(second - first) / CLOCKS_PER_SEC;
}void testSort()
{double quick = 0.0;double shell = 0.0;double heap = 0.0;int cnt = 10;//测试次数int a[N];//存放随机数for(int i = 0; i < cnt; i++){
//		if(i%5 == 0)
//			N *= 10;init(a);int t[N];memcpy(t,a,N);quick += getQuickSortTime(t);memcpy(t,a,N);shell += getShellSortTime(t);memcpy(t,a,N);heap += getHeapSortTime(t);}
//	cout.precision(5);cout.setf(ios::fixed);cout << "基于"<< N <<"个元素的随机数组进行排序,测试"<<cnt<<"次取平均值的结果如下:\n";cout << "快速排序:" << quick/cnt << "s\n";cout << "希尔排序:" << shell/cnt << "s\n";cout << " 堆排序 :" << heap/cnt << "s\n";
}int main()
{ testSort();//	cout << "排序前数组的前20位元素:\n";
//	print(iN);
//	heapSort(iN,N);//显示排序算法所用的时间
//	cout << "排序后数组的前20位元素:\n";
//	cout <<"first: " << first << " second: " << second << endl; 
//	cout << "排序耗费的时间:";
//	cout <<  (double)(second - first) / CLOCKS_PER_SEC << "s" << endl;
}

四、实验结果

基于10000个元素的随机数组进行排序,测试10次取平均值的结果如下:
快速排序:0.008402s
希尔排序:0.001554s堆排序 :0.001759s

五、实验总结

奇了怪了

这篇关于GDPU 数据结构 天码行空13的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/643100

相关文章

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

【数据结构】——原来排序算法搞懂这些就行,轻松拿捏

前言:快速排序的实现最重要的是找基准值,下面让我们来了解如何实现找基准值 基准值的注释:在快排的过程中,每一次我们要取一个元素作为枢纽值,以这个数字来将序列划分为两部分。 在此我们采用三数取中法,也就是取左端、中间、右端三个数,然后进行排序,将中间数作为枢纽值。 快速排序实现主框架: //快速排序 void QuickSort(int* arr, int left, int rig

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

《数据结构(C语言版)第二版》第八章-排序(8.3-交换排序、8.4-选择排序)

8.3 交换排序 8.3.1 冒泡排序 【算法特点】 (1) 稳定排序。 (2) 可用于链式存储结构。 (3) 移动记录次数较多,算法平均时间性能比直接插入排序差。当初始记录无序,n较大时, 此算法不宜采用。 #include <stdio.h>#include <stdlib.h>#define MAXSIZE 26typedef int KeyType;typedef char In

【408数据结构】散列 (哈希)知识点集合复习考点题目

苏泽  “弃工从研”的路上很孤独,于是我记下了些许笔记相伴,希望能够帮助到大家    知识点 1. 散列查找 散列查找是一种高效的查找方法,它通过散列函数将关键字映射到数组的一个位置,从而实现快速查找。这种方法的时间复杂度平均为(

浙大数据结构:树的定义与操作

四种遍历 #include<iostream>#include<queue>using namespace std;typedef struct treenode *BinTree;typedef BinTree position;typedef int ElementType;struct treenode{ElementType data;BinTree left;BinTre

Python 内置的一些数据结构

文章目录 1. 列表 (List)2. 元组 (Tuple)3. 字典 (Dictionary)4. 集合 (Set)5. 字符串 (String) Python 提供了几种内置的数据结构来存储和操作数据,每种都有其独特的特点和用途。下面是一些常用的数据结构及其简要说明: 1. 列表 (List) 列表是一种可变的有序集合,可以存放任意类型的数据。列表中的元素可以通过索

浙大数据结构:04-树7 二叉搜索树的操作集

这道题答案都在PPT上,所以先学会再写的话并不难。 1、BinTree Insert( BinTree BST, ElementType X ) 递归实现,小就进左子树,大就进右子树。 为空就新建结点插入。 BinTree Insert( BinTree BST, ElementType X ){if(!BST){BST=(BinTree)malloc(sizeof(struct TNo

【数据结构入门】排序算法之交换排序与归并排序

前言         在前一篇博客,我们学习了排序算法中的插入排序和选择排序,接下来我们将继续探索交换排序与归并排序,这两个排序都是重头戏,让我们接着往下看。  一、交换排序 1.1 冒泡排序 冒泡排序是一种简单的排序算法。 1.1.1 基本思想 它的基本思想是通过相邻元素的比较和交换,让较大的元素逐渐向右移动,从而将最大的元素移动到最右边。 动画演示: 1.1.2 具体步

13 transition数组的动画使用

划重点 动画:transitiontransition-group :数组动画数组的 添加 / 删除 豆腐粉丝汤 清淡又健康 <!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><me