数组
数组(是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理）
- 数组是一种引用数据类型，数组对象在堆内存中。
- 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
- 数组创建后长度不可变。
数组的优点：
- 查询效率高
数组的缺点：
- 数据量特别大时不能存储（内存中需要找到足够大的连续内存空间）
- 删除添加效率低，类似于线性表。
一维数组
//静态初始化(定义数组的同时就为数组元素分配空间并赋值)
int[] i = {1,2,3,4,5,6};
int[] i = new int[]{1,2,3,4,5,6};
//动态初始化(数组声明且为数组元素分配空间与赋值的操作分开进行)
//长度为5
int[] i = new int[5];
i[0] = 1;
一维数组的使用
- 数组元素的下标从0开始，长度为n的数组合法下标取值范围0到n-1
- 每个数组都有一个属性length指明它的长度
- 数组一经分配空间会被隐式初始化，引用数据类型默认初始化值为null，基本数据类型初始化值各有不同
多维数组
从数组底层的运行机制看，没有多维数组。
//静态初始化
int[][] arr = new int[][]{{1,2},{3,4},{5,6,7}};
//静态初始化
//x是一维数组，没有初始化，y是二维数组
int[] x, y[] = {{1, 2}, {3, 4}};
int[] x={5,6}, y[] = {{1, 2}, {3, 4}};
//动态初始化
int[][] arr = new int[5][2];
arr[0][0] = 123;
//动态初始化
//每个一维数组默认初始化值为null
int[][] arr = new int[5][];
arr[0] = new int[3];
查找算法
二分查找
public class BinarySearch {
public static void main(String[] args) {
// 二分查找要求数组必须是有序的
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 输入要查找的元素
Scanner scanner = new Scanner(System.in);
System.out.println("输入要查找的元素");
int search = scanner.nextInt();
// 开始偏移量
int start = 0;
// 结束偏移量
int stop = arr.length - 1;
// 中间偏移量
int mid = 0;
// 开始偏移量小于结束偏移量继续往下判断
while (start <= stop) {
// 中间偏移量
mid = (start + stop) / 2;
if (search == arr[mid]) {
System.out.println("存在");
break;
} else if (arr[mid] > search) {
stop = mid - 1;
} else {
start = mid + 1;
}
}
}
}
排序算法
- 假设含有n个记录的序列为{R1、R2、…、Rn}，其相应的关键字序列为{K1、K2、…、Kn}。将这些记录重新排序为{Ri1、Ri2、… 、Rin}，使得相应的关键字值满足条件{Ki1<=Ki2<=…<=Kin}，这样的一种操作称为排序。
- 通常排序的目的是为了更快的查找
- 衡量排序算法的优劣：时间复杂度、空间复杂度、稳定性
- 排序算法分为内部排序和外部排序
内部排序
- 整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
- 从平均时间而言快速排序最佳。但在最坏情况下时间性能不如堆排序和归
并排序(排序之前重新打乱顺序避免最坏情况) - 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序
- 从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排序、快速排序、Shell排序和堆排序是不稳定排序
- 从待排序的记录数n的大小看n较小时，宜采用简单排序；而n较大时宜采用改进排序
冒泡排序
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数
- 针对所有的元素重复以上的步骤，除了最后一个
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止
快速排序
- 快速排序时间复杂度O(nlog(n))
- 从数列中挑出一个元素，称为基准pivot
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数
列排序 - 递归的最底部情形是数列的大小是0或1，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去 。
外部排序
- 参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。
java.util.Arrays工具类
| 方法 | 解释说明 |
|---|---|
| Arrays.sort(int[]) | 排序 |
| Arrays.equals(int[],int[]) | 判断两个数组是否相等 |
| Arrays.toString(int[]) | 返回指定数组内容的字符串表示形式 |
| Arrays.fill(int[],int) | 指定值填充到数组中 |
| Arrays.stream() | |
| Arrays.spliterator() | |
| Arrays.setAll() | |
| Arrays.parallelSort() | 升序 |
| Arrays.binarySerch(int[]，int) | 二分查找 |
| Arrays.asList(T…) |
数组中常见的异常
- 数组脚标越界异常(ArrayIndexOutOfBoundsException)
- 空指针异常(NullPointerException)
面试题
1.Java中的任何数据类型都可以使用System.out.pritln方法显示
- 对基本数据类型而言，输出的往往是变量的值
- 对于像数组这一类复杂的数据类型，输出的是其堆空间中存储位置的hashCode值
2.创建一个长度为6的int型数组，要求取值为1-7，同时元素值各不相同
public class Demo3 {
public static void main(String[] args) {
int[] arr = new int[6];
for (int i = 0; i < arr.length; i++) {// [0,1) [0,7) [1,8)
arr[i] = (int) (Math.random() * 7) + 1;
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j]) {
i--;
break;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
public class Demo3 {
public static void main(String[] args) {
int[] arr = new int[6];
int[] temp = new int[7];
for (int i = 0; i < temp.length; i++) {
temp[i] = i + 1;
}
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
int location = random.nextInt(temp.length - i);
arr[i] = temp[location];
temp[location] = temp[temp.length - 1 - i];
temp[temp.length - 1 - i] = arr[i];
}
System.out.println(Arrays.toString(arr));
}
}
3.回形数格式方阵的实现
- 从键盘输入一个整数（1~20）则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如：
输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
class RectangleTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个数字");
int len = scanner.nextInt();
int[][] arr = new int[len][len];
int s = len * len;
/*
* k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
*/
int k = 1;
int i = 0, j = 0;
for (int m = 1; m <= s; m++) {
if (k == 1) {
if (j < len && arr[i][j] == 0) {
arr[i][j++] = m;
} else {
k = 2;
i++;
j--;
m--;
}
} else if (k == 2) {
if (i < len && arr[i][j] == 0) {
arr[i++][j] = m;
} else {
k = 3;
i--;
j--;
m--;
}
} else if (k == 3) {
if (j >= 0 && arr[i][j] == 0) {
arr[i][j--] = m;
} else {
k = 4;
i--;
j++;
m--;
}
} else if (k == 4) {
if (i >= 0 && arr[i][j] == 0) {
arr[i--][j] = m;
} else {
k = 1;
i++;
j++;
m--;
}
}
}
// 遍历
for (int m = 0; m < arr.length; m++) {
for (int n = 0; n < arr[m].length; n++) {
System.out.print(arr[m][n] + "\t");
}
System.out.println();
}
}
}
class RectangleTest {
public static void main(String[] args) {
int n = 7;
int[][] arr = new int[n][n];
int count = 0; // 要显示的数据
int maxX = n - 1; // x轴的最大下标
int maxY = n - 1; // Y轴的最大下标
int minX = 0; // x轴的最小下标
int minY = 0; // Y轴的最小下标
while (minX <= maxX) {
for (int x = minX; x <= maxX; x++) {
arr[minY][x] = ++count;
}
minY++;
for (int y = minY; y <= maxY; y++) {
arr[y][maxX] = ++count;
}
maxX--;
for (int x = maxX; x >= minX; x--) {
arr[maxY][x] = ++count;
}
maxY--;
for (int y = maxY; y >= minY; y--) {
arr[y][minX] = ++count;
}
minX++;
}
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
String space = (arr[i][j] + "").length() == 1 ? "0" : "";
System.out.print(space + arr[i][j] + " ");
}
System.out.println();
}
}
}
扫一扫
1020
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
