一、数组的遍历
在操作数组时，经常需要依次富翁数组中的每个元素，这种操作称作数组的遍历。
1、for循环遍历
案例一（使用for循环遍历数组）
public class ArrayTest {
public static void main(String[] args){
int[] arr={1,2,3,4,5}; // 定义数组
//通过for循环遍历输出数组
for(int i = 0;i <arr.length;i++){ // 通过索引访问元素
System.out.println(arr[i]);
}
}
}
运行结果
1
2
3
4
5
分析：
在案例一中，我们使用int[] arr={1,2,3,4,5}定义了一个长度为5发数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0 ~4,因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。
2、For-Each语句遍历
遍历数组就是获取数组的每个元素。通常遍历数组都是使用for循环来实现的，但是for循环不够简洁，下面我们简要介绍一下使用foreach语句来实现遍历数组的方法。
java5之后，Java提供了一种更简洁的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索（下标）引来访问数组元素，foreach循环自动遍历数组和集合的每一个元素。
语法格式如下：
for(type element: array){
System.out.println(element);
}
实例二
该实例用来显示数组 myList 中的所有元素：
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
运行结果：
1.9
2.9
3.4
3.5
二、数组的排序（重点）
数组，其实就是一个给定了大小给定了类型的容器，在这容器中有你设定的元素，你可以对这些元素进行各种升降排列，或者找出其中特殊的元素并进行一系列的运算。
1、冒泡排序
在冒泡排序的过程中，不断地比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。
接下来通过几个步骤来具体分析一下冒泡排序的整个过程，具体如下。
第1步,从第一个元素开始,将相邻的两个元素依次进行比较，直到最后两个元素完成比较。
如果前一个元素比后一-个元素大，则交换它们的位置。整个过程完成后，数组中最后一个元素自
然就是最大值，这样也就完成了第一轮比较。
第2步，除了最后一个元素，将剩余的元素继续进行两两比较，过程与第一步相似，这样就
可以将数组中第2大的数放在倒数第2个位置。
第3步，依此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一对元素需要比
较为止。
了解了冒泡排序的原理之后，接下来通过一个案例来实现冒泡排序：
public class 数组排序一冒泡排序 {
public static void main(String[] args){
int[] arr = {9,8,3,5,2};
System.out.print("冒泡排序前:");
printArray(arr); // 打印数组元素
bubbleSort(arr); // 调用排序方法
System.out.print("冒泡排序后：");
printArray(arr); // 打印数组元素
}
//定义打印数组元素方法
public static void printArray(int[] arr){
//循环遍历数组的元素
for (int i = 0;i < arr.length; i++){
System.out.print(arr[i] + " "); //打印元素和空格
}
System.out.println("\n");
}
//定义对数组排序的方法
public static void bubbleSort(int[] arr){
//定义外层循环
for (int i = 0;i < arr.length - 1; i++){
//定义内层循环
for (int j = 0 ; j < arr.length - i- 1; j++){
if(arr[j] > arr[j+1]){ //比较相邻元素
//下面的三行代码用于交换两个元素
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.print("第" + (i + 1) + "轮排序后：");
printArray(arr); // 每轮比较结束打印数组元素
}
}
}
运行结果
冒泡排序前:9 8 3 5 2
第1轮排序后：8 3 5 2 9
第2轮排序后：3 5 2 8 9
第3轮排序后：3 2 5 8 9
第4轮排序后：2 3 5 8 9
冒泡排序后：2 3 5 8 9
在上述案例中，bubbleSort ()方法中通过一个嵌套for 循环实现了冒泡排序。其中，外层循环用来控制进行多少轮比较，每一轮比较都可以确定一个元素的位置，由于最后一个元素不需要进行比较，因此外层循环的次数为arr.length-1。内层循环的循环变量用于控制每轮比较的次数，它被作为角标去比较数组的元素，由于变量在循环过程中是自增的，这样就可以实现相邻元素依次进行比较，在每次比较时如果前者小于后者,就交换两个元素的位置，具体执行过程如图所示：
分析：
在图中的第一轮比较中，第1个元素“9” 为最大值,因此它在每次比较时都会发生位置的交换，被放到最后一个位置。第2轮比较与第1轮过程类似，元素“8”被放到倒数第2个位置。第3轮比较中，第1次比较没有发生位置的交换，在第2次比较时才发生位置交换，元素“5”被放到倒数第3个位置。第4轮比较只针对最后两个元素，它们比较后发生了位置的交换,元素“3” 被放到第2个位置。通过4轮比较，很明显，数组中的元素已经完成了排序。
2、选择排序
举个例子，将数组5 2 0 4 1 3 升序
- 找到数组中最小的 放到第一个位置 0 5 2 4 1 3
- 数组中剩下的找到最小的放在第二个位置 0 1 5 2 4 3
- 继续在剩下的找到最小的放在第三个位置 0 1 2 5 4 3
- 在剩下的找到最小的放在第四个位置 0 1 2 3 5 4
- ~~ 0 1 2 3 4 5 完成
代码演示：
public class 数组排序一选择排序 {
public static void main(String[] args) {
int[] a = {5,2,0,4,1,3};
System.out.print("排序前：");
printArray(a);
xian(a);
System.out.print("排序后：");
printArray(a);
}
public static void printArray(int[] a){
//循环遍历数组的元素
for (int i = 0;i < a.length; i++){
System.out.print(a[i] + " "); //打印元素和空格
}
System.out.println("\n");
}
public static void xian(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int min = i;//找到最小的一个索引
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min])
min = j;
}
if (i != min) {
int temp = a[min];
a[min] = a[i];
a[i] = temp;
}
System.out.print("第" + (i + 1) + "轮排序后：");
printArray(a);
}
}
}
运行结果
排序前：5 2 0 4 1 3
第1轮排序后：0 2 5 4 1 3
第2轮排序后：0 1 5 4 2 3
第3轮排序后：0 1 2 4 5 3
第4轮排序后：0 1 2 3 5 4
第5轮排序后：0 1 2 3 4 5
排序后：0 1 2 3 4 5
3、插入排序
插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
效果图
代码实现：
public class 数组排序一插入排序 {
public static void main(String[] args)
{
int[] ins = {2,3,5,1,23,6,78,34};
int[] ins2 = sort(ins);
for(int in: ins2){
System.out.println(in);
}
}
public static int[] sort(int[] ins){
for(int i=1; i<ins.length; i++){
int temp = ins[i]; //保存每次需要插入的那个数
int j;
for(j=i; j>0&&ins[j-1]>temp; j--){ //这个较上面有一定的优化
ins[j] = ins[j-1]; //把大于需要插入的数往后移动。最后不大于temp的数就空出来j
}
ins[j] = temp; //将需要插入的数放入这个位置
}
return ins;
}
}
运行结果：
1
2
3
5
6
23
34
78
参考：插入排序
4、希尔排序
希尔排序：
希尔排序是一种插入排序的改进算法，可以解决插入排序在某些情况下效率 低下的问题；
基本思想：
希尔排序是对无序表按一定的步长进行分组，每组使用直接插入排序算法（或其他排序算法）进行排序，随着步长的直接减少，当步长减为1时，无序表变为有序表
组内交换法希尔排序（不建议）
import java.util.Arrays;
public class shellsorted {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int[] arr= {5,3,7,4,1,6,8,2};
int temp=0;
int count=0;
// gap 为每次变化的步长
for(int gap=arr.length/2; gap>0; gap/=2) {
//循环到gap=1为止
for(int i=gap;i<arr.length;i++) {
// i->arr.length 为每次排序的分组（比较次数） （因为这里是交换法所以两两分组交换）
// 第一步 4为步长需要4组 即比较4次
// 第二步 2为步长需要 比较6次
// 第三步 1为步长需要比较7次
for( int j=i-gap;j>=0;j-=gap) {
//每两个元素比较只比较一次就退出
//交换元素
if(arr[j]>arr[j+gap]) {
temp=arr[j];
arr[j]=arr[j+gap];
arr[j+gap]=temp;
}
}
}
System.out.println("第"+count+++"轮排序结果:"+Arrays.toString(arr));
}
System.out.println(Arrays.toString(arr));
}
}
运行结果：
第0轮排序结果:[1, 3, 7, 2, 5, 6, 8, 4]
第1轮排序结果:[1, 2, 5, 3, 7, 4, 8, 6]
第2轮排序结果:[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
移位插入法的希尔排序 (推荐）
public class shellsorted {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int[] arr= {5,3,7,4,1,6,8,2};
for(int gap=arr.length/2; gap>0; gap/=2) {
//从第gap个元素开始，逐个对其所在的组进行插入排序
for(int i=gap;i<arr.length;i++) {
int j=i;
int temp=arr[j];
if(arr[j]<arr[j-gap]) {
while(j-gap >= 0 && temp < arr[j-gap]) {
//移动
arr[j]=arr[j-gap];
j-=gap;
}
//找到位置
arr[j]=temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
经验证比较使用直接插入法排序比交换法排序快得多！！！
参考：希尔排序
三、最值操作
在操作数组时，我们会经常获取数组中元素的最值。接下来我们通过一个案例来演示最值的获取：
public class 数组最值 {
public static void main(String[] args){
int[] arr = {3,4,2,7,8,9,6};//定义一个数组
int max = getMax(arr);//调用获取元素最大值的方法
System.out.println("max="+max);//打印最大值
}
static int getMax (int[] arr){
int max = arr[0];//定义变量max记住最大值，首先假设第一个元素为最大值
//下面通过一个for循环遍历输出数组中的元素
for (int x=1;x<arr.length;x++){
if(arr[x] > max){
max = arr[x];
}
}
return max;
}
}
运行结果：
max=9
解析：
案例中getMax ()方法用于求数组中的最大值，该方法中定义了一个临时变量max,
用于记住数组的最大值。首先假设数组中第-个元素arr[0]为最大值，然后使用for 循环对数组进行遍历，在遍历的过程中只要遇到比max值还大的元素，就将该元素赋值给max。这样一来，变量max就能够在循环结束时记住数组中的最大值。需要注意的是，for 循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for 循环只需要从第2个元素开始比较，从而提高程序的运行效率。
扫一扫
578
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
