20202301 贾奕琦 2021-2022-1 《数据结构与面向对象程序设计》实验七报告
# 20202301 2021-2022-1 《数据结构与面向对象程序设计》实验七报告
课程：《程序设计与数据结构》
班级： 2023
姓名： 贾奕琦
学号：20202301
实验教师：王志强
实验日期：2021年11月11日
必修/选修： 必修
## 1.实验内容
-
定义一个Searching和Sorting类，并在类中实现linearSearch,SelectionSort方法，最后完成测试。
要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
提交运行结果图。 -
重构你的代码
把Sorting.java Searching.java放入 cn.edu.besti.cs2023.（姓名首字母+四位学号） 包中（例如：cn.edu.besti.cs1823.G2301）
把测试代码放test包中
重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种） -
参考http://www.cnblogs.com/maybe2030/p/4715035.html ，学习各种查找算法并在Searching中补充查找算法并测试
提交运行结果截图 -
实现排序方法等(至少3个)
测试实现的算法（正常，异常，边界）
提交运行结果截图（如果编写多个排序算法，即使其中三个排序程序有瑕疵，也可以酌情得满分） -
编写Android程序对实现各种查找与排序算法进行测试
提交运行结果截图
推送代码到码云（选做，额外加分）
-
## 2. 实验过程及结果
（1）定义一个Searching和Sorting类，并在类中实现linearSearch,SelectionSort方法，最后完成测试。
要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
提交运行结果图。
searching类
package cn.edu.besti.cs2023.J2301;
import java.util.Arrays;
import java.util.Scanner;
public class Searching {
int data[];
int top;
public Searching(int m[])
{
data=m;
}
public int[] input(int[] data){
final int CAPACITY=3;
this.data =new int[CAPACITY];
int i=0;
Scanner scan=new Scanner(System.in);
System.out.print("输入数组(以*作为结尾)：");
while(scan.hasNextInt()){
if(i== this.data.length)
this.data = Arrays.copyOf(this.data, this.data.length+CAPACITY);
this.data[i]=scan.nextInt();
i++;
}
top=i;
scan.next();
return this.data;
}
public static Comparable linearSearch(Comparable[] data,Comparable target)
{
int index = 0;
int result = -1;
while (result==-1 && index < data.length)
{
if (data[index].compareTo(target)==0){
result = index+1;
}
else {
index++;
}
}
if(result!=-1)
System.out.println(target+"是第"+result+"位");
else
System.out.println(target+"不存在！");
return result;
}
//顺序查找
public static int SequenceSearch(Comparable[] a, int value, int n) {
int i;
for (i = 0; i < n; i++)
if (a[i].compareTo(value)==0)
return i + 1;
return -1;
}
//二分查找（折半查找），版本1
public static int BinarySearch1(int a[], int value, int n) {
int low, high, mid = 0;
low = 0;
high = n;
while (low <= high) {
mid = (high + low) / 2;
if (a[mid] == value) {
return mid+1;
} else if (a[mid] < value) {
low = mid;
if (mid == n - 1) {
break;
}
} else {
high = mid;
}
}
return -1;
}
//插值查找
public static int InsertionSearch(int a[], int value, int low, int high) {
while(low<=high) {
int mid = (low + high + 1) / 2;
if (a[mid] == value) {
mid = mid + 1;
return mid;
} else {
if (a[mid] > value)
high = mid - 1;
if (a[mid] < value)
low = mid + 1;
}
}
return -1;
}
}
测试
package test;
import org.junit.jupiter.api.Test;
import junit.framework.TestCase;
import cn.edu.besti.cs2023.J2301.Searching;
class SearchingTest extends TestCase{
Comparable[] a ={2301,1,2,3,4,5,6,7,8,9};
@Test
public void TestLinearSearch()//throws Exception
{
//正常
assertEquals(2,Searching.linearSearch(a,1));
assertEquals(3,Searching.linearSearch(a,2));
assertEquals(6,Searching.linearSearch(a,5));
assertEquals(4,Searching.linearSearch(a,3));
//异常
assertEquals(-1,Searching.linearSearch(a,0));
assertEquals(-1,Searching.linearSearch(a,10));
assertEquals(-1,Searching.linearSearch(a,11));
assertEquals(-1,Searching.linearSearch(a,12));
//边界
assertEquals(1,Searching.linearSearch(a,2301));
assertEquals(10,Searching.linearSearch(a,9));
//正序
assertEquals(1,Searching.linearSearch(a,2301));
assertEquals(2,Searching.linearSearch(a,1));
assertEquals(3,Searching.linearSearch(a,2));
assertEquals(4,Searching.linearSearch(a,3));
//逆序
assertEquals(4,Searching.linearSearch(a,3));
assertEquals(3,Searching.linearSearch(a,2));
assertEquals(2,Searching.linearSearch(a,1));
assertEquals(1,Searching.linearSearch(a,2301));
}
@Test
public void SequenceSearch() {
//正常
assertEquals(3,Searching.SequenceSearch(a,2,10));
//异常
assertEquals(-1,Searching.SequenceSearch(a,22,10));
//边界
assertEquals(1,Searching.SequenceSearch(a,2301,10));
}
@Test
void binarySearch1() {
//正常
assertEquals(3,Searching.SequenceSearch(a,2,10));
//异常
assertEquals(-1,Searching.SequenceSearch(a,22,10));
//边界
assertEquals(1,Searching.SequenceSearch(a,2301,10));
}
@Test
void insertionSearch() {
//正常
assertEquals(3,Searching.SequenceSearch(a,2,10));
//异常
assertEquals(-1,Searching.SequenceSearch(a,22,10));
//边界
assertEquals(1,Searching.SequenceSearch(a,2301,10));
}
}
sorting类
package cn.edu.besti.cs2023.J2301;
import java.util.Scanner;
import java.util.Arrays;
public class Sorting {
int []data;
int top;
public Sorting(int m[]){
data=m;
}
public void Input() {
final int CAPACITY = 3;
data= new int[CAPACITY];
Scanner scan = new Scanner(System.in);
int i = 0;
System.out.print("输入数组(以*作为结尾)：");
while (scan.hasNextInt()) {
if (i == data.length)
data = Arrays.copyOf(data, data.length + CAPACITY);
data[i] = scan.nextInt();
i++;
}
top=i;
scan.next();
}
public static void swap(int[] m, int a, int b){
int temp;
temp=m[a];
m[a]=m[b];
m[b]=temp;
}
public void print(int[] m){
for(int i=0;i<top;i++){
System.out.print(m[i]+" ");
}
System.out.println("");
}
public static String selectionSort(int[] data)
{
int min;
for (int index = 0; index < data.length-1; index++)
{
min = index;
for (int scan = index+1; scan < data.length; scan++) {
if (data[scan]<data[min]) {
min = scan;
}
}
swap(data, min, index);
}
String result = "";
for (int num : data)
{
result += num + " ";
}
System.out.println(result);
return result;
}
}
测试
package test;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import cn.edu.besti.cs2023.J2301.Sorting;
import static org.junit.jupiter.api.Assertions.*;
class SortingTest {
String expect="1 2 3 4 5 6 7 8 9 2301 ";
@Test
void selectionSort_异常() {
int[] a =new int[]{2,1,3,4,5,6,7,8,9,2301};
Assertions.assertEquals(expect, Sorting.selectionSort(a));
}
@Test
void selectionSort_正常() {
int[] b =new int[]{1,3,4,2,6,7,9,5,8,2301};
assertEquals(expect,Sorting.selectionSort(b));
}
@Test
void selectionSort_边界() {
int[] c =new int[]{2301,2,3,4,5,6,7,8,9,1};
assertEquals(expect,Sorting.selectionSort(c));
}
@Test
void selectionSort_正序() {
int[] d =new int[]{1,2,3,4,5,6,7,8,9,2301};
assertEquals(expect,Sorting.selectionSort(d));
}
@Test
void selectionSort_逆序() {
int[] e =new int[]{2301,9,8,7,6,5,4,3,2,1};
assertEquals(expect,Sorting.selectionSort(e));
}
}
2、重构你的代码
把Sorting.java Searching.java放入 cn.edu.besti.cs2023.（姓名首字母+四位学号） 包中（例如：cn.edu.besti.cs1823.G2301）
把测试代码放test包中
重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
searching
sorting
入包：
命令行：
3、参考http://www.cnblogs.com/maybe2030/p/4715035.html ，学习各种查找算法并在Searching中补充查找算法并测试
提交运行结果截图
4、实现排序方法等(至少3个)
测试实现的算法（正常，异常，边界）
提交运行结果截图（如果编写多个排序算法，即使其中三个排序程序有瑕疵，也可以酌情得满分）
package cn.edu.besti.cs2023.J2301;
import java.util.Scanner;
public class SearchingTest {
public static void main(String[] args) {
int i;
int data[] = new int[10];
int top;
int result1, result2, result3;
int m;
Scanner scan = new Scanner(System.in);
System.out.print("输入数组:");
for (i = 0; i < 10; i++) {
m = scan.nextInt();
data[i] = m;
}
top = i;
int n;
System.out.println("输入查找的元素：");
n = scan.nextInt();
result1 = SequenceSearch(data, n, top);
if (result1 != -1)
System.out.println("顺序查找："+result1);
else
System.out.println(n + "不存在！");
result2 = BinarySearch1(data, n, top);
System.out.println("二分查找：" + result2);
if (result2 != -1)
System.out.println("顺序查找："+result2);
else
System.out.println(n + "不存在！");
result3 = InsertionSearch(data, n, 0, top);
System.out.println("插值查找：" + result3);
if (result3 != -1)
System.out.println("顺序查找："+result3);
else
System.out.println(n + "不存在！");
}
//顺序查找
public static int SequenceSearch(int a[], int value, int n) {
int i;
for (i = 0; i < n; i++)
if (a[i] == value)
return i + 1;
return -1;
}
//二分查找（折半查找），版本1
public static int BinarySearch1(int a[], int value, int n) {
int low, high, mid = 0;
low = 0;
high = n;
while (low <= high) {
mid = (high + low) / 2;
if (a[mid] == value) {
return mid+1;
} else if (a[mid] < value) {
low = mid;
if (mid == n - 1) {
break;
}
} else {
high = mid;
}
}
return -1;
}
//插值查找
public static int InsertionSearch(int a[], int value, int low, int high) {
while(low<=high) {
int mid = (low + high + 1) / 2;
if (a[mid] == value) {
mid = mid + 1;
return mid;
} else {
if (a[mid] > value)
high = mid - 1;
if (a[mid] < value)
low = mid + 1;
}
}
return -1;
}
}
正常：
边界：
异常：
5、编写Android程序对实现各种查找与排序算法进行测试
提交运行结果截图
推送代码到码云（选做，额外加分）
## 3. 实验过程中遇到的问题和解决过程
- 问题1：IDEA上次删过，就出现了一系列的问题
- 问题1解决方案：怕了怕了，努力了近三天，终于解决了，能正常运行了，救命，再也不敢随便删除IDEA了
- 问题2：写代码的时候，总是出现数组溢出的情况
- 问题2解决方案：多次更改测试
## 其他
感悟：球球了，给个安装和编写都傻瓜的app吧！！！
从IDEA到安卓，每一次的安装和使用，我都愿称为我的受苦受难时间！！！！！
## 参考资料
- 《Java程序设计教程（第九版）》
- 《Java软件结构与数据结构（第四版）》
