java基础07-15



算法运用：

    计算1-100之间的所有的奇数和

          1+3+5+7...+99

public class LoopTest{

    public static void main(String[] args){

        // 定义变量,保存求和

        int sum = 0;

        // for循环,循环中的变量, 0-100

        for(int i = 0 ; i <= 100 ; i++){

            //对循环的变量,进行奇数的判断, %2==1

            if(i % 2 == 1){

                //对奇数求和

                sum  += i;

            }

        }

        System.out.println(sum);

 

    }

}

要求: 计算出水仙花数

     三位数100-999  个位数的立方+十位数的立方+百位数的立方 = 自己本身

          153 = 1*1*1 + 5*5*5 + 3*3*3

          已知三位数  123  获取出每个数位 利用 除法,取模运算

实现步骤:

     1. 定义变量才存储 三个数位上的整数

     2. 利用循环,循环中的变量,从100变化到999

     3. 循环中得到三位数,利用算法,拆解成三个单独数位

     4. 将三个数位立方的求和计算, 计算后的求和,和他自己进行比较判断

        想同,就是水仙花

*/

public class LoopTest_1{

    public static void main(String[] args){

        //定义三个变量

        int bai = 0;

        int shi = 0;

        int ge = 0 ;

       

        //循环,循环变量从100-999

        for(int i = 100 ; i < 1000 ; i++){

            //对i,进行计算,获取出三个数位

            //获取百位

            bai = i / 100;

            //获取十位

            shi = i / 10 % 10;

            //获取个位

            ge = i % 10;

            //对三个数位进行立方求和

            if(bai * bai * bai + shi * shi *shi + ge * ge *ge == i){

                System.out.println(i);

            }

        }

    }

}

 

 

/*

   数组的查找功能

     在一个数组中,找一个元素,是否存在于数组中,如果存在,就返回索引

     

     普通查询:

       找到元素在数组中出现的索引,如果没有这个 元素,结果就是负数

       

*/

public class ArrayMethodTest_3{

     public static void main(String[] args){

         int[] arr = {1,3,5,7,9,11,15};

         int index = binarySearch(arr,10);

         System.out.println(index);

         

     }

     

     /*

         定义方法,实现,折半查找

         返回值: 索引

         参数: 数组,被找的元素

         实现步骤:

          1. 需要的变量定义

             三个,三个指针

             

          2. 进行循环折半

             可以折半的条件  min <= max

          

          3. 让被找元素,和中间索引元素进行比较

              元素 > 中间索引  小指针= 中间+1

              元素 < 中间索引  大指针= 中间-1

              元素 == 中间索引  找到了,结束了,返回中间索引

              

           4. 循环结束,无法折半

             元素没有找到 ,返回-1

     */

     public static int binarySearch(int[] arr, int key){

         //定义三个指针变量

         int min = 0 ;

         int max = arr.length -1 ;

         int mid = 0;

         //循环折半,条件 min<=max

         while( min <= max){

             //公式,计算中间索引

             mid = (min+max)/2;

             //让被找元素,和中间索引元素进行比较

             if(key > arr[mid]){

                 min = mid + 1;

             }else if (key < arr[mid]){

                 max = mid - 1;

             }else{

                 //找到元素,返回元素索引

                 return mid;

             }

         }

         return -1;

     }

     

    /*

       定义方法,实现数组的普通查询

       返回值: 索引

       参数:  数组, 被找的元素

      

       实现步骤:

        1. 遍历数组

         2. 遍历过程中,使用元素和数组中的元素进行比较

           如果相同,返回元素在数组中的索引

            如果不同,返回负数

    */

    public static int search(int[] arr, int key){

        //遍历数组

        for(int i = 0 ; i < arr.length ; i++){

            //数组元素,被查找的元素比较

            if(arr[i] == key){

                //返回索引

                return i;

            }

        }

        return -1;

    }

}

 

 

/*

  数组的排序: 一般都是升序排列,元素,小到大的排列

 

  两种排序的方式

     选择排序: 数组的每个元素都进行比较

     冒泡排序: 数组中相邻元素进行比较

     规则: 比较大小,位置交换

*/

public class ArrayMethodTest_2{

    public static void main(String[] args){

        int[] arr  = {3,1,4,2,56,7,0};

        //调用选择排序方法

        //selectSort(arr);

       

        //调用冒泡排序方法

        bubbleSort(arr);

        printArray(arr);

    }

    /*

       定义方法,实现数组的冒泡排序

       返回值: 没有

        参数:  数组

    */

    public static void bubbleSort(int[] arr){

        for(int i = 0 ; i < arr.length - 1; i++){

            //每次内循环的比较,从0索引开始, 每次都在递减

            for(int j = 0 ; j < arr.length-i-1; j++){

                //比较的索引,是j和j+1

                if(arr[j] > arr[j+1]){

                   int temp = arr[j];

                   arr[j] = arr[j+1];

                   arr[j+1] = temp;

                }

            }

        }

    }

   

    /*

        定义方法,实现数组的选择排序

        返回值: 没有

        参数:  数组

        实现步骤:

         1.嵌套循环实现排序

           外循环,控制的是一共比较了多少次

            内循环,控制的是每次比较了多少个元素

         2. 判断元素的大小值

           小值,存储到小的索引

    */

    public static void selectSort(int[] arr){

        for(int i = 0 ; i < arr.length - 1; i++){

            //内循环,是每次都在减少,修改变量的定义

            for(int j = i+1 ; j < arr.length ; j++){

                //数组的元素进行判断

                if(arr[i] > arr[j]){

                   //数组的换位

                   int temp = arr[i];

                   arr[i] = arr[j];

                   arr[j] = temp;

                }

            }

        }

    }

   

    /*

       定义方法,实现功能

       返回值: void

       方法参数: 数组

    */

    public static void printArray(int[] arr){

        //输出一半中括号,不要换行打印

        System.out.print("[");

        //数组进行遍历

        for(int i = 0 ; i < arr.length ; i++){

            //判断遍历到的元素,是不是数组的最后一个元素

            //如何判断 循环变量 到达 length-1

            if( i == arr.length-1 ){

                //输出数组的元素和]

                System.out.print(arr[i]+"]");

            }else{

            //不是数组的最后一个元素,输出数组元素和逗号

               System.out.print(arr[i]+",");

            }

        }

        System.out.println();

    }

}

 

 

/*

    利用嵌套for循环,实现99乘法表示

    实现步骤:

      1. 定义外循环控制行数

      2. 内循环控制个数,个数,每次都在递增

      3. 循环中输出,乘法表的格式  1*3=3

*/

public class LoopTest_3{

    public static void main(String[] args){

        print99(9);

    }

   

    public static void print99(int n){

        //定义外循环,循环9次

        for(int i = 1; i <= n; i++){

            //定义内循环,每次递增,循环条件, <=i

            for(int j = 1; j <= i ;j++){

                //按照标准格式,输出打印

                System.out.print(j+"*"+i+"="+i*j+"\t");

            }

            System.out.println();

        }

    }

}