1. 首页
  2. 文章中心
  3. JavaSE

数组常见思想

115 阅读 0 评论
我是靠谱客的博主 失眠蚂蚁，这篇文章主要介绍数组常见思想，现在分享给大家，希望可以做个参考。

1.最值思想

原理：
假设第一个数为最大值max，遍历获取到数组的每一个元素
拿到每一个元素和这个max进行比较
如果比假定的最大值还要大，那么将该数赋值给最大值

功能：求出最大值
返回值类型：int
参数列表：int[] arr
方法名：getMax

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int getMax(int[] arr){
				//假设第一个数为最大值
				int max = arr[0];
				//遍历数组中的每一个元素
				for(int i = 0; i < arr.length; i++){
					//获取到数组中的每一个元素arr[i]，获取的元素并判断是否比max大
					if(arr[i] > max){
					//设置arr[i]的值为最大值
						max = arr[i];
					}
				}
				return max;
			}

功能：求出最小值
返回值类型：int
参数列表：int[] arr
方法名：getMin

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
public static int getMin(int[] arr) {
	//假设第一个数为最小值
	int min = arr[0];
	//遍历数组中的每一个数，获取arr[i]
	for (int i = 0; i < arr.length; i++) {
	if (arr[i] < min) {
		min = arr[i];
}
}
	return min;
}

2.求和思想

遍历数组中的元素，定义求和变量
功能：求出数列中所有数值的和
返回这类型：int
参数列表：int[] arr
方法名：getSum;

复制代码
1
2
3
4
5
6
7
//定义求和变量
double sum = 0.0;
	for(int i = 0; i < arr.length; i++){
	//累加求和
	sum += arr[i];
	}return sum;

3.求平均值思想

功能：求和数组中所有数据的平均值
返回值类型：int
参数列表：int[] arr
方法名：getAvgValue
遍历数组中的元素，定义求和变量，获取数组元素之和，然后与数组长度相除

复制代码
1
2
3
4
5
6
7
8
9
10
11
public static int getAvgValue(int[] arr) {
			//定义数组中所有数值求和变量
			double sum = 0.0;
			for(int i = 0; i < arr.length; i++){
				sum += arr[i];
			}
			//定义平均值变量
			double average = sum / arr.length;
			return average；
}

4.倒置思想

定义临时变量，遍历次数为i/2,讲A值赋给临时变量，再将B值赋给A值，再将临时变量的值赋给B值
功能：将数组中的数倒置并输出
返回这类型：void
参数列表：int[] arr
方法名：reverseArray

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*
eg:{8,4,2,1,23,344,12}  --> {12,344,23,1,2,4,8}
分析：
第一次交换
第一个数和最后一个数交换位置
定义临时变量
int temp = 0;
temp = arr[0];
arr[0] == arr[arr.length - 1 - 0];
arr[arr,length - 1 - 0] = temp;

第二次交换
第二个数和倒数第二个数交换位置
int temp = 0;
temp = arr[1];
arr[1] = arr[arr.length - 1 - 1];
arr[arr.length -1 - 1] = temp;

第三次交换
第三个数和倒数第三个数交换位置
int temp = 0;
temp = arr[2];
arr[2] = arr[arr.length - 1 - 2];
arr[arr.length - 1 - 2] = temp;

循环体代码：
int temp = 0;
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;

循环此数：
7个数-------------->交换三次
6个数-------------->交换三次
5个数-------------->交换二次
4个数-------------->交换二次
3个数-------------->交换一次
2个数-------------->交换一个
i个数-------------->交换i/2次
*/
public static void reverseArray(int[] arr){
				for(int i = 0; i < arr.length / 2; i++){
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[arr.length - 1 - i];
					arr[arr.length - 1 - i] = temp;
				}
			}

5.查找思想

1.基本查找

1.1遍历查找
功能：查找数组中是否包含此数
数组查找：从键盘中任意输入一个数据，判断数列中是否包含此数
参数列表：int[] arr, int num
返回值类型：boolean
方法名：isContainsNum

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static boolean isContainsNum(int[] arr int num) {
	//定义要查找的数默认在数组中不存在
	boolean flag = false;
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == num) {
		//如果要查找的数等于数组中的数，将flag置为true，并退出循环
			flag = true;
			break;
		}
}
	return flag；
	
}

1.2通过索引查找，并返回该数在数组中的索引值index

返回值类型：int
参数列表：int[] arr ,int num
方法名：baiscSearch

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static int baiscSearch(int[] arr,int num) {
	//定义默认索引值为-1，表示没找到
	int index = -1;
	//遍历数组中的数
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == num) {
		//如果遍历数组中的某个数等于要查找的数，将数列中这个数的下标赋值给index，并退出循环
			index = i;
			break;
}

}
	return index;
}

2.二分查找

前提条件：这个数组中的元素是有序排列的
二分查找的查找过程图
在这里插入图片描述
返回值类型：int
参数列表：int[] arr,int num
方法名:binarySearch

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public static int binarySearch(int[] arr, int num) {
	//定义最大索引和最小索引
	int maxIndex = arr.length - 1;
	int minIndex = 0;
	//计算中间索引
	int midIndex = (maxIndex + minIndex) / 2;
	
	//将中间索引对应的值与要查找的数进行比较，如果比要查找的数大，那么往左边找，如果比要查找的数小，那么往右边找，依次类推，缩小范围
	//定义while循环，一直找这个数
	while ( arr[midIndex] != num) {
		if (arr[midIndex] > num) {
			//如果大于num，下一次的查找的最大值将会变化，等于中间索引的值-1，最小值不变为0
			maxIndex = minIndex - 1;
	}else if (arr[midIndex] < num) {
			//如果小于num,下一次的查找最小值将会变化，等于中间索引的值+1，这时最大值就不变了为maxIndex = arr.length - 1
			minIndex = midIndex + 1;
	}
	//还要判断下如果最小索引大于最大索引的时候
	if (minIndex > maxIndex) {
	//返回-1表示没找到
		return -1;
	}
	midIndex = (maxIndex+minIndex) / 2;	
}
	//相等的话直接返回中间索引
	return midIndex;
}

6.排序思想

1.冒泡排序

原理

a.相邻两个元素进行比较，大的数会冒泡，每趟比较结束后，最大值就出现在最大索引处
b.一共比较了arr.length - 1趟
c.每趟比较的此数比上一次少一次
冒泡排序过程图
在这里插入图片描述

返回值类型：void
参数列表：int[] arr
方法名：bubbleSort

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
public static void bubbleSort (int[] arr) {
	//int [] arr = {24,69,80,55,13};
	/*for (int i = 0; i < arr.lenght - 1 - 0; i++) {
		
		//arr[0]与arr[1]比较
		//arr[1]与arr[2]比较
		//arr[2]与arr[3]比较
		//arr[3]与arr[4]比较
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第一趟排序后的结果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 1; i++) {
		
		//arr[0]与arr[1]比较
		//arr[1]与arr[2]比较
		//arr[2]与arr[3]比较
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第二趟排序后的结果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 2; i++) {
		
		//arr[0]与arr[1]比较
		//arr[1]与arr[2]比较
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第三趟排序后的结果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 3; i++) {
		
		//arr[0]与arr[1]比较
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第四趟排序后的结果："+Arrays.toString(arr));
	*/
	//循环体
	for (int i = 0; i < arr.length -1;i++) {
		for (int j = 0; j < arr.length - 1 - i) {
		if (arr[j] > arr [j+1]) {
			int temp = 0;
			temp = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = temp;
		}
		
		}

	}
	System.out.println("排序后的结果为："+Arrays.toString(arr));
}

2.选择排序

原理

从左边开始，依次和后面的所有数进行比较，小的数往前移，每一趟比较完毕后，最小的数出现在最前面

规律
1.一共比较了arr.length -1趟
2.每趟比上一趟少比较1次
3.每一趟初始比较位置是上一趟位置+1
4.前面的元素依次和后面每一个元素进行比较，小的往前移动

选择排序过程图
在这里插入图片描述
返回值类型：void
参数列表：int[] arr
方法名：selectSort

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public static void selectSort(int[] arr) {
	/*
	//int[] arr = {44,89,100,77,33};
	arr[0]与arr[1]比较
	arr[0]与arr[2]比较
	arr[0]与arr[3]比较
	arr[0]与arr[4]比较
	比较4次
	int i = 0;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第一次选择排序的结果为："+Arrays.toString(arr));

	int i = 1;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第二次选择排序的结果为："+Arrays.toString(arr));
	
	int i = 2;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第三次选择排序的结果为："+Arrays.toString(arr));

	int i = 3;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第四次选择排序的结果为："+Arrays.toString(arr));
	*/
	//循环体
	for (int i = 0; i < arr.length; i++) {
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

3.插入排序

插入过程分析图
在这里插入图片描述
分析过程
插入排序，分有序区和无序区，有序区选数组中最左边的一个，其他属于无序区，然后将无序区的第一个数拿出来，放到临时变量里面，然后这个临时变量里面的值与有序区的第一个数进行比较
如果大于临时区，就放到它后面，如果小于，将临时变量的值赋值给有序区的第一个，有序区的数往后排，依次类推
代码实现如下：

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class DoInsertSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = {22,10,1,55,66,43};
		int i,j;
		//定义临时变量存储要比较的值
		int temp = 0;
		for (i = 1; i < arr.length; i++) {
			temp = arr[i];
			for (j = i - 1; j >= 0; j--) {				
				if (arr[j] < temp) {
					break; 
				}else {
					arr[j+1] = arr[j];
				}
			}
			arr[j+1] = temp;
		}
		System.out.println(Arrays.toString(arr));
	}

}

最后

以上就是失眠蚂蚁最近收集整理的关于数组常见思想的全部内容，更多相关数组常见思想内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(76)

相关文章

java里的for概念,Java入门学习–JavaSE04关于for语句的嵌套，函数与数组概念解析...
java里的for概念,Java入门学习–JavaSE04关于for语句的嵌套，函数与数组概念解析...
说一下 ArrayList 和 LinkedList 的区别？
说一下 ArrayList 和 LinkedList 的区别？
数组相关及其主要思想回顾有关数组总结：
数组相关及其主要思想回顾有关数组总结：
循环结构 整数的个数
循环结构 整数的个数
数组常见思想
数组常见思想
数组总结：常见的思想
数组总结：常见的思想
循环与数组
循环与数组
数组方面的知识以及算法题
数组方面的知识以及算法题

评论列表共有 0 条评论

立即
投稿
返回
顶部