Practice| 数组

/*
从键盘确定班级的组号，在从键盘输入每一组的人数，并输入每一个学员的成绩，并求出，每一组的平均分，
全部的平均分，每一组的最高分，全部的最高分，并显示结果.
 
*/
class Test3{
    public static void main(String[] args){
 
        java.util.Scanner input = new java.util.Scanner(System.in);
 
        //先确定一共有多少个组；
        System.out.print("请输入一共有多少个组:");
        int groups = input.nextInt();
 
        int[][] scores = new int[groups][]; //如5个组，+ 人数
 
        //遍历输入每个组的人数
 
        for(int i = 0;i < scores.length;i++){
 
            System.out.print("请输入第" + (i+1) +"组的人数:");
            int num = input.nextInt();
            scores[i] = new int[num];  //确定每 i 行的列数 <==> 相当于一维数组;
 
        }
 
        //遍历scores二维数组,输入成绩即填充列数，默认值为0 ；
        for(int i = 0; i < scores.length;i++){
            for(int j = 0;j < scores[i].length;j++){
                System.out.print("请输入第"+ (i+1) +"组" + "第"+ (j+1) + "个学员的成绩:");
                int score = input.nextInt();
                scores[i][j] = score;
            }
            System.out.println();
        }
        //每个组和班级的平均分
        int sumAll = 0;
        int countAll = 0;
        for(int i = 0; i < scores.length;i++){
            int sumGroup = 0; //每循环一次就会赋0 -->可求出每组的成绩
            int countGroup = 0;
            for(int j = 0;j < scores[i].length;j++){
                sumAll += scores[i][j];
                countAll++;
 
                sumGroup += scores[i][j];
                countGroup++;
            }
            System.out.println("第" + (i+1) + "组的总分为:" + sumGroup + "\t" + "第" + (i+1) + "组的平均分为:" + sumGroup/countGroup);
        }
        System.out.println("全班总分为:" + sumAll + "\t" + "全班平均分为:" + sumAll/countAll);
 
        //求每个组和班级的最高分
        int max_ban = 0;
        for(int i = 0;i < scores.length;i++){
            int max_zu = 0;
                //int max_ban = 0;
            for(int j = 0;j < scores[i].length;j++){
 
                if(scores[i][j] > max_zu){
                    max_zu = scores[i][j];
                }
                if(scores[i][j] > max_ban){
                    max_ban = scores[i][j];
                }
 
            }System.out.println("第" + (i+1) + "组的最高分为:" + max_zu);
 
        }System.out.println("全班最高分为:" + max_ban);
 
    }
}

数组的复制

/*
（1）已知一个数组存储了成绩
int[] scores = {67,89,23,45,99};
要让你把，所有不及格的成绩找出来，放到一个数组中
结果：{23,45}
 
(1)先统计不及格的有几个人，count个
(2)新建数组  int[] low = new int[count];
(3)再遍历scores，把不及格的复制到low数组中
*/
 
class ArrayCopy{
    public static void main(String[] args){
        int[] scores = {67,89,23,45,99};
        int count = 0;
        for(int i = 0;i < scores.length; i++){
            if(scores[i] < 60){
                count++;
            }
        }
        int[] low = new int[count];
 
        for(int i = 0,j = 0; i < scores.length && j<count; i++){ //&& j<count不写也可以不会超范围;
            if(scores[i] < 60){
                //j = i;//i=2, 3
                low[j] = scores[i];    //这里是关键啊啊
                j++;
            }
        }
 
        //for(int i = 0;i<low.length;i++){
            //System.out.println(low[i]);
        //}
        for(int num : low){
            System.out.print("不及格的有:" + num + "\n");
        }
    }
}

二分查找（前提是有顺序的）

使用二分查找算法查找字符串数组中  {"a","b","c","d","e","f","g","h"} g的元素。

* String类型：
 * （1）重写了equals方法
 * （2）实现了java.lang.Comparable接口
 *         这个接口的抽象方法  int compareTo(String str)
 */
public class Test19 {
    public static void main(String[] args) {
        String[] arr = {"a","b","c","d","e","f","g","h"};
        String find = "g";
 
        int left = 0;
        int right = arr.length-1;
        int mid = (left + right)/2;
        int index = -1;
 
        while(left<=right){
            if(arr[mid].equals(find)){
                index = mid;
                break;
            }else if(find.compareTo(arr[mid])>0){//find比arr[mid]大，去mid的右边查找
                left = mid +1;
            }else{
                right = mid - 1;
            }
            mid = (left + right)/2;
        }
        System.out.println("g的下标是：" +index);
    }
}

//二分法
class BinarySearch{
    public static void main(String [] args){
        int[] arr = {0,1,2,5,8,9,12,17,20};
        //int[] arr = {1,2,5,8,9,12,17,20};
        int index = -1;
        int find = 5;
        int left = 0;
        int right = arr.length - 1;
        int mid = (left + right) /2;
 
        while(left <= right){  //left left   left  left
            if(arr[mid] == find){//找到了
                index = mid;
                break;
            }else if(find < arr[mid]){//说明find在[mid]的左边
                right = mid-1;
            }else{//说明find在[mid]的右边
                left = mid + 1;
            }
            mid = (left + right)/2;
        }
        if(index==-1){
            System.out.println("未找到");
        }else{
            System.out.println("下标：" + index);
        }
    }
}

冒泡排序（把大的往右边移动-下沉；把小的往左移动-冒泡）

/*
冒泡排序:
从小到大
 
//1、先照我这个写
//2、如果我要求，每一轮从最后一个元素开始比较
//我刚才，相当于把“大”往“右”移动
//现在，把“小”往“左”移动
/*
冒泡排序：实现从小到大
（1）方法一：把“大”往“右”移动，称为“下沉”
（2）方法二：把“小”往“左”移动，称为“冒泡”
 
*/
 
class BubbleSort{
    public static void main(String[] args){
        int[] arr = {3,9,4,2,1,8,6}; //6
 
        //从小到大:通过相邻元素的比较, 大的往后移动称为 下沉；
 
        for(int i = 1;i < arr.length-1;i++ ){
            for(int j = 0;j < arr.length-1;j++){
                if(arr[j] > arr[j+1]){
                    int temp = 0;
                    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] + "\t");
        }
 
    }
}
 
---->>>
1       2       3       4       6       8       9

class BubbleSort{
    public static void main(String[] args){
        int[] arr = {3,9,4,2,1,8,6}; //6
 
        //从小到大:把 小 的往 左 移动;称为"冒泡"。
        for(int i = 0; i < arr.length;i++){
            for(int j = arr.length-1; j > i;j--){
                if(arr[j] < arr[j-1]){  //如果后边的arr[j] < 前边的arr[j-1]
                    int temp = 0;
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
        }for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}
 
---->>>
1       2       3       4       6       8       9

package com.atguigu.exam;
 
import java.util.Arrays;
 
public class Test20 {
    public static void main(String[] args) {
        int[] array = {4,3,6,1};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
 
    public static void sort(int[] arr){
        //轮数：n-1
        for (int i = 1; i < arr.length; i++) {
            //每一轮从左往右比较
            /*
             * 当i=1,j=0,1,2,...arr.length-2   j<arr.length-i
             */
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

直接选择排序

/*
 
直接选择排序-->>
思路：
    每一轮找出本轮未排序元素中的最小值，然后和它应该在的位置的元素交换
 
例如：
第一轮：最小值是1，它的位置[4]，它应该在[0]，[4]和[0]位置元素交换  {1,2,7,9,4,6}
第二轮：最小值是2，它的位置[1]，它应该在[1]，不动                   {1,2,7,9,4,6}
第三轮：最小值是4，它的位置[4]，它应该在[2]，[4]和[2]位置元素交换  {1,2,4,9,7,6}
第四轮：最小值是6，它的位置[5]，它应该在[3]，[5]和[3]位置元素交换  {1,2,4,6,7,9}
第五轮：最小值是7，它的位置[4]，它应该在[4]，不动
*/
 
class TestSelectSort{
    public static void main(String[] args){
        int[] arr = {4,2,7,9,1,6};
        //外循环：5轮
        //i的循环值：0,1,2,3,4  i<arr.length-1
        for(int i = 0; i <arr.length-1;i++){
            //找出本轮的最小值及其下标
            //(1)先假设“本轮未排序部分”的第一个元素最小
            int min = arr[i];
            int index = i;
 
            //(2)用min 和 "剩余的元素" 进行比较,确定本轮的最小值; 从i+1开始比较，到最后；
            /*
            第一轮：未排序部分 [0,5]，min=arr[0]，index=0，j=1,2,3,4,5
            第二轮：未排序部分 [1,5]，min=arr[1]，index=1，j=2,3,4,5
            第三轮：未排序部分 [2,5]，min=arr[2]，index=2，j=3,4,5
            第四轮：未排序部分 [3,5]，min=arr[3]，index=3，j=4,5
            第五轮：未排序部分 [4,5]，min=arr[4]，index=4，j=5
            */
 
            for(int j = i+1; j < arr.length; j++){
                if(min > arr[j]){
                    min = arr[j];
                    index = j;
                }
            }
 
            //(3)把[index]位置的元素和它应该在的位置交换
            /*
            第一轮，最小值应该在[0]，第一轮i=0
            第二轮，最小值应该在[1]，第一轮i=1
            第三轮，最小值应该在[2]，第一轮i=2
            第四轮，最小值应该在[3]，第一轮i=3
            第五轮，最小值应该在[4]，第一轮i=4
            */
            if(index != i){ //如果arr[index]，即本轮的最小值，不在它应该在的位置[i]，就要交换
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }
        }
        for(int num : arr){
            System.out.print(num); //
        }
 
    }
}