20182328 2019-2020-1 《数据结构与面向对象程序设计》第八周学习总结

教材学习内容总结

查找

查找的概念：查找是在一组项内找到指定目标或是确定目标不存在的过程
线性查找：从数组表头开始，依次将某个值与目标元素比较，最后找到目标或者目标不存在于数组中

核心代码

    private static int search(int[] arr, int key) {
        int index = -1;
        int i = 0;
        for (int n : arr) {
            if (n==key){
                index=i;
                break;
            }
            i++;
        }
        return index;
    }

二分查找：将表中间位置的元素与目标元素比较，如果两者相等，则查找成功；否则利用中间位置将表分成前、后两个子表，如果中间位置元素大于目标元素，则进一步查找前一子表，否则进一步查找后一子表。

核心代码

    public static int search(int[] nums, int num) {
        int low = 0;
        int high = nums.length - 1;
 
        while (low <= high) {
            int mid = (low + high) / 2;
            if (num > nums[mid]) {
                low = mid + 1;
            } else if (num < nums[mid]) {
                high = mid - 1;
            } else {
                return mid;
            }
        }
 
        return -1;
    }

哈希表查找：哈希表是根据关键码值而直接进行访问的数据结构。也就是说，它通过把目标元素映射到表中一个位置来访问查找。

核心代码

    public void insert(T x) {
        List<T> whichList=theLists[myhash(x)];
        if(!whichList.contains(x)) {
            whichList.add(x);
            if(++currentSize>theLists.length)
                rehash();
        }
    }
    public void remove(T x) {
        List<T> whichList=theLists[myhash(x)];
        if(whichList.contains(x)) {
            whichList.remove(x);
            currentSize--;
        }
    }
    public boolean contains(T x) {
        List<T> whilchList=theLists[myhash(x)];
        return whilchList.contains(x);
    }
    public void makeEmpty() {
        for(int i=0;i<theLists.length;i++)
            theLists[i].clear();
        currentSize=0;
    }

排序

选择排序：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

核心代码

public class SelectionSort {

    public static String selectionSort(int[] arr) {
        
        for(int i=0; i<arr.length; i++) {
            int minIndex = i;
            for(int j=i; j<arr.length; j++) {
                if(arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int tmp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = tmp;
        }
        
        return Arrays.toString(arr);
    }

冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换它们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个，持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

核心代码

public static void bubbleSort(int []arr) {

        for(int i =1;i<arr.length;i++) { 
            for(int j=0;j<arr.length-i;j++) {
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    
                    arr[j]=arr[j+1];
                    
                    arr[j+1]=temp;
            }
            }    
        }

快速排序:先从序列中取出一个数作为基准数；
分区过程：将把这个数大的数全部放到它的右边，小于或者等于它的数全放到它的左边；递归地对左右子序列进行不走2，直到各区间只有一个数。

核心代码

public class TestQuickSort {
        private static int partition(int[] arr, int low, int high) {
               
        int i = low;
        int j= high;
        int x = arr[low];
         while(i<j){
         arr[j]
         while(arr[j]>=x && i<j){
        j--;
            }
        if(i<j){
        arr[i] = arr[j];
         i++;
        }
    while(arr[i]<x && i<j){
         i++;
        }
        if(i<j){
        arr[j] = arr[i];
        j--;
           }
       }
                
        
        arr[i] = x;//arr[j] = y
        return i; //return j;
        }
        private static void quickSort(int[] arr, int low, int high) {
                if(low < high){
             intindexpartition(arr,low,high);
             quickSort(arr,low,index-1);
             quickSort(arr,index+1,high);
                }
        }

归并排序:归并排序是一种基于递归策略的排序算法。它采用分治法，归并排序将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后再将他们合并成一个子序列。合并两个子序列的过程也就是两路归并。

核心代码

public class MergeSort {
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];
        int p1=left,p2=mid+1,k=left;
        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];
        while(p2<=right) tmp[k++]=a[p2++];
        for (int i = left; i <=right; i++) 
            a[i]=tmp[i];
    }

    public void mergeSort(int [] a,int start,int end){
        if(start<end){
            int mid=(start+end)
            mergeSort(a,start,mid);
            mergeSort(a,mid+1,end);
            merge(a, start, mid, end);
        }
    }

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

问题1：在java中线性查找和二分查找有什么区别？
优劣各是什么？
问题1解决方案：二分查找法的查找次数比线性查找少，查找速度快，但是要求待查表为有序表，且插入删除困难，条件要求比线性查找多。
问题2：快速排序和归并排序哪个效率高？
问题2解决方案：首先可各自的时间复杂度做一个比较，通过比较两者均为O(nlogn)，但大O的作用是给出一个规模的上的比较，到底谁更快还得看具体的平均时间所处理的数据量，下面是我从网上收集的测试数据：