中北大学算法基础实验:蛮力与优化算法实验:题目1

本文介绍了如何使用Java编程实现选择排序和起泡排序算法,提供了详细的伪代码以及实际代码示例,同时分析了两种排序算法的时间复杂度。实验包括了排序过程的代码运行截图和实验心得,旨在帮助读者复习数据结构和算法知识。
摘要由CSDN通过智能技术生成

使用java写代码,伪代码与老师PPT要求一致,有代码运行截图和时间复杂度分析,如果有误请及时评论。

实验时间

2024年 3 月27日19时至22时

学时数

3

1.实验名称

蛮力与优化算法实验:题目1 排序问题程序设计整数排序问题

2.实验目的

题目1实验目的:

(1)掌握选择排序和起泡排序的基本思想;

(2)掌握两种排序方法的具体实现过程;

(3)在掌握的基础上编程实现两种排序方法。

3.实验内容

输入一个待排序的序列,分别用选择排序和起泡排序两种排序方法将其变换成有序的序列,输出结果,输出时要求有文字说明。请任选一种语言编写程序实现上述算法,并分析其算法复杂度。

  1. 实验原理

选择排序原理:通过自定义的最小值元素的下标,在内层循环中通过下标进行比较,查找过程中不移动数位置, 如果发现比自定义最小值元素下标还要小的值,则将该值的下标赋值给自定义的最小值元素下标。在一次内层循环结束后,将最小值元素交换至数组左端。

算法思想

A.在未排序序列中找到最小(大)元素,存放到排序序列的起始位置;
B.从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾;
C.以此类推,直到所有元素均排序完毕

—————————————————————————————————————

起泡排序原理:从第一个数开始,依次往后进行相邻两个数之间的比较,如果前面的数比后面的数大就交换这两个数的位置,如果前面的数较小或两者一样大,就不作处理。

详细描述

➀比较相邻的元素的大小。如果第一个比第二个大,就交换它们两个的顺序;
➁对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
➂针对所有的元素重复以上的步骤,除了最后一个;
➃重复步骤➀~➂,直到排序完成。

      

  1. 实验源代码和伪代码

实验一(已经输入序列):

选择排序伪代码:

算法 SelectSortMin

输入:  int []a = {1, 8, 5, 16, 32, 21}

输出:  从小到大排序的结果

1:  for i ← 0 to a.length − 2 do //外层循环控制循环次数

2:          min ← i

3:         for j ← i + 1 to a.length − 1 do //内层循环进行比较更新下标

4:                  if a[j] < a[min] then

5:                         min ← j

6:                  end if

7:            end for

8:          if i ! = min then

9:                  temp = a[min]

10:                  a[min] = a[i];

11:                  a[i] = temp;

12:         end if

13:  end for

选择排序源代码(java版且从小到大排序):

public class SelectSortMin {

public static void main(String[] args) {

int[] a = { 1, 8, 5, 16, 32, 21 };

int min;// 最小值下标

int temp;

// 外层循环控制循环次数

for (int i = 0; i < a.length - 1; i++) {

min = i;// 假设最小值是a[i],即a[0]

       //内层循环进行比较更新下标

for (int j = i + 1; j < a.length; j++) {

if (a[j] < a[min])

// 如果有比现在制定的最小元素还小的,就更新最小值下标

min = j;

}

// 退出内层循环后,判断最小下标是否与原来相等,不等,说明有更小的,进行更新元素顺序

if (i != min) {

// if (a[i] != a[min]) {// 也可以更改为这个

temp = a[min];

a[min] = a[i];

a[i] = temp;

}

}

//输出最终结果

for (int i = 0; i < a.length; i++)

System.out.print(a[i] + ",");

}

}

起泡排序伪代码:

算法 BubbleSortMin

输入:  int []a = {1, 8, 5, 16, 32, 21}

输出:  从小到大排序的结果

1:  for i ← 0 to a.length − 2 do //外层循环控制循环次数

2:         for j ← 0 to a.length − i − 1 do //内层循环进行比较更新下标

3:               if array[j] > array[j + 1] then

4:                         temp = array[j + 1]

5:                         array[j + 1] = array[j]

6:                         array[j] = temp

7:                  end if

8:         end for

9:  end for

起泡排序源代码(java版且从小到大排序):

  1. public class BubbleSortMin {
  2. public static void main(String[] args) {
  3. int[] array = { 1, 8, 5, 16, 32, 21 };
  4. int temp;
  5. // 外层循环控制比较的趟数
  6. for (int i = 0; i < array.length - 1; i++) {
  7. // 内层循环控制每一趟排序多少次
  8. for (int j = 0; j < array.length - i - 1; j++) {
  9. // 升序--如果前面大于后面则交换
  10. if (array[j] > array[j + 1]) {
  11. // 引入temp变量作为交换媒介
  12. temp = array[j + 1];
  13. array[j + 1] = array[j];
  14. array[j] = temp;
  15. }
  16. }
  17. }
  18. System.out.print("由小到大的排序为:");
  19. for (int i = 0; i < array.length; i++)
  20. System.out.print(array[i] + ",");
  21. }
  22. }

选择排序时间复杂度分析:

选择排序的时间复杂度是O(N2):假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N),需要遍历多少次呢?N-1次因此,选择排序的时间复杂度是 O(N2) 。

起泡排序时间复杂度分析:

在冒泡排序中,第1轮需要比较n-1次,第2轮需要比较n-2次……第n-1轮需要比较1次,所以平均时间复杂度为:O( n2 );

  1. 实验结论及心得

实验一:

选择排序代码运行截图:

8cad2213da744f848839b4a5c667e9e7.png

起泡排序代码运行截图:

0f24c0d9faef46dca9482ca41b1b9a44.png

心得:

对数据结构进行了复习。

  • 26
    点赞
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值