实验三 查找和排序 实验报告 20162305

实验三 查找和排序 实验报告 20162305

一、查找和排序-1

1、实验要求

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

2、实验过程

• 这个实验是在教材上的代码基础上实现的。教材中给了Searching类和Sorting类，测试这两个代码中给出的方法。查找类中包含了线性查找和二分查找两种方法。排序类中包含了像选择排序，插入排序，冒泡排序等等方法。这些方法在之前的学习中已经了解过，设计测试类，在两个类的测试类中一一实现这些方法。

3、实验成果截图

二、查找和排序-2

1、实验要求

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

2、实验过程

• 按照实验要求，我在IDEA中新建了一个package包，命名为cn.edu.besti.cs162305.lyx。在IDEA中重构代码，将代码加入相应的文件夹中，然后运行，在IDEA中可以实现。不过打开命令行后编译成功后，命令行中显示代码编译没问题，不过结果却没能显示出来。

3、实验成果截图

• 命令行
  

• IDEA

• 1、
  

• 2、
  

三、查找和排序-3

1、实验要求

• 参考 查找算法博客 在Searching中补充查找算法并测试
  提交运行结果截图

2、实验过程

• 在这篇学习博客中，一共提到了7种查找的方法，分别是顺序查找、二分查找、插值查找、斐波那契查找、树表查找、分块查找和哈希查找。其中的顺序查找和二分查找在教材的代码中都已经实现，下面介绍其他五种查找方法

（1）、插值查找

• 插值查找是基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。

• 插值查找在实际使用时，一般要满足两个假设条件：
  （1）每一次对数据的访问与通常的指令相比，费用都是相当昂贵的。例如，待查找的表一定是在磁盘而非内存中，因而每一次比较都
  要进行磁盘访问。
  （2）数据不仅是已被排好序的，而且呈现均匀分布特征。

• 实验代码

public static Comparable InsertionSearch(int[] num, int key) {
        //定义三个判断数
        int low, high, mid;
        low = 0;
        high = num.length - 1;
        while (low <= high) {
            // mid = (low + high) / 2;
            //二分查找
            mid = low + (high - low) * (key - num[low]) / (num[high] - num[low]); // 插值查找
            if (key < num[mid]) high = mid - 1;
            else if (key > num[mid]) low = mid + 1;
            else
                // 如果等于则直接还回下标值
                return mid;
        }
        return -1;
    }

（2）、斐波那契查找

• 斐波那契查找也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。
  　　

• 相对于折半查找，一般将待比较的key值与第mid=（low+high）/2位置的元素比较，比较结果分三种情况：
  1、相等，mid位置的元素即为所求
  2、>，low=mid+1 3、<，high=mid-1。

• 斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1;开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1),比较结果也分为三种：
  1、相等，mid位置的元素即为所求
  2、low=mid+1,k-=2;
  3、high=mid-1,k-=1。

• 说明：low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))= Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找。

• 实验代码

 private int max_size = 20;//斐波那契数组的长度

    /*构造一个斐波那契数组*/
    public void Fibonacci(int[] F) {
        F[0] = 0;
        F[1] = 1;
        for (int i = 2; i < max_size; ++i)
            F[i] = F[i - 1] + F[i - 2];
    }

    /*定义斐波那契查找法*/
    int FibonacciSearch(int[] a, int key)  //a为要查找的数组,n为要查找的数组长度,key为要查找的关键字
    {
        int low = 0;
        int high = a.length - 1;

        int[] F = new int[max_size];
        Fibonacci(F);//构造一个斐波那契数组F

        int k = 0;
        while (a.length > F[k] - 1)//计算n位于斐波那契数列的位置
            ++k;
        //将数组a扩展到F[k]-1的长度

        int[] temp = new int[F[k] - 1];
        
        for (int i = 0; i < a.length; i++)
            temp[i] = a[i];


        for (int i = a.length; i < F[k] - 1; ++i)
            temp[i] = a[a.length - 1];

        while (low <= high) {
            int mid = low + F[k - 1] - 1;
            if (key < temp[mid]) {
                high = mid - 1;
                k -= 1;
            } else if (key > temp[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                if (mid < a.length) return mid; //若相等则说明mid即为查找到的位置
                else return a.length - 1; //若mid>=n则说明是扩展的数值,返回n-1
            }
        }

        return 0;
    }

（3）、二叉树查找

• 实现这个方法相对简单。我们可以利用之前实现过的二叉查找树来实现查找功能。定义一个二叉查找树，遍历整个数，利用二叉查找树中的find方法来查找目标值，从而实现查找功能。
• 实验代码

 public int BinaryTreeSearch(int[] a, int key) {
        LinkedBinarySearchTree linkedBinarySearchTree = new LinkedBinarySearchTree();
        //添加元素进入查找树
        for (int i = 0; i < a.length; i++)
            linkedBinarySearchTree.add(a[i]);
        //利用find方法查找值
        if (linkedBinarySearchTree.find(key) == null) return Integer.parseInt(null);
        else return key;

    }

（4）、分块查找

• 分块查找又称索引顺序查找，它是顺序查找的一种改进方法。将n个数据元素"按块有序"划分为m块（m ≤ n）。每一块中的结点不必有序，但块与块之间必须"按块有序"；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素，以此类推。

• 实验代码

public static int blockSearch(int[] index, int[] a, int key, int m) {  
    // 在序列a数组中，用分块查找方法查找关键字为key的记录  
    // 1.在index[ ] 中折半查找，确定要查找的key属于哪个块中  
    int i = binarySearch(index, key);  
    if (i >= 0) {  
        int j = i > 0 ? i * m : i;  
        int length = (i + 1) * m;  
        // 在确定的块中用顺序查找方法查找key  
        for (int k = j; k < length; k++) {  
            if (key == a[k]) {  
                System.out.println("查询成功");  
                return k;  
            }  
        }  
    }  
  
    return -1;  
}  

（5）、哈希查找

• 利用Java中的HashMap类实现查找功能。其实现过程和二叉查找树实现查找类似。利用HashMap中的put方法将元素添加入表中，再用containKey方法判断有无目标元素，从而实现查找功能。
• 实验代码

    public int HashSearch(int[] a , int key){
        HashMap<Integer,Integer> hashMap = new HashMap();
        for(int i = 0;i <a.length;i++)
            hashMap.put(i,a[i]);
        if(hashMap.containsKey(key) == true)
            return key;
        else
            return 0;
    }

3、实验成果截图

四、查找和排序-4

1、实验要求

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

2、实验过程

（1）、希尔排序

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

 public static void shellSort(int[] data) {
        int j = 0;
        int temp = 0;
        for (int a = data.length / 2; a > 0; a /= 2) {
            for (int i = a; i < data.length; i++) {
                temp = data[i];
                for (j = i - a; j >= 0; j -= a) {
                    if (temp < data[j]) {
                        data[j + a] = data[j];
                    } else {
                        break;
                    }
                }
                data[j + a] = temp;
            }
            for (int i = 0; i < data.length; i++)
                System.out.print(data[i] + " ");
        }
    }

（2）、堆排序

• 利用之前完成的LinkedMaxHeap实现排序功能。根据最大堆的性质依次返回值并打印出来，实现排序功能
• 实验代码

 public void heapSort(Comparable[] data){
        LinkedMaxHeap linkedMaxHeap = new LinkedMaxHeap();
        for (int i = 0; i < data.length; i++)
            linkedMaxHeap.add(data[i]);
        for (int i = data.length-1; i>=0;i--)
            data[i]=linkedMaxHeap.removeMax();
    }

（3）、桶排序

• 桶排序的基本思想是将一个数据表分割成许多buckets，然后每个bucket各自排序，或用不同的排序算法，或者递归的使用bucket sort算法。基本流程是先建立一堆buckets，再遍历原始数组，并将数据放入到各自的buckets当中，对非空的buckets进行排序； 按照顺序遍历这些buckets并放回到原始数组中即可构成排序后的数组。

• 实验代码

 public static void bucketSort(int[] arr){

        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < arr.length; i++){
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }

        //桶数
        int bucketNum = (max - min) / arr.length + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<Integer>());
        }

        //将每个元素放入桶
        for(int i = 0; i < arr.length; i++){
            int num = (arr[i] - min) / (arr.length);
            bucketArr.get(num).add(arr[i]);
        }

        //对每个桶进行排序
        for(int i = 0; i < bucketArr.size(); i++){
            Collections.sort(bucketArr.get(i));
        }


    }

（4）、二叉树排序

• 利用二叉查找树的性质实现排序功能，利用类中findMin（）方法将数组中的元素排序。
• 实验代码

public static void BinaryTreeSort(Comparable[] a){
        LinkedBinarySearchTree linkedBinaryTree = new LinkedBinarySearchTree();
        for (int i = 0; i < a.length; i++)
            linkedBinaryTree.add(a[i]);
        for (int i = 0; i < a.length; i++) {
            a[i] = linkedBinaryTree.findMin();
            linkedBinaryTree.remove(linkedBinaryTree.findMin());
        }
    }

3、实验成果截图