学习大数据的第五天——自习复习了（冒泡、快速、直接插入、反转）排序和二分查找

最新推荐文章于 2022-01-10 22:04:57 发布

三岁清风

最新推荐文章于 2022-01-10 22:04:57 发布

阅读量751

点赞数

文章标签： big data 排序算法大数据 java 开发语言

本文链接：https://blog.csdn.net/weixin_43808721/article/details/122397308

版权

数组的概念：

数组可以看成是多个相同类型数据组合，对这些数据的统一管理。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组的元素可以是任何数据类型，包括基本类型和引用类型。
C和C++中的数组都可以分配在栈上面，而JAVA中的数组是只能分配在堆上面的，因为JAVA中的数组是引用类型。

数组的特点：

数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。
数组的特点：查询快、增删慢集合。可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，效率较高，查询快，增删慢

数组相关的题目

一、填空题
1.数组会在内存中开辟一块___连续_____的空间，每个空间相当于之前的一个变量，称为数组的元素。数组的长度一经确定，就无法再改变。
2.要获取一个数组的长度，可以通过___length____属性来获取，但获取的只是为数组分配的空间的数量，而不是数组中实际已经存放的元素的个数。
3.int[] arr_____仅仅是给出了数组名字和元素的数据类型，要想真正的使用数组还必须使用new关键字为它分配内存空间。
4.创建数组后，系统会给每一个数组元素一个默认的值，如String类型元素的默认值是__null_____。
5.在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ，可以使__array[1][0].length_____得到二维数组中第二维中第一个数组的长度。

二、选择题

在Java中，以下程序段能正确为数组赋值的是（ a ）。（选择二项）

A int a[]={1,2,3,4};
B. int b[4]={1,2,3,4};
C. int c[];c={1,2,3,4};
D. int d[];d=new int[]{1,2,3,4};
数组元素的索引可以是（ d ）。（选择一项）

A 整型常量
B. 整型变量
C. 整型表达式
D. 以上都可以
已知表达式int [] m={0,1,2,3,4,5,6};下面（ b ）表达式的值与数组最大下标数相等。（选择一项）

A m.length()
B. m.length-1
C. m.length()+1
D. m.length+1
在Java中，以下定义数组的语句正确的是（ c d ）。（选择二项）

A int t[10]=new int[ ];
B. char [ ]a=”hello”;
C. String [ ] s=new String [10];
D. double[ ] d [ ]=new double [4][ ];
在Java中,下面代码的输出结果为（ a ）。（选择一项）
public static void main(String[] args) {
int[] arrA = { 12, 22, 8, 49, 3 };
int k = 0;
int len = arrA.length; //5
for (int i = 0; i < len; i++) { //0
for (int j = i + 1; j < len; j++) {//1
if (arrA[i] > arrA[j]) {//
k = arrA[i];
arrA[i] = arrA[j];
arrA[j] = k;
}
}
}
for (int i = 0; i < arrA.length; i++) {
System.out.print(arrA[i]);
if (i < arrA.length - 1) {
System.out.print("，");
}
}
}

A 3，8，12，22，49
B. 12，22，8，49，3
C. 49，22，12，8，3
D. 编译错误
以下选项中能够正确创建一个数组的是（ ad ）。（选择二项）

A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];

三、判断题
1.数组可以声明为任何数据类型，包括任何基本数据类型和引用数据类型。（对）
2.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。但是其元素类型可以是不同类型，允许出现混合类型。（错）
3.声明数组并分配空间后，数组的每个元素将会赋予初始值。（对）
4.创建数组后，系统会给每个数组元素一个默认值，如double型元素的默认值是0.0。（对）
5.数组的主要优点是按照索引查找某个元素效率高，同时按照元素值查询某个元素效率也很高，但是添加和删除元素需要大量移动元素，效率低下。（T）
数组的特点：查询快、增删慢集合
可以利用偏移地址来访问元素，效率高；可以利用折半方法查找元素，效率较高
查询快，增删慢
6.数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。（对）
7.Java允许创建不规则数组，即Java多维数组中各行的列数可以不同。（对）
8.对于数组int[][] t={{1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2（错）

四、简答题
1.数组的特点。
查询快、增删慢、集合
2.数组的优缺点
查询快
增删慢
3.冒泡排序的算法。
数组中相邻的两个元素比较，将最大或者最小值放到末尾，以此循环比较：算法如下：
public static void getFunction2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
printArray(arr);
}
import java.util.Arrays;

排序算法

/*
Java中五种常见的排序方法:
1.Arrays.sort()
2.冒泡排序
3.选择排序
4.反转排序
5.直接插入排序
*/
public class zy8 {

public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        if (i == 0) {
            System.out.print("[" + arr[i] + ",");
        } else if (i == arr.length - 1) {
            System.out.print(arr[i] + "]");
        } else {
            System.out.print(arr[i] + ",");
        }
    }
    System.out.println();
}

public static void getFunction1(int[] arr) {
    Arrays.sort(arr);
    printArray(arr);
}

//int[] arr = {2, 62, 14, 3, 7, 9, 1}
//冒泡排序
public static void getFunction2(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] < arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    printArray(arr);
}

//选择排序
public static void getFunction3(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int num = i;
        for (int j = i; j < arr.length; j++) {
            if (arr[j] < arr[num]) {
                num = j;
            }
        }
        int temp = arr[num];
        arr[num] = arr[i];
        arr[i] = temp;
    }
    printArray(arr);
}

//反转排序(逆序)
public static void getFunction4(int[] arr) {
    for (int i = 0; i < arr.length / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
    printArray(arr);
}

//直接插入排序
public static void getFunction5(int[] arr) {
    int temp;
    for (int i=1;i<arr.length;i++){
        //待排元素小于有序序列的最后一个元素时，向前插入
        if (arr[i]<arr[i-1]){
            temp = arr[i];
            for (int j=i;j>=0;j--){
                if (j>0 && arr[j-1]>temp) {
                    arr[j]=arr[j-1];
                }else {
                    arr[j]=temp;
                    break;
                }
            }
        }

// printArray(arr);
}
printArray(arr);
}

public static void main(String[] args) {
    int[] arr = {2, 62, 14, 3, 7, 9, 1};
    System.out.println("原数组:");
    printArray(arr);
    System.out.println("************************************");
    System.out.println("Arrays.sort()排序后的数组:");
    getFunction1(arr);
    System.out.println("************************************");
    System.out.println("冒泡排序后的数组:");
    getFunction2(arr);
    System.out.println("************************************");
    System.out.println("选择排序后的数组:");
    getFunction3(arr);
    System.out.println("************************************");
    System.out.println("反转排序后的数组:");
    getFunction4(arr);
    System.out.println("************************************");
    System.out.println("直接插入排序后的数组:");
    getFunction5(arr);
}

}

二分查找（非递归）

/*
二分法查找操作：使用二分法查找有序数组中元素。找到返回索引，不存在输出-1。
分析：二分法查找的前提是数组有序。
假如有一组数为3，12，24，36，55，68，75，88要查给定的值24.可设三个变量front，mid，end分别指向数据的上界，中间和下界，mid=（front+end）/2.　　
1)开始令front=0（指向3），end=7（指向88），则mid=3（指向36）。因为mid>x，故应在前半段中查找。
2)令新的end=mid-1=2，而front=0不变，则新的mid=1。此时x>mid，故确定应在后半段中查找。
3)令新的front=mid+1=2，而end=2不变，则新mid=2，此时a[mid]=x，查找成功。
4)如要查找的数不是数列中的数，例如x=25，当第三次判断时，x>a[mid]，按以上规律，令front=mid+1，即front=3，出现front>end的情况，表示查找不成功。
*/
import java.util.Scanner;

public class zy11 {

public static boolean myBinarySearch(int[] arr, int x) {
    int front = 0;
    int end = arr.length - 1;
    while (front <= end) {
        int mid = (front + end) / 2;
        if (x == arr[mid]) {
            return true;
        }
        if (arr[mid] > x) {
            end = mid - 1;
        }
        if (arr[mid] < x) {
            front = mid + 1;
        }
    }
    return false;
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arr = {3, 12, 24, 36, 55, 68, 75, 88};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
    System.out.println("输入你想要查找的数字：");
    int x = sc.nextInt();
    if (myBinarySearch(arr, x)) {
        System.out.println("找到了！");
    } else {
        System.out.println("没找到！");
    }

}

}

二分查找（递归方法）

import java.util.Arrays;
import java.util.Scanner;
public static int recursionBinarySearch(int[] arr, int key, int low, int high) {

    if (key < arr[low] || key > arr[high] || low > high) {
        return -1;
    }
    int middle = (low + high) / 2;            //初始中间位置
    if (arr[middle] > key) {
        //比关键字大则关键字在左区域
        return recursionBinarySearch(arr, key, low, middle - 1);
    } else if (arr[middle] < key) {
        //比关键字小则关键字在右区域
        return recursionBinarySearch(arr, key, middle + 1, high);
    } else {
        return middle;
    }
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arr = {3, 12, 24, 36, 55, 68, 75, 88};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
    System.out.println("输入你想要查找的数字：");
    int x = sc.nextInt();
    int front = 0;
    int end = arr.length - 1;
    int m = recursionBinarySearch(arr, x, front, end);
    if (m == -1) {
        System.out.println("在数组中查找不到!");
    } else {
        m = m + 1;
        System.out.println("查找的数字在第" + m + "位");
    }
}