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

时间：2018-10-16 22:10:59 阅读：332 评论：0 收藏：0 [点我收藏+]

标签：归并 down point mis main 分割 htm 分享图片 any

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

教材学习内容总结

==《Java软件结构与数据结构》第九章-排序与查找==

一、查找

①.查找概念： 在一个项目中寻找一个元素或者判断一个元素是否存在在这个项目中。
②.查找的类型： 查找在第九章主要讨论了两种类型，一种是线性查找、另一种是二分查找。
③.查找的目标： 查找实际就是不同元素之间的比较过程，而查找的目标就是为了找到某个元素，在查找的同时保持最高效的性能。

二、线性查找法

①.线性查找法的概念： 如果该项目为某类型的列表，则线性查找法的实现既是从头到尾依次比较每一个值，直到找到或者遍历到最后。
线性查找示意图
②.方法实现：

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;
    }

三、二分查找法

①.二分查找概念： 二分查找每一次查找都将现有元素组缩减一半可行候选项，大大加强效率。图二分
②.二分查找前提要求： ==该元素组应该是已排序好了的。==
③.二分查找法实现：

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;
    }

④.线性查找与二分查找的优劣比较：
- 线性查找的优势：在于比二分查找更加简单，==调试与编程更容易==。线性查找==无需对队列进行排序即可使用==
- 二分查找的优势：线性查找的时间复杂度为==O(n)==,二分查找的时间复杂度为==O(log2 n)==,在随着n的变大，二分查找的效率会远远高于线性查找。

四、排序

①.排序概念：
- 1.排序是按照某个特定要求，对一组元素进行升序或者降序的规律进行排序。
- 2.根据效率分为两类排序：顺序排序、对数排序
- 3.顺序排序根据方法实现不同分为三种：选择排序、插入排序、冒泡排序。
- 4.对数排序根据方法实现不同分为两种：快速排序、归并排序。

五、顺序排序

①选择排序法概念： 遍历一次列表所有元素，将最大或最小的元素放在第一位，然后再次遍历该列表除此之外的元素，重复这些操作直到最后一位元素。选择示意图
代码实现：

public class SelectionSort {
 
    public static void selectionSort(int[] a) {
        int n = a.length;
        for (int i = 0; i < n; i++) {
            int k = i;
            
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[k]) {
                    k = j;
                }
            }
    
            if (k > i) {
                int tmp = a[i];
                a[i] = a[k];
                a[k] = tmp;
            }
        }
    }
 
    public static void main(String[] args) {
        int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 };
        selectionSort(b);
        for (int i : b)
            System.out.print(i + " ");
    }
}

②插入排序法概念： 该排序法的用法就是从左第二元素开始向左或者右进行一个一个比较，每一次比较有两种情况，若是按照从小往大排的话，提出的元素与它现有位置左边的小则该元素向左移动一位，而之前的元素向后一位；如果提出元素比它左边位置的大则停止该元素的比较，开始下一个元素的比较。
插入排序法示意图
插入排序法代码实现：

public static void insertSort(int[] numbers)
    {
    int size = numbers.length;
    int temp = 0 ;
    int j =  0;
    
    for(int i = 0 ; i < size ; i++)
    {
        temp = numbers[i];
     
        for(j = i ; j > 0 && temp < numbers[j-1] ; j --)
        {
        numbers[j] = numbers[j-1];
        }
        numbers[j] = temp;
    }
    }

③冒泡排序法概念： 这个排序方法在一定程度上与插入排序法相似，刚开始的步骤与插入排序相同，都是将一个元素与左边或者右边的元素比较，若是从小到大排序的前提，左边元素大过右边元素则向右一位继续该步骤，但是一旦小于右边元素，则该元素固定，刚刚较大的元素开始向右比较，以此类推。
冒泡排序法示意图
冒泡排序法代码实现：

private static void bubbleSort(int[] sortNum)
    {
        int temp = 0;
        for (int i = 0; i < sortNum.length-1; i++) 
        {           
            for (int j = 0; j < sortNum.length-1-i; j++) 
            {       
                if(sortNum[j+1]<sortNum[j])
                {               
                    temp = sortNum[j];
                    sortNum[j] = sortNum[j+1];
                    sortNum[j+1] = temp;
                }
            }
        }
    }

五、对数排序

①快速排序法概念： 这个方法引入了三个重要变量i、j、k，i为==左侧变量==，j为==右侧变量==，k为==基准值==。该方法开始时需选择一个k（一般选择的是第一个元素），（==第一次遍历==）然后i变量从左边一直遍历到最右边，每次将i所在元素与基准值比较，若是大于基准值的该元素与基准值进行互换位置。（==第二次遍历==）从右边开始将小于基准值的元素进行调换顺序直到最左边。此时基准值左边的元素均小于基准值，而基准值右边的元素均大于基准值，则此时分为两个区域，对于这两个区域继续进行上述步骤直到无法分开。
快速排序法图示
快速排序法代码实现：


public class QuickDemo {
    public static void main(String[] args) 
    {
        int[] arr = { 5,2,4,9,7 };
        sort(arr, 0, arr.length - 1);
    }
    public static void sort(int arr[], int low, int high) 
    {
        int l = low;
        int h = high;
        int k = arr[low];
        while (l < h) 
        {
        
            while (l < h && arr[h] >= k 
            { 
                h--;// h=6
            }
            if (l < h) 
            {
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                
                l++;
            }
        
            while (l < h && arr[l] <= k) 
            {  
                l++;
            }
            if (l < h) 
            {
                int temp = arr[h];
                arr[h] = arr[l];
                arr[l] = temp;
                h--;
            }
            
        }
        print(arr);
        System.out.print("l=" + (l + 1) + "h=" + (h + 1) + "k=" + k + "\n");
    
        if (l > low)
        if (h < high)
            sort(arr, l + 1, high);

②归并排序法概念： 这个方法在我看来是分为三步，第一步是分割的思想，将一组元素从中间开始分开，直到分到一个一个元素，第二步就是将分开的元素进行比较。第三步就是比较之后的合并为一组元素。
归并排序法图示

六、基数排序

概念：这个方法会是利用元素的位数进行排序的，分为10个组内（0,1,2,3,4，...，9）第一次从第一位开始分（即个位）放在相应组内，然后按照从0到9的顺序拿出来，再进行十位的放置，再按0到9的顺序拿出，直到这些元素最高位结束
直截了当的图片解释：
个位排序图
十位排序图
百位排序图

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

问题1：插入排序与冒泡排序他们之间排序过程中有许多相似之处那么它们之间的效率方面究竟谁更好呢？
解答：首先插入排序的时间复杂度为O (n^2)，冒泡排序的时间复杂度为O (n^2)。所以光从时间复杂度上是无法判断的，那么我们可以直接定义他们效率相同吗？显然是不行的，在pp9.3的编写过程中就明确规定要求出该问题的答案，在测试中可以一眼看出，冒泡排序花费的时间比插入排序少一些但是操作数远大于插入排序图对比
冒泡：
插入：
问题2：在什么情况下，二分排序法比顺序排序法效率要高呢？
解答：由于二分排序法的大多方法都是递归实现排序的，且数据越多，对二分排序法时间要求不高，而顺序排序法则影响较大，如果要具体到多少个元素来判断零界点的话，只能具体问题具体分析。

代码调试中的问题和解决过程
问题1：在使用书上自带的检测类型时，发现超出范围的问题。图
解决：经过debug发现在第5个的时候超出范围了，后面检测循环条件的时候发现当第五个元素在于第七个元素比较的时候，数组为0-6，没有7则会报错，稍改一下条件就解决了图
问题2：在做pp9.2的时候出现了输出地址的情况图
解决：经过检查发现是使用sout的时候带入的变量错了多加一个S就出问题了。图