20162307 实验三查找与排序

最新推荐文章于 2024-03-02 20:02:23 发布

bafeiqiao7632

最新推荐文章于 2024-03-02 20:02:23 发布

阅读量221

点赞数

文章标签： java 操作系统数据结构与算法

原文链接：http://www.cnblogs.com/Tiffany23/p/7820325.html

版权

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中的方法写测试类
1. 要求是写不少于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(find==null){
                  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(find1==null){
              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<T> data, int target){
          BTNode <T> root ;
          root = new BTNode <T> ( (T) data );
          ArrayIterator<T> iter = new ArrayIterator <T> ();
          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(q==0)return 0;
                  else {
                  i-=q;
                  t=p;
                      p=q;
                      q=t-p;
                  }
          }
              if(k>target[i].compareTo ( data )){
                  if(p==1)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方法，二叉排序就主要调用这两个方法，找出最大值，然后将其删除，在剩余中再找最大值

四、实验结果

转载于:https://www.cnblogs.com/Tiffany23/p/7820325.html

bafeiqiao7632

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
20162307 实验三查找与排序

20162307 实验三查找与排序北京电子科技学院（BESTI）实验报告课程：程序设计与数据结构班级：1623姓名：张韵琪学号：20162307指导教师：娄嘉鹏老师、王志强老师实验日期：2017年11月06号实验密级：非密级实验时间：三天必修/选修：必修实验名称：查找与排序实验仪器：电脑实验目的与要求：目的：学习查找与排序的应用，实现和分析要...
复制链接

扫一扫