Java笔记5 数组、排序和查找

最新推荐文章于 2022-11-10 14:20:45 发布

Zero灵渡

最新推荐文章于 2022-11-10 14:20:45 发布

阅读量241

点赞数 3

分类专栏： Java笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44736498/article/details/123341831

版权

Java笔记专栏收录该内容

18 篇文章 1 订阅

订阅专栏

5.1 数组

5.1.1 定义

int a[];与int[] a;均可

5.1.2 初始化

动态初始化：int a[] = new int[10];
静态初始化：int a[] = {3, 5, 2, 1, 7};

5.1.3 细节

数组创建后，如果没有赋值，有默认值
- int: 0，short: 0, byte: 0, long: 0, float: 0.0, double: 0.0，
- char: \u0000，boolean: false，String: null
数组属于引用类型，数组型数据是对象（object）
数组赋值机制
数组在默认情况下是引用传递，赋的值是地址

数组拷贝

int[] arr1 = {10, 20, 30};
int[] arr2 = new int[arr1.length];
for (int 1 = 0; i < arr1.length; i++) {
  arr2[i] = arr1[i];
}

数组反转
- 方法一：首位交换
- 方法二：逆序赋值
数组添加、扩容
- 定义初始数组 int[] arr = {1,2,3}//下标 0-2
- 定义一个新的数组int[] arrNew = new int[arr.length+1];
- 遍历 arr 数组，依次将 arr 的元素拷贝到 arrNew 数组
- 将 4 赋给 arrNew[arrNew.length - 1] = 4;把 4 赋给 arrNew 最后一个元素
- 让 arr 指向 arrNew ;arr = arrNew;那么原来 arr数组就被销毁

5.2 排序

5.2.1 分类

内部排序法（指将需要处理的所有数据都加载到内部存储器中进行排序。）
- 交换排序法
- 选择排序法
- 插入式排序法
外部排序法（数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。）
- 合并排序法
- 直接合并排序法

5.2.2 冒泡排序法（Bubble Sorting）

通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

public class BubbleSorting {
    public static void main(String[] args) {
        int[] a = {24, 69, 80, 57, 13};
        int temp = 0;
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println("\n排序后为：");
        for (int i = a.length - 1; i>=0; i--) {
            for (int j = 0; j < i; j++) {
                if(a[j] > a[j+1]) {
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

5.3 查找

顺序查找
二分查找

5.4 多维数组

以二维数组为例

5.4.1 动态初始化

类型[] 数组名 = new 类型[大小][大小];
类型[] 数组名 = new 类型[大小][]; //列数不确定
- 要给每一个一维数组开辟空间数组名[i] = new 类型[大小];

5.4.2 静态初始化

类型数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}};

5.4.3 杨辉三角

public class YangHui {
    public static void main(String[] args) {
        int a[][] = new int[10][];
        for (int i = 0; i<a.length; i++) {
            a[i] = new int[i+1];
            for (int j = 0; j < a[i].length; j++) {
                if (j == 0 || j == a[i].length - 1) {
                    a[i][j] = 1;
                } else {
                    a[i][j] = a[i-1][j] + a[i-1][j-1];
                }
            }
        }
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}

5.4.4注意事项

一维数组的声明方式有: int[] x 或者 int x[]
二维数组的声明方式有: int[][] y或者 int[] y[] 或者int y[][]

5.5 作业

下面数组定义正确的有：
1. String strs[] = {'a', 'b', 'c'};//error, char -> String
2. String strs[] = {"a", "b", "c"};//ok
3. String strs[] = new String{"a", "b", "c"};//error, String[] -> String
4. String strs[] = new String[]{"a", "b", "c"};//ok
5. String strs[] = new String[3]{"a", "b", "c"};//error, 编译不通过
写出结果

String foo = "blue";

boolean[] bar = new boolean[2];

if (bar[0]) {

	foo = "green";

}

System.out.println(foo);

结果为blue，boolean数组初始化为false

有个升序的数组，要求插入一个元素，该数组顺序依然是升序

import java.util.*;
/*
数组插入元素保持升序（定位+动态扩容）
 */
public class AddSort {
    public static void main(String[] args) {
        int [] arr = {10, 12, 45, 90};
        AddSort as = new AddSort();
        as.arrPrint(arr);
        System.out.print("插入一个数(-1退出)：");
        Scanner sc = new Scanner(System.in);
        int insertNum = sc.nextInt();
        int index = -1;

        while(insertNum != -1) {
            arr = as.arrayCapacity(arr, insertNum);
            as.arrPrint(arr);
            System.out.print("插入一个数(-1退出)：");
            insertNum = sc.nextInt();
        }
    }
    public int getIndex(int[] arr, int insertNum) {
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(insertNum < arr[i]) {
                index = i;
                break;
            }
        }
        if (index < 0) {
            return arr.length;
        } else {
            return index;
        }
    }
    public int[] arrayCapacity(int[] arr, int insertNum) {
        int index = getIndex(arr, insertNum);
        int[] arrNew = new int[arr.length+1];
        for (int i = 0; i < arrNew.length; i++) {
            if (i < index) {
                arrNew[i] = arr[i];
            } else if(i == index) {
                arrNew[i] = insertNum;
            } else{
                arrNew[i] = arr[i-1];
            }
        }
    
        return arrNew;
    }
    public void arrPrint(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

随机生成10个整数（1-100）保存到数组，并倒序打印以及求平均值，求最大值和最小值的下标，并查找里边是否有8

import java.lang.Math;
public class ChaZhaoTest {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * 100) + 1;
        }
        arrPrint(arr);
        reversePrint(arr);
        getAverage(arr);
        getMaxIndex(arr);
        getMinIndex(arr);
        has8(arr);
    }
    public static void arrPrint(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void reversePrint(int[] arr) {
        for (int i = arr.length-1; i >= 0; i--) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void getAverage(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("average:" + (double)sum / arr.length);
    }
    public static void getMaxIndex(int[] arr) {
        int max = -1;
        int maxIndex = 0;
        for (int i = 0; i < arr.length; i++) {
            if(max < arr[i]){
                maxIndex = i;
                max = arr[i];
            }
        }
        System.out.println("maxIndex:" + maxIndex);
    }
    public static void getMinIndex(int[] arr) {
        int min = 101;
        int minIndex = 0;
        for (int i = 0; i < arr.length; i++) {
            if(min > arr[i]){
                minIndex = i;
                min = arr[i];
            }
        }
        System.out.println("minIndex:" + minIndex);
    }
    public static void has8(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 8) {
                sum++;
            }
        }
        System.out.println("has "+ sum + "eight");
    }
}