数组统计：求总和、均值、统计偶数个数等

思路

遍历数组，挨个的累加，判断每一个元素

示例代码1

  1. int[] arr = {4,5,6,1,9};
  2. //求总和、均值
  3. int sum = 0;//因为0加上任何数都不影响结果
  4. for(int i=0; i<arr.length; i++){
  5.     sum += arr[i];
  6. }
  7. double avg = (double)sum/arr.length;

示例代码2

int[] arr = {4,5,6,1,9};

//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
    result *= arr[i];
}

示例代码3

int[] arr = {4,5,6,1,9};
//统计偶数个数
int even = 0;
for(int i=0; i<arr.length; i++){
    if(arr[i]%2==0){
        even++;
    }
}

数组的顺序查找

顺序查找：挨个查看
要求：对数组元素的顺序没要求

顺序查找示例代码

//查找value第一次在数组中出现的index
public static void main(String[] args){
    int[] arr = {4,5,6,1,9};
    int value = 1;
    int index = -1;

    for(int i=0; i<arr.length; i++){
        if(arr[i] == value){
            index = i;
            break;
        }
    }

    if(index==-1){
        System.out.println(value + "不存在");
    }else{
        System.out.println(value + "的下标是" + index);
    }
}

数组找最值

1574577970893.png

思路

  • 先假设第一个元素最大/最小
  • 然后用max/min与后面的元素一一比较

示例代码

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

数组中找最值及其下标

情况一

找最值及其第一次出现的下标

思路

  • 先假设第一个元素最大/最小
  • 用 max/min 变量表示最大/小值，用 max/min 与后面的元素一一比较
  • 用 index 时刻记录目前比对的最大/小的下标

示例代码

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
        index = i;
    }
}

思路2

  • 先假设第一个元素最大/最小
  • 用 maxIndex 时刻记录目前比对的最大/小的下标，那么 arr[maxIndex] 就是目前的最大值
    int[] arr = {4,5,6,1,9};
//找最大值
int maxIndex = 0;
for(int i=1; i<arr.length; i++){
  if(arr[i] > arr[maxIndex]){
      maxIndex = i;
  }
}
System.out.println("最大值：" + arr[maxIndex]);

情况二

找最值及其所有最值的下标（即可能最大值重复）

思路

  • 先找最大值，假设第一个元素最大，用max与后面的元素一一比较
  • 遍历数组，看哪些元素和最大值是一样的

示例代码

int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
    if(arr[i] > max){
        max = arr[i];
    }
}

//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
    if(max == arr[i]){
        System.out.print(i+"\t");
    }
}

4.9.5 冒泡排序

经典算法之冒泡排序（Bubble Sort）
原理：比较两个相邻的元素，将值大的元素交换至右端
思路：依次比较相邻的两个数，将小数放到前面，大数放到后面

例如：冒泡：从小到大，从左到右两两比较
/*
{6,3,8,2,9,1}
    第一轮：
    第1次：arr[0]与arr[1]比较，6>3成立，就交换，{3,6,8,2,9,1}
    第2次：arr[1]与arr[2]比较，6>8不成立，不交换{3,6,8,2,9,1}
    第3次：arr[2]与arr[3]比较，8>2成立，就交换，{3,6,2,8,9,1}
    第4次：arr[3]与arr[4]比较，8>9不成立，不交换{3,6,2,8,9,1}
    第5次：arr[4]与arr[5]比较，9>1成立，就交换，{3,6,2,8,1,9}

    第一轮结果：{3,6,2,8,1,9}   9已经到达正确位置，下一轮不用在参与

    第二轮：
    第1次：arr[0]与arr[1]比较，3>6不成立，不交换{3,6,2,8,1,9}
    第2次：arr[1]与arr[2]比较，6>2成立，就交换，{3,2,6,8,1,9}
    第3次：arr[2]与arr[3]比较，6>8不成立，不交换{3,2,6,8,1,9}
    第4次：arr[3]与arr[4]比较，8>1成立，就交换，{3,2,6,1,8,9}

    第二轮结果：{3,2,6,1,8,9}   8已经到达正确位置，下一轮不用在参与

    第三轮：
    第1次：arr[0]与arr[1]比较，3>2成立，就交换，{2,3,6,1,8,9}
    第2次：arr[1]与arr[2]比较，3>6不成立，不交换{2,3,6,1,8,9}
    第3次：arr[2]与arr[3]比较，6>1成立，就交换，{2,3,1,6,8,9}

    第三轮结果：{2,3,1,6,8,9}   6已经到达正确位置，下一轮不用在参与

    第四轮：
    第1次：arr[0]与arr[1]比较，2>3不成立，不交换{2,3,1,6,8,9} 
    第2次：arr[1]与arr[2]比较，3>1成立，就交换，{2,1,3,6,8,9} 

    第四轮结果：{2,1,3,6,8,9}    3已经到达正确位置，下一轮不用在参与

    第五轮
    第1次：arr[0]与arr[1]比较，2>1成立，就交换，{1,2,3,6,8,9}

    第五轮结果：{1,2,3,6,8,9}   2已经到达正确位置，下一轮不用在参与

    剩下1，肯定是最小的了，不用比较了

    6个元素，比较了5轮， n个元素需要n-1轮
    每一轮比较很多次
*/

示例代码

public static void main(String[] args){
    int[] arr = {6,3,8,2,9,1};  //arr.length = 6

    //i=1,2,3,4,5  一共5轮
    for(int i=1; i<arr.length; i++){//轮数
        /*
        i=1，第1轮，j=0,1,2,3,4   arr[j]与arr[j+1]
        i=2，第2轮，j=0,1,2,3     arr[j]与arr[j+1]
        i=3，第3轮，j=0,1,2       arr[j]与arr[j+1]
        i=4，第4轮，j=0,1         arr[j]与arr[j+1]
        i=5，第5轮，j=0           arr[j]与arr[j+1]

        j=0, j<=arr.length-1-i
        */
        for(int j=0; j<=arr.length-1-i; j++){
            if(arr[j] > arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

    //结果
    for(int i=0; i<arr.length; i++){
        System.out.print(arr[i] + " ");
    }
}