20162307 实验三 查找与排序

20162307 实验三 查找与排序

北京电子科技学院（BESTI）

实 验 报 告

课程：程序设计与数据结构

班级：1623

姓名：张韵琪

学号：20162307

指导教师：娄嘉鹏老师、王志强老师

实验日期：2017年11月06号

实验密级：非密级

实验时间：三天

必修/选修：必修

实验名称：查找与排序

实验仪器：电脑

实验目的与要求：

• 目的：

  学习查找与排序的应用，实现和分析

• 要求：
  1.没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程
  2.完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）。报告可以参考范飞龙老师的指导
  3. 严禁抄袭，有该行为者实验成绩归零，并附加其他惩罚措施。

实验内容、步骤

一、实验要求

完成教材P302 Searching.Java ,P305 Sorting.java中方法的测试
不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位
提交运行结果图（可多张）

一、实验步骤

• 1. 仔细研究教材P302 Searching.Java ,P305 Sorting.java

• 2.根据Searching、Sorting中的方法写测试类

• 3. 要求是写不少于10个测试，所以要有正常，边界、异常的情况

• 定义了10个数组

  Comparable[] irr1 = {1, 2, 3, 4, 5, 2307};
  Comparable[] irr2 = {1, 1, 1, 1, 1, 1, 1, 1, 1};
  Comparable[] irr3 = {2307, 5, 4, 3, 2, 1};
  Comparable[] irr4 = {1, 0, 1, 0, 1, 0};
  Comparable[] irr5 = {-1, -2, -3, 2307};
  Comparable[] irr6 = {1.1, 1.2, 1.3, 23.07};
  Comparable[] irr7 = {0.0, 1.0, 2.0, 3.0};
  Comparable[] irr8 = {"a", "b", "c", "zhangyunqi"};
  Comparable[] irr9 = {"a", "a", "a", "zhangyunqi"};
  Comparable[] irr10 = {0.00, 1.23, 23.00};

• Searching的测试：

  //irr1 linearSearch
  System.out.println ("\n第1组 {1, 2, 3, 4, 5, 2307}😊;
  Comparable find = (Comparable)Searching.linearSearch(irr1,2307);
  System.out.println("linearSearch(1) find 2307:");
  if(findnull){
  System.out.println("Not find ");
  }else {
  System.out.println ("Find it");
  }
  System.out.println();
  //irr1 binarySearch
  Comparable find1= (Comparable)Searching.binarySearch ( irr1,2307 );
  System.out.println("binaryDearch(1) find 2307:");
  if(find1null){
  System.out.println("Not find ");
  }else {
  System.out.println ("Find it");
  }
  System.out.println();

• Sorting的测试

  System.out.println ("第1组 {1, 2, 3, 4, 5, 2307}： ");
  Sorting.selectionSort (irr1 );
  System.out.println ("\nselectionSort 😊;
  for (Comparable comparable : irr1) {
  System.out.print ( comparable + " " );
  }
  Sorting.selectionSort ( irr1);

  System.out.println ("\ninsertionSort 😊;
  for (Comparable comparable : irr1) {
  System.out.print ( comparable + " " );
  }
  Sorting.insertionSort ( irr1);
  System.out.println ("\nbubbleSort 😊;
  for (Comparable comparable : irr1) {
  System.out.print ( comparable + " " );
  }
  Sorting.bubbleSort ( irr1);
  System.out.println ("\nquickSort 😊;
  for (Comparable comparable : irr1) {
  System.out.print ( comparable + " " );
  }
  Sorting.quickSort ( irr1,0,irr1.length-1);
  System.out.println ("mergeSort 😊;
  for (Comparable comparable : irr1) {
  System.out.print ( comparable + " " );
  }
  Sorting.mergeSort ( irr1,0,irr1.length-1);

一、实验结果

二、实验要求

重构你的代码
把Sorting.java Searching.java放入 cn.edu.besti.cs1623.（姓名首字母+四位学号） 包中
把测试代码放test包中
重新编译，运行代码，提交编译，运行的截图（IDEA，命令行两种）
课下把代码推送到代码托管平台

二、实验步骤

• 创建个包 cn.edu.besti.cs1623.zyq2307,将Searching、Sorting放入包内
• 再建test，Make Directory as Test Source Root

二、实验结果

三、实验要求

参考http://www.cnblogs.com/maybe2030/p/4715035.html 在Searching中补充查找算法并测试
提交运行结果截图

三、实验步骤

• 查看老师所给的博客

• 补充方法

• 写出测试

  public static Comparable SequenceSearch(Comparable[] data, Comparable target, int n) {
  int i;
  for (i = 0; i < n; i++)
  if (data[i] == target)
  return i;
  return -1;
  }
  public static int FibonacciSearch(int [] a, int n, int key){
  int [] F = new int[a.length];
  int low, high, mid, i, k;
  low = 1;
  high = n;
  k = 0;

  while (n > F[k]-1) /* 计算n位于斐波那契数列的位置 */
  k++;

  while (low <= high) {
  mid = low + F[k-1] -1;
  if (key < a[mid]){
  high = mid - 1;
  k = k - 1;
  }
  else if (key > a[mid]){
  low = mid + 1;
  k = k - 2;
  }
  else {
  if (mid <= n)
  return mid;
  else
  return n;
  }
  }
  return 0;
  }
  public static Comparable InsertionSearch(int[] data, int target) {
  Comparable result = null;
  int first = 0, last = data.length - 1, mid;
  while (result == null && first <= last) {
  mid = (first + last) / 2
  if (data[mid] == (target))
  result = data[mid];
  else if (data[mid] - (target) > 0)
  last = mid - 1;
  else
  first = mid + 1;
  }
  return result;
  }
  public static Comparable BinarySearchTree(Comparable data, int target){
  BTNode root ;
  root = new BTNode ( (T) data );
  ArrayIterator iter = new ArrayIterator ();
  if (root != null)
  root.inorder ( iter );
  return (Comparable) iter;
  }
  public static int fibSearch(Comparable data, Comparable[] target,int m,int k,int[] fib){
  int i=fib[m],p=fib[m-1],q=fib[m-2];
  int t;
  while(k!=target[i].compareTo (data)){
  if(k<target[i].compareTo ( data )){
  if(q0)return 0;
  else {
  i-=q;
  t=p;
  p=q;
  q=t-p;
  }
  }
  if(k>target[i].compareTo ( data )){
  if(p1)return 0;
  else{
  i+=q;
  p-=q;
  q-=p;
  }
  }
  }
  return i;
  }

三、实验结果

四、实验要求

补充实现课上讲过的排序方法：希尔排序，堆排序，桶排序，二叉树排序
测试实现的算法（正常，异常，边界）
提交运行结果截图
推送相关代码到码云上

四、实验步骤

• 希尔排序：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( < …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

  public static void ShellSort(Comparable[] data) {//希尔
  for (int i = data.length / 2; i > 2; i /= 2) {
  for (int j = 0; j < i; j++) {
  insertionSort ( data );
  }
  }
  insertionSort ( data );
  }

• 堆排序：（最大堆）根为最大值，每次取根的值，再移除，将叶子点放到根处，再使其变成最大堆，再取根

  public class MaxHeapSort {
  void init(int[] data) {
  this.queue = new int[data.length + 1];
  for (int i = 0; i < data.length; i++) {
  queue[++size] = data[i];
  fixUp(size);
  }
  }
  private int size = 0;
  private int[] queue;
  public int get() {
  return queue[1];
  }
  public void remove() {
  fixDown(1);
  }
  // fixdown
  private void fixDown(int k) {
  int j;
  while ((j = k << 1) <= size) {
  if (j < size && queue[j] < queue[j + 1])
  j++;
  if (queue[k] > queue[j]) // 不用交换
  break;
  k = j;
  }
  }
  private void fixUp(int k) {
  while (k > 1) {
  int j = k >> 1;
  if (queue[j] > queue[k])
  break;
  k = j;
  }
  }
  }

• 桶排序：桶排序的基本思想是：把数组 arr 划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并。
  1.找出待排序数组中的最大值max、最小值min
  2.我们使用 动态数组ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(max-min)/arr.length+1
  3.遍历数组 arr，计算每个元素 arr[i] 放的桶
  4.每个桶各自排序
  5.遍历桶数组，把排序好的元素放进输出数组

  public static void Bucketsort(int data[],int min,int max){
  int i,j;
  int temp[] = new int[max - min];
  int buckets[] = new int[max - min];
  //记录每个元素在序列中出现的次数
  for(i = 0; i < data.length; ++i)
  {
  buckets[data[i]]++;
  }
  //计算“落入”桶内的元素在有序序列中的位置
  for(i = 1; i < max; ++i)
  {
  buckets[i] = buckets[i] + buckets[i - 1];
  }
  //将num[]中的数据完全复制到temp[]数组
  System.arraycopy(data, 0, temp, 0, data.length);
  //根据buckets数组中的信息将待排序列的各元素放入相应的位置
  for(j = data.length - 1; j >= 0; --j)
  {
  data[--buckets[temp[j]]] = temp[j];
  }
  }

• 二叉树排序：排序二叉树的定义也是递归定义的，需要满足：
  （1）若它的左子树不为空，则左子树上所有节点的值要均小于根节点的值；
  （2）若它的右子树不为空，则右子树上所有节点的值要均大于根节点的值；
  （3）左、右子树也分别是排序二叉树

之前LinkedBinaryTree中有findMax，remove方法，二叉排序就主要调用这两个方法，找出最大值，然后将其删除，在剩余中再找最大值

四、实验结果