9.29

工作内容

任务4.4.1 冒泡排序

对数组{0,9,12,1,6,3,7,11}使用冒泡排序法排序

package com.xxm.task4;


/*
对数组{0,9,12,1,6,3,7,11}使用冒泡排序法排序
 */
public class Quest_4_1_1_Sort_Bubble {
    public static void main(String[] args) {
        int arr[] = new int[]{0, 9, 12, 1, 6, 3, 7, 11};
        bubble(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void bubble(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int c;
                    c = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = c;
                }
            }
        }
    }
}

结果如下：

任务4.4.2 插入排序

对数组{0,9,12,1,6,3,7,11}使用插入法排序

package com.xxm.task4;

/*
对数组{0,9,12,1,6,3,7,11}使用插入法排序
 */
public class Quest4_1_2_Sort_Insert {
    public static void main(String[] args) {
        int[] arr = new int[]{0, 9, 12, 1, 6, 3, 7, 11};
        insertSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }


    public static void insertSort(int[] arr) {
        int N = arr.length;
        for (int i = 1; i < N; i++) {
            //将a[i]插入到a[i-1]，a[i-2]，a[i-3]……之中
            for (int j = i; j > 0 && (arr[j] < (arr[j - 1])); j--) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;

            }
        }
    }
}

结果如下：

任务4.4.3 二分插入排序

package com.xxm.task4;
//对数组{0,9,12,1,6,3,7,11}使用二分算法进行排序

import java.util.Arrays;

public class Quest4_1_3_Sort_BinaryInsert{
    public static void main(String[] args) {
        int arr[] = new int[]{0,9,12,1,6,3,7,11};
        binaryInsertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    static void binaryInsertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int left = 0;
            int right = i - 1;//定义左右指针。
            int temp = arr[i];  //定义临时变量，用于存放当前数组数据，以用于数据交换
            int mid;    //定义中间指针
            while (left <= right) { //循环：当左指针<右指针时
                mid = (left + right) / 2;    //给中间指针赋值，当数组有偶数个数据时，中间指针指向中间偏左那一个数据
                if (temp < arr[mid]) {
                    right = mid - 1;//如果当前数组数据<中间指针所指数据，则把中间指针左移并作为新的右指针，并取前半段继续下一步二分
                } else {
                    left = mid + 1;  //如果当前数组数据>=中间指针所指数据，则把中间指针右移并作为新的左指针，并取后半段继续下一步二分
                }   //这个while循环结束后，left<right
            }
            // 然后再把第i个元素前1位（j）与目标位置（left）之间的所有元素后移，再把第i个元素（arr[i]=temp）放在目标位置上。
            for (int j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
            }   //i元素前一位（j）与目标位置（left）之间所有元素元素右移
            arr[left] = temp;   //第i个元素（arr[i]=temp）放在目标位置（left）
        }
        System.out.print("排序后的数组为 ");
    }
}

结果如下：

任务4.4.4 解释数据结构中堆和栈的区别

明天做

 

 

任务4.4.5 交换两数

要用3种方法噢！

package com.xxm.task4;
    /*
    用三种方法交换两个正整数
     */
public class Quest4_2_SwapAB {
    public static void main(String[] args) {
        int a = 15;
        int b = 2315;
        int c = 12315;
        int d = 8;
        int e = 12580;
        int f = 314;
        swap1(a, b);
        swap2(c, d);
        swap3(e, f);
    }

    /*
    方法1：建立临时变量，用于交换
    */
    public static void swap1(int a, int b) {
        int c;
        c = a;
        a = b;
        b = c;
        System.out.println(a + "," + b);
    }

    /*
    方法2：利用异或交换
    */
    public static void swap2(int a, int b) {
        a = a ^ b;
        b = b ^ a;
        a = a ^ b;
        System.out.println(a + "," + b);
    }

    /*
    方法3：利用加法交换
     */
    public static void swap3(int a, int b) {
        a = a + b;
        b = a - 2 * b;
        a = (a - b) / 2;
        b = a + b;
        System.out.println(a + "," + b);

    }
}

输出结果如下：

 

任务4.4.6 求奇数和

使用 for 循环求出 0～300 之间的奇数之和

package com.xxm.task4;

/*
使用 for 循环求出 0～300 之间的奇数之和
 */
public class Quest4_3_Summing {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i < 300; i++) {
            if (i % 2 == 1) {
                sum += i;
            }
        }
        System.out.println("300以内的所有奇数之和为" + sum);
    }
}

输出结果如下：

任务4.4.7 数组去重

去除数组[8, 7, 2, 1, 5, 0, 1, 9, 2]中重复的值，相同的值只保留一个

package com.xxm.task4;

import java.util.ArrayList;

    /*
    去除数组[8, 7, 2, 1, 5, 0, 1, 9, 2]中重复的值，相同的值只保留一个
     */

public class Quest4_4_RemoveSameValue {
    public static void main(String[] args) {
        //使用List遍历的方法。
        int[] arr = new int[]{8, 7, 2, 1, 5, 0, 1, 9, 2};
        ArrayList arrlist = new ArrayList();
        for (int i = 0; i < arr.length; i++) {
            if(!arrlist.contains(arr[i])){
                arrlist.add(arr[i]);
            }
        }
        for (int i = 0; i < arrlist.size(); i++) {
            System.out.println(arrlist.get(i));
        }
    }
}

输出如下：

C1任务36

要想以下 JavaScript 代码符合预期，空格处应该填什么(表达式除外)？

答：要访问age变量，所以填age。

C1任务36-2

要想以下 JavaScript 代码符合预期，空格处应该填什么字符串？

答：created_staff

C1任务37-1

要想以下 JavaScript 代码符合预期，空格处应该填什么整型数字？

答：4

C1任务37-2

要想以下 JavaScript 代码符合预期，空格处应该填什么整型数字？

答：±3

C1任务38

要想以下 JavaScriptt 代码运行符合预期，空格处应该填什么？

答：0.67不是整形数字，所以isNaN('.67)为false，因此横线要填false才能保证后续语句执行。

 

 

 

 

 

学习内容

顺序查找

就是暴力查找，从开头到结尾，逐一对比，查找是否有匹配数据。

 

二分查找

二分查找有一个前提，数列必须是按大小有序排列的数列。

其原理：以升序数列为例，先取数组中间值与目标值比较。

如果目标值<中间值，则取左边的一半数组继续进行二分查找；如果目标值>中间值，则取右边的一半数列进行二分查找。重复数次之后即可。

 

插值查找

插值查找，有序表的一种查找方式。插值查找是根据查找关键字与查找表中最大最小记录关键字比较后的查找方法。插值查找基于二分查找，将查找点的选择改进为自适应选择，提高查找效率。

上面一段看不懂对吧，我也看不太懂。下面我用自己的话捋一遍。

插值查找是一种基于二分查找的算法，只是并非每一次分割数组都是二分，而是以一定的比例来切（例如，3/4+1/4）。

问题来了，这个比例如何确定呢？这就可以引出插值查找的一个前提，要求待查找的数组是有序的，并且分布较均匀。

例如要在一个1~100左右的有序数组里查找一个数69，66的第一个数是6，大概在数组的60%位置，于是取60%作为比例进行第一次分割和查找。同理，第二轮的时候选择90%为比例。

就有点像查字典，如果我们要查一个单词：and，如果用二分查找。那么第一个字母就要查很多次。但是如果直接先找a开头的单词，再找到n开头的单词，再找d开头的单词，就会比二分查找快很多。

 

分块查找

分块查找是二分查找和顺序查找的改进方法。

其原理为，

1、把一个大的线性表分为若干块，每块中的数据可以无序，但是块与块之间必须是有序的。每个块有一个索引值，保证前一个块中的所有索引值都小于后一个块的所有数据的索引值。

2、选取每块中最小的关键字作为该块的索引，建立一个索引表。

3、要查找数据时，先将数据在索引表中查找，确定目标数据所在的块。然后在块中查找所需数据。

 

哈希查找

哈希查找是通过计算数据元素的存储地址进行查找的一种方法。

哈希查找的操作步骤（以数组{16,123,33,289,5,1,153}为例）：

1.用给定的哈希函数构造哈希表；

例如:

int H[] = new int[arr.length-1];
public void K(n){
             arr.fori{H[i]= arr[i] % 10
            }
}

这样上一个数组就变成了哈希表{6,3,3,9,5,1,3}

2.根据选择的冲突处理方法解决地址冲突；

设哈希地址为Hash[i]。

将哈希表中的数据按顺序分配进哈希地址。

原数据	哈希表中数据	哈希地址	查找次数
16	6	6	1
123	3	3	1
33	3	4（3位置有数据，顺延）	2
289	9	9	1
5	5	1	1
1	1	1	1
153	3	7（3-6有数据，顺延）	5

3.在哈希表的基础上执行哈希查找。

List类

作用

实现列表功能。

导入

import java.util.List;

常用方法

size()

返回此列表中的元素数

contains(Object o)

如果该列表中包含o，则返回true。

get(int index)

返回此列表中指定位置的元素

set(int index,E element)

用指定的元素替换列表中指定位置的元素。

add(E e)

将元素添加到列表末尾。

add(int index ,E e)

将元素添加到指定位置

remove(int index)

删除此列表中指定位置的元素（可选操作）。 将任何后续元素向左移位（从索引中减去一个元素）。 返回从列表中删除的元素。

ArrayList类

作用

基于数组，实现列表功能。（？）

导入

import java.util.ArrayList;

常用方法

大部分都跟List类差不多，不多赘述。如果有不一样，多查文档。