20172318 2018-2019-1 《程序设计与数据结构》第5周学习总结

时间 2019-11-14

原文原文链接

20172318 2018-2019-1 《程序设计与数据结构》第5周学习总结

教材学习内容总结

排序与查找

searching：查找
- 查找是这样一个过程，即在某个项目组中寻找某一指定目标元素，或者肯定该指定
  目标并不存在。
- 高效的查找会使该过程所作的比较操做次数最小化·
- searchpool：查找池要查找的一组元素项。
staticmethod 静态方法:经过类名来调用的一种方法，该类名不能引用实例数据。也称
为类方法。
- 在方法声明中，经过使用static修饰符就能够把它声明为静态的·
generic method：泛型方法
- 与建立泛型类类似，咱们也能够建立泛型方法。即，不是建立一个引用泛型参数的类，而是建立一个引用泛型的方法。泛型参数只应用于该方法。要建立一个泛型方法，只需在方法头的返回类型前插入一个泛型声明便可：
linearsearch：线性查找:一种查找方式，从列表项的一端开始，按线性方式进行，直到找到要查找的元素，或达到了列表的末端（代表没有找到要查找的元素）。html

public static <T>   
        boolean linearSearch(T[] data, int min, int max, T target)
    {
        int index = min;
        boolean found = false;

        while (!found && index <= max) 
        {
            found = data[index].equals(target);
            index++;
        }

        return found;
    }

二分查找法
- binarysearch：二分查找对己排序列表的查找，其中每次比较操做，均可以去除人约一
  半的剩余可行候选元素。
- 二分查找将利用了查找池是已排序的这一事实·
- 二分查找的每次比较都会删除一半的可行候选项。
- logarithmic algorithm对数算法:复杂度为0(g2n）的算法，如二叉查找。
- logarithmic sort：对数排序、种排序算法，若是要给n个元素进行排序，须要大约nlog2n
  次比较操做。java

public static <T extends Comparable<T>>  
        boolean binarySearch(T[] data, int min, int max, T target)
    {  
        boolean found = false;
        int midpoint = (min + max) / 2;  // determine the midpoint

        if (data[midpoint].compareTo(target) == 0)
            found = true;

        else if (data[midpoint].compareTo(target) > 0)
        {
            if (min <= midpoint - 1)
                found = binarySearch(data, min, midpoint - 1, target);
        }
        
        else if (midpoint + 1 <= max)
            found = binarySearch(data, midpoint + 1, max, target);

        return found;
    }

二分查找的复杂度是对数级的，这使得它对于大型查找池很是有效率·git
sorting：排序
- 排序是这样一个过程，即基于某一标准，将某一组项目接照某个规定顺序排列“
selectionsort：选择排序:算法经过反复地将某一特定值放到它在列表中的最终已排序位置从而完成
对某一列表值的排序

public static <T extends Comparable<T>> 
        void selectionSort(T[] data)
    {
        int min;
        T temp;
        
        for (int index = 0; index < data.length-1; index++)
        {
            min = index;
            for (int scan = index+1; scan < data.length; scan++)
                if (data[scan].compareTo(data[min])<0)
                    min = scan;
            
            swap(data, min, index);
        }
    }

private static <T extends Comparable<T>> 
        void swap(T[] data, int index1, int index2)
    {
        T temp = data[index1];
        data[index1] = data[index2];
        data[index2] = temp;
    }

insertionsort：插入排序:插入排序算法经过反复地将某一特定值插入到该列表某个已排序的子集中来完成对
列表值的排序·

public static <T extends Comparable<T>> 
        void insertionSort(T[] data)
    {
        for (int index = 1; index < data.length; index++)
        {
            T key = data[index];
            int position = index;
            
            // shift larger values to the right 
            while (position > 0 && data[position-1].compareTo(key) > 0)
            {
                data[position] = data[position-1];
                position--;
            }
            
            data[position] = key;
        }
    }

bubble sort：冒泡排序:冒泡排序算法经过重复地比较相邻元素且在必要时将它们互换，从而完成对某个列
表的排序。

public static <T extends Comparable<T>> 
        void bubbleSort(T[] data)
    {
        int position, scan;
        T temp;
        
        for (position =  data.length - 1; position >= 0; position--)
        {
            for (scan = 0; scan <= position - 1; scan++)
            {
                if (data[scan].compareTo(data[scan+1]) > 0)
                    swap(data, scan, scan + 1);
            }
        }
    }

quicksort:快速排序:快速排序算法经过将列表分区，而后对这两个分区进行递归式排序，从而完成对整
个列表的排序·
- partition：分区快速排序算法使用的未排序元素的一个集合，其中的元素个部小于或大
  于选定的某个元素。
- partitionelement：分区元素快速排序算法用来把未排序元素分隔成两个不一样分区的
  元素。

public static <T extends Comparable<T>> 
        void quickSort(T[] data)
    {
        quickSort(data, 0, data.length - 1);
    }
    
private static <T extends Comparable<T>> 
        void quickSort(T[] data, int min, int max)
    {
        if (min < max)
        {
            int indexofpartition = partition(data, min, max);
            
            quickSort(data, min, indexofpartition - 1);
            
            quickSort(data, indexofpartition + 1, max);
        }
    }
    
private static <T extends Comparable<T>> 
        int partition(T[] data, int min, int max)
    {
        T partitionelement;
        int left, right;
        int middle = (min + max) / 2;
        
        partitionelement = data[middle];
        swap(data, middle, min);
        
        left = min;
        right = max;
        
        while (left < right)
        {
            while (left < right && data[left].compareTo(partitionelement) <= 0)
                left++;
            
            while (data[right].compareTo(partitionelement) > 0)
                right--;
            
            if (left < right)
                swap(data, left, right);
        }
        
        swap(data, min, right);
        
        return right;
    }

mergesort:归并排序:算法经过将列表递归式分红两半直至每一子列表都含有一个元素，而后将
这些子列表归并到一个排序顺序中，从而完成对列表的排序·

public static <T extends Comparable<T>>
        void mergeSort(T[] data)
    {
        mergeSort(data, 0, data.length - 1);
    }
    
private static <T extends Comparable<T>>
        void mergeSort(T[] data, int min, int max)
    {
        if (min < max)
        {
            int mid = (min + max) / 2;
            mergeSort(data, min, mid);
            mergeSort(data, mid+1, max);
            merge(data, min, mid, max);
        }
    }
    
    
    @SuppressWarnings("unchecked")
private static <T extends Comparable<T>>
        void merge(T[] data, int first, int mid, int last)
    {
        T[] temp = (T[])(new Comparable[data.length]);
        
        int first1 = first, last1 = mid;  // endpoints of first subarray
        int first2 = mid+1, last2 = last;  // endpoints of second subarray
        int index = first1;  // next index open in temp array
        
        while (first1 <= last1 && first2 <= last2)
        {
            if (data[first1].compareTo(data[first2]) < 0)
            {
                temp[index] = data[first1];
                first1++;
            }
            else
            {
                temp[index] = data[first2];
                first2++;
            }
            index++;
        }
        
        while (first1 <= last1)
        {
            temp[index] = data[first1];
            first1++;
            index++;
        }
        
        while (first2 <= last2)
        {
            temp[index] = data[first2];
            first2++;
            index++;
        }
        
        for (index = first; index <= last; index++)
            data[index] = temp[index];
   }

radixsort：基数排序:一种排序算法，使用排序密钥而不是直接地进行比较元素，来实现元素排序
- 基数排序是基于队列处理的。算法
sequentialsort:顺序排序:一种排序算法，一般使用嵌套循环，须要大约n2次比较来给n
个元素排序。数组
targetelement：目标元素:在查找操做中要寻找的元素。
viablecandidates:可行候选:查找池中的元素，在这些元素中可能找到目标元素。数据结构

教材学习中的问题和解决过程

问题1：各个排序法的时间和空间复杂度
问题1解决方案：学习
问题2：各个排序法的应用场景
问题2解决方案：
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
　当记录规模较小时，直接插入排序较好；不然由于直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
　快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
　堆排序所需的辅助空间少于快速排序，而且不会出现快速排序可能出现的最坏状况。这两种排序都是不稳定的。
　若要求排序稳定，则可选用归并排序。但前面介绍的从单个记录起进行两两归并的排序算法并不值得提倡，一般能够将它和直接插入排序结合在一块儿使用。先利用直接插入排序求得较长的有序子序列，而后再两两归并之。由于直接插入排序是稳定的，因此改进后的归并排序还是稳定的。
---------------------
做者：Seven17000
来源：CSDN
原文：https://blog.csdn.net/mbuger/article/details/67643185?utm_source=copy
版权声明：本文为博主原创文章，转载请附上博文连接！测试

代码调试中的问题和解决过程

问题1：pp9.2运行出现ui
问题1解决方案：这是一个很是常见的异常，从名字上看是数组下标越界错误，解决方法就是查看为何下标越界。
for (int j = 0;j<=data.length-i;j++) {
这是我错误的条件，后来我发现应该这样写for (int j = 0;j<=data.length-1-i;j++) {
最后测试成功.net
问题2：如何获取程序执行时间？
参考了博客java获取程序执行时间
第一种是以毫秒为单位计算的。

//伪代码

long startTime=System.currentTimeMillis(); //获取开始时间

doSomeThing(); //测试的代码段

long endTime=System.currentTimeMillis(); //获取结束时间

System.out.println("程序运行时间： "+(end-start)+"ms");

//伪代码

long startTime=System.currentTimeMillis(); //获取开始时间

doSomeThing(); //测试的代码段

long endTime=System.currentTimeMillis(); //获取结束时间

System.out.println("程序运行时间： "+(end-start)+"ms");
第二种是以纳秒为单位计算的。

//伪代码

long startTime=System.nanoTime(); //获取开始时间

doSomeThing(); //测试的代码段

long endTime=System.nanoTime(); //获取结束时间

System.out.println("程序运行时间： "+(end-start)+"ns");

//伪代码

long startTime=System.nanoTime(); //获取开始时间

doSomeThing(); //测试的代码段

long endTime=System.nanoTime(); //获取结束时间

System.out.println("程序运行时间： "+(end-start)+"ns");

上周考试错题总结

上周无错题

代码托管

点评过的同窗博客和代码

本周结对学习状况
- 20172312
- 课本内容总结详细，图片较少
- 结对学习内容
  - 课本第九章

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	0/0	1/1	8/8
第二周	500/500	1/2	15/ 23
第三周	802/1302	1/3	12/35
第四周	1530/2832	2/5	15/50
第五周	1165/3997	1/6	10/60

参考资料

《Java软件结构与数据结构教程（第四版）》