实验3

实验一

要求：完成教材P302 Searching.Java ,P305 Sorting.java中方法的测试

不少于10个测试用例，提交测试用例设计情况（正常，异常，边界，正序，逆序），用例数据中要包含自己学号的后四位

实验思路：这些代码之前作业就写过，只是改了部分测试用例，没有什么问题。

实验截图：

实验二

要求：重构你的代码

把Sorting.java Searching.java放入 cn.edu.besti.cs1623.（姓名首字母+四位学号） 包中
把测试代码放test包中
重新编译，运行代码

实验思路：我的命令行出现了些问题，总是出现非法字符，最后我把代码拷到同学的电脑上重构运行截图。

实验截图：

实验三

要求：参考 http://www.cnblogs.com/maybe2030/p/4715035.html 在Searching中补充查找算法并测试

实验思路：这个实验的主要问题是斐波那契数列的实现，从第三位开始的数字是它前两位的和，随着元素个数增多越来越接近需要的黄金比例，参考代码实现：

        /* 输出：9 */
        static int FibonacciSearch(int [] a, int n, int key){
            int [] F = {0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987};
            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;
        }

实验截图：

实验四

要求：补充实现课上讲过的排序方法：希尔排序，堆排序，桶排序，二叉树排序等

测试实现的算法（正常，异常，边界）

实验思路：堆排序、桶排序主要参考PPT里的代码，二叉树排序之前实现过二叉查找树，调出中序遍历即可，希尔排序我又回去看了一下之前的课件，加深了理解

希尔排序：

堆排序：

// 堆排序
    public static void heapSort(Integer[] data)
    {

        for (int i = 0; i < data.length; i++)
        {
            createMaxdHeap(data, data.length - 1 - i);

            sw(data, 0, data.length - 1 - i);

        }
    }

    public static void createMaxdHeap(Integer[] data, int lastIndex)
    {
        for (int i = (lastIndex - 1) / 2; i >= 0; i--)
        {

            int an = i;

            while (2 * an + 1 <= lastIndex) {

                int biggerIndex = 2 * an + 1;
                if (biggerIndex < lastIndex) {

                    if (data[biggerIndex] < data[biggerIndex + 1]) {

                        biggerIndex++;
                    }
                }
                if (data[an] < data[biggerIndex]) {

                    sw(data, an, biggerIndex);
                    an = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }

    public static void heapSort2(int[] data)
    {
        for (int ch = 0; ch < data.length; ch++)
        {
            createMaxdHeap2(data, data.length - 1 - ch);
            swap(data, 0,data.length - 1 - ch );

        }
    }

    public static void createMaxdHeap2(int[] data, int lastIndex)
    {
        for (int i = (lastIndex - 1) / 2; i >= 0; i--)
        {

            int j = i;

            while (2 * j + 1 >= lastIndex) {

                int biggerIndex = 2 * j + 1;

                if (biggerIndex > lastIndex) {

                    if (data[biggerIndex] > data[biggerIndex + 1])
                    {

                        biggerIndex++;
                    }
                }
                if (data[j] < data[biggerIndex])
                {

                    swap(data, j, biggerIndex);
                    j = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }

桶排序：

二叉树排序 ：

实验截图：

转载于:https://www.cnblogs.com/1zhjch/p/7813890.html