黑马程序员_数组

101 阅读 0 评论 67 点赞

我是靠谱客的博主外向毛衣，这篇文章主要介绍黑马程序员_数组，现在分享给大家，希望可以做个参考。

------- android培训、java培训、期待与您交流！ ----------

数组

概念

数组是一种数据结构，用来存储同一类型的数据集合。通过一个整型整型下标可以访问数组的每一个值。

声明方式

一维数组：

1、静态初始化：在定义数字的同时为数组元素分配空间并赋值。

格式一：元素类型[] 数组名 = new 元素类型{元素1，元素2，元素3，........}；

Eg: int[] arr = new int{2,3,4,5};

格式二：元素类型[] 数组名 = {元素1，元素2，元素3，元素4，..................}；

Eg: int[] arr = {1,2,3,4,5,11}

2、动态初始化：数组定义域为数组分配空间和赋值的操作分开进行

Eg: int[] a = new int{5};

a[0] = 12;

a[1] = 1;

a[2] = 3;

a[3] = 8;

a[4] = 23;

常见操作

1、遍历

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
<span style="font-size:18px;">public class Test {

	public static void main(String[] args) 
	{
		int[] arr = new int[]{21,123,7,5,12,76};
		for(int x =0;x<arr.length;x++)
		{
			System.out.println(arr[x]);
		}
	}
}
</span>

2、获取最值

复制代码

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
<span style="font-size:18px;">public class Test {

	public static void main(String[] args) 
	{
		int[] arr = new int[]{21,123,7,5,12,76};
		getMax(arr);//求最大值
		getMin(arr);//求最小值
	}
	public static void getMax(int[] arr)//定义求数组最大值的方法
	{
		int max = arr[0];
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x]> max)
				max = arr[x];
		}
		System.out.println("最大值："+max);
	}
	public static void getMin(int[] arr)//定义求数组最小值的方法
	{
		int min = arr[0];
		for(int x = 0;x<arr.length;x++)
		{
			if(arr[x] < min)
				min = arr[x];
		}
		System.out.println("最小值："+min);
	}
}</span>

输出：最大值：123
最小值：5

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
25
26
27
<span style="font-size:18px;">public class Test {

	public static void main(String[] args) 
	{
		int[] arr = new int[]{21,123,7,5,12,76};
		select_sort(arr);
		for(int x = 0;x<arr.length;x++)
		{
			System.out.print(arr[x]+"t");
		}
	}
	public static void select_sort(int[] arr)//定义选择排序方法
	{
		for(int x= 0;x<arr.length-1;x++)
		{
			for(int y=x+1;y<arr.length;y++)
			{
				if(arr[x] > arr[y])
				{
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
}</span>

冒泡排序：重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换

复制代码

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
public class Test {

	public static void main(String[] args) 
	{
		int[] arr = new int[]{21,123,7,5,12,76};
		bubble_sort(arr);//冒泡排序
		for(int x = 0;x<arr.length;x++)//打印排序后数组的所有元素
		{
			System.out.print(arr[x]+"t");
		}
	}
	public static void bubble_sort(int[] arr)//定义冒泡排序方法
	{
		for(int x = 0;x<arr.length-1;x++)//x控制循环次数
		{
			for(int y = 0;y<arr.length-1-x;y++)//y控制每次循环
			{
				if(arr[y] > arr[y+1])
				{
					int temp = arr[y+1];
					arr[y+1] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
}

4、折半查找（二分查找）

原理：首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

优点：比较次数少，查找速度快要求待查表为有序表，且插入删除困难

复制代码

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 class Test {

	public static void main(String[] args) 
	{
		int[] arr = new int[]{21,123,7,5,12,76};
		int index = halfSearch(arr,7);
		System.out.println(index);
	}
	public static int halfSearch(int[] arr,int key)//定义折半查找的方法
	{
		int min = 0;
		int max = arr.length - 1;
		int mid = (min + max)/2;		
		while(arr[mid] != key)
		{
			if(key < arr[mid])
			{
				max = mid - 1;
			}
			else if(key > arr[mid])
			{
				min = mid + 1;
			}
			mid = (mid + max)/2;
		}
		return mid;
	}
}