《数据结构与面向对象程序设计》实验七报告
课程：《程序设计与数据结构》
班级： 1923
姓名： 杨坤
学号：20192320
实验教师：王自强
实验日期：2020年11月19日
必修/选修： 必修
1.实验内容
1.定义一个Searching和Sorting类，并在类中实现linearSearch,SelectionSort方法，最后完成测试。
要求不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
提交运行结果图。
2.重构你的代码
把Sorting.java Searching.java放入 cn.edu.besti.cs1823.（姓名首字母+四位学号） 包（例如：cn.edu.besti.cs1823.G2301）
把测试代码放test包中
重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
3.参考http://www.cnblogs.com/maybe2030/p/4715035.html ，学习各种查找算法并在Searching中补充查找算法并测试
提交运行结果截图
4.补充实现课上讲过的排序方法：希尔排序，堆排序，二叉树排序等(至少3个)
测试实现的算法（正常，异常，边界）
提交运行结果截图（如果编写多个排序算法，即使其中三个排序程序有瑕疵，也可以酌情得满分）
5.编写Android程序对实现各种查找与排序算法进行测试
提交运行结果截图
推送代码到码云（选做，加分）
2.实验结果与运行截图
sorting代码
package Chapter13;
public class Sorting {
public void selectionSort(int[] data)
{
int min=0;//记录最小的数
for(int i=0;i<data.length;i++)
{
for (int j=i+1;j<data.length;j++)
{
if(data[i]>data[j])
{min=data[j];
data[j]=data[i];
data[i]=min;}
}
}
for(int i=0;i<data.length;i++)
{
System.out.println("test"+"["+i+"]"+": "+data[i]);
}
}
public void insertSort(int []data)
{
int temp;
int j ;
for(int i=1;i<data.length;i++)
{
temp=data[i];//待插入的数
for ( j=i-1;j>=0&&data[j]>=temp;j--)
{
data[j+1]=data[j];
}
data[j+1]=temp;
}
for(int i=0;i<data.length;i++)
{
System.out.println("test"+"["+i+"]"+": "+data[i]);
}
}
public void shellSort(int[] data)
{
int j = 0;
int temp = 0;
//每次将步长缩短为原来的一半
for (int increment = data.length / 2; increment > 0; increment /= 2)
{
for (int i = increment; i < data.length; i++)
{
temp = data[i];
for (j = i; j >= increment&&temp <data[j - increment]; j -= increment)
{
data[j] = data[j - increment];
}
data[j] = temp;
}
}
for(int i=0;i<data.length;i++)
{
System.out.println("test"+"["+i+"]"+": "+data[i]);
}
}
//快速排序
public void quickSort(int[] data)
{
subQuickSort(data, 0, data.length - 1);
for(int i=0;i<data.length;i++)
{
System.out.println("test"+"["+i+"]"+": "+data[i]);
}
}
private void subQuickSort(int[] data, int start, int end)
{
if (start >= end)
{
return;
}
int middleIndex = subQuickSortCore(data, start, end);
subQuickSort(data, start, middleIndex - 1);
subQuickSort(data, middleIndex + 1, end);
}
private int subQuickSortCore(int[] data, int start, int end)//返回中轴值
{
int middleValue = data[start];
while (start < end)
{
while (data[end] >= middleValue && start < end)
{
end--;
}
data[start] = data[end];
while (data[start] <= middleValue && start < end)
{
start++;
}
data[end] = data[start];
}
data[start] = middleValue;
return start;
}
//快速排序2
public void QuickSort(int[] array,int start,int end)
{
if(start<end)
{
int key=array[start];//初始化保存基元
int i=start,j;//初始化i,j
for(j=start+1;j<=end;j++)
{
if(array[j]<key)//如果此处元素小于基元，则把此元素和i+1处元素交换，并将i加1，如大于或等于基元则继续循环
{
int temp=array[j];
array[j]=array[i+1];
array[i+1]=temp;
i++;
}
}
array[start]=array[i];//交换i处元素和基元
array[i]=key;
QuickSort(array, start, i-1);//递归调用
QuickSort(array, i+1, end);
}
}
}
search代码
package Chapter13;
import java.util.Arrays;
public class Searching<T> {
public void linear(int[] data, int target)
{
int count=0;
for(int i = 0; i < data.length; i++) {
if(data[i]==target){//如果数据存在
count++;
System.out.println("找到目标数的下标："+i);//返回数据所在的下标，也就是位置
}
}
if (count==0)
System.out.println("没有找到目标数");
else
System.out.println("共有"+count+"个");
}
public void binarySearch(int[] data,int target)
{
int count=0;
int low,high,mid;
low=0;
high=data.length-1;
while (low<=high)
{
mid=(low+high)/2;
if(data[mid]==target)
{ count++;
System.out.println("找到目标数的下标："+mid);
break;//不加这个会死循环
}
else if (data[mid]>target)
{
high=mid-1;
}
else
low=mid+1;
}
if (count==0)
System.out.println("没有找到目标数");
else
System.out.println("共有"+count+"个");
}
//使用递归
public int binSearch(int srcArray[], int start, int end, int target) {
int mid = (end - start) / 2 + start;
if (srcArray[mid] == target) {
return mid;
}
if (start >= end) {
return -1;
} else if (target > srcArray[mid]) {
return binSearch(srcArray, mid + 1, end, target);
} else if (target < srcArray[mid]) {
return binSearch(srcArray, start, mid - 1, target);
}
return -1;
}
//插值查找
public int insertSearch(int []data,int left,int right,int target){
//注意，不然mid可能会越界
if(left>right || target<data[0] ||target>data[data.length-1]){
return -1;
}
int mid = left +(right - left) * (target - data[left])/ (data[right] -data[left]);
int midVal =data[mid];
if(target > midVal){//向右递归
return insertSearch(data, mid+1, right, target);
}else if(target < midVal){//向左递归
return insertSearch(data, left, mid-1, target);
}else {
return mid;
}
}
//创建斐波那契函数
//斐波那契数列
public static int[] fib(int []data) {
int[] f = new int[data.length];
f[0] = 1;
f[1] = 1;
for (int i = 2; i < data.length; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
//斐波那契查找
public int fibSearch(int[] a, int target) {
int low = 0;
int high = a.length - 1;
int k = 0;
int mid = 0;
int f[] = fib(a);
while (high > f[k] - 1) {
k++;
}
int[] temp = Arrays.copyOf(a, f[k]);
for (int i = high + 1; i < temp.length; i++) {
temp[i] = a[high];
}
while (low <= high) {
mid = low + f[k - 1] - 1;
if (target < temp[mid]) {
high = mid - 1;
k--;
} else if (target > temp[mid]) {
low = mid + 1;
k -= 2;
} else {
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
测试代码：
package Chapter13;
import java.util.Stack;
public class SearchSortTest {
public static void main(String[] args) {
int []test=new int[10];
test[0]=1;
test[1]=1;
test[2]=1;
test[3]=1;
test[4]=1;
test[5]=1;
test[6]=2;
test[7]=3;
test[8]=2;
test[9]=0;
/* Searching searching=new Searching();
System.out.println("线性查找： ");
searching.linear(test, 1);
Sorting sorting=new Sorting();
sorting.selectionSort(test);
System.out.println("二分查找： ");
searching.binarySearch(test, 2);
System.out.println("递归二分查找： ");
System.out.println("找到目标数的下标："+searching.binSearch(test, 0, test.length-1, 1));
System.out.println("插值查找： ");
System.out.println("找到目标数的下标："+searching.insertSearch(test, 0, test.length-1, 1));
System.out.println("斐波那契查找： ");
System.out.println("找到目标数的下标："+ searching.fibSearch(test,3));
*//*Sorting sorting=new Sorting();*//*
System.out.println("希尔排序： ");
sorting.shellSort(test);
*//*Sorting sorting=new Sorting();*//*
System.out.println("直接插入排序： ");
sorting.insertSort(test);*/
Sorting sorting=new Sorting();
System.out.println("快速排序: ");
sorting.QuickSort(test,0, test.length-1);
for(int i=0;i<test.length;i++)
{
System.out.println("test"+"["+i+"]"+": "+test[i]);
}
}
}
截图：
3.实验心得体会
自身的自学能力还要提升，大多数的实验代码都在同学的帮助下完成，在运到困难时，容易感到沮丧，还要多锻炼自己。平时也要多加练习。
这是一个新的软件，一切都是陌生的，在遇到这种问题的时候，多上网搜集资料是非常必要的，同时多家运用学习的app在上面观看相关的视频能够更好的掌握