打怪升级之小白的大数据之旅(六)＜Java基础语法之数组的基本算法＞-CSDN博客

//示例代码：
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9};
        //求总和、均值
        int sum = 0;//因为0加上任何数都不影响结果
        for(int i=0; i<arr.length; i++){
            sum += arr[i];
        }
        //均值
        double avg = (double)sum/arr.length;
    }
}

示例代码2：

//示例代码2：
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9};
        //求总乘积
        long result = 1;//因为1乘以任何数都不影响结果
        for(int i=0; i<arr.length; i++){
            result *= arr[i];
        }
    }
}

示例代码3：

//示例代码3：
public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,9};
        //统计偶数个数
        int even = 0;
        for(int i=0; i<arr.length; i++){
            if(arr[i]%2==0){
                even++;
            }
        }
    }
}

查找指定元素

查找某个指定元素在数组中的首次出现的位置（索引）
常见查找算法有顺序查找，二分查找（折半查找，前提要求数组中元素是按照大小顺序排序的）

示例代码:

//示例代码：
public class Demo5Element {
    //查找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);
        }
    }
}

查找最大/小值及其位置

查找出数组中元素的最大值或最小值

算法思路：
（1）先假设第一个元素为最大/最小，用max/min变量表示最大/小值，
（2）然后用max/min与后面的每个元素一一比较

示例代码:

//示例代码2：
public class Demo5Element {
    public static void main(String[] args) {
        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];
            }
        }
    }
}

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

算法思路：
（1）先假设第一个元素最大/最小，用变量index表示其位置，
（2）然后用index位置的元素与后面的元素一一比较
(3) 用变量index时刻记录目前比对的最大/小的下标

示例代码:

//示例代码2：
public class Demo5Element {
    public static void main(String[] args) {
        //求最大值及其位置
        int[] arr = {4, 5, 6, 1, 9};
        int maxIndex=0;//假定索引0位置的元素最大
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>arr[maxIndex]){
                maxIndex=i;
            }
        }
        System.out.println("最大值：" + arr[maxIndex]);
    }
}

查找最大值及其所有下标位置(最大值重复)

算法思路：
（1）先找到最大值
（2）遍历数组，看哪些元素和最大值是一样的

示例代码:

//示例代码2：
public class Demo5Element {
    public static void main(String[] args) {
        int[] arr = {4,9,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");
            }
        }
    }
}

排序之冒泡排序

Java中的经典算法之冒泡排序(Bubble Sort)
把数组中元素按照从小到大（升序）或者从大到小（降序）顺序进行重新排列
冒泡排序原理:
- 比较两个相邻的元素，将值大的元素交换至右端，最大值出现在最后位置。
算法思路:
- 依次比较相邻的两个数，将小数放到前面，大数放到后面。
- 即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。
- 然后比较第2个和第3个元素，将小数放到前面，大数放到后面。
- 如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。
- 重复第一趟步骤，直至全部排序完成。

算法思路--伪代码

例如：冒泡：从小到大，从左到右两两比较
/*
{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轮
	每一轮比较很多次
*/

示例代码

//示例代码2：
public class Demo5DelElement {
    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] + " ");
        }
    }