JAVA第三章

永无魇足

已于 2023-03-22 10:57:55 修改

阅读量76

点赞数 3

文章标签： java Powered by 金山文档

于 2023-03-16 15:04:08 首次发布

本文链接：https://blog.csdn.net/ylxb2234/article/details/129585300

版权

本文介绍了数组的创建，包括一维数组的两种创建方式及直接赋值的方法。接着详细讲解了数组的遍历，提供了两种for循环的方式。文章还探讨了两种排序算法——冒泡排序和选择排序，包括它们的基本原理和示例代码。此外，还讨论了提高查找效率的折半查找算法。最后，文章提到了杨辉三角的特点及其生成方法。

摘要由CSDN通过智能技术生成

1.数组：

一组数据，相同数据类型的集合。

1.1创建一维数组：

两种方法：（以创建一个整型数组为例）

法一：

int []a = new int [5] ;

法二：

int a[] = new int[5];

创建数组时，给定数据类型。创建数组时要添加容量，容量一旦确定就不可改变。或者直接赋值。

直接赋值写法：

写法1：

 int []a = new int[]{1,2,3,4,5};

写法2：

int []a = {1,2,3,4,5};

Arrays.ToString(a) 把数组a以字符串形式输出。

例：

System.out,println(Arrays.ToString(floats)); /*数组a以浮点形式输出。*/

chars 字符形式，默认全空格

floats 浮点形式，默认全0.0

booleans 布尔形式，默认全false

strings 字符串形式，默认全null

不难发现，数组a 的取值都在原本的数据类型后面加了一个s

数组下标(索引)从0开始，最大到长度减1。

数组存储必须是连续的。

1.2数组遍历两种for循环：

普通for循环

for(类型变量：数组)隐藏遍历的细节，每次从数组中取出一个元素赋给变量

如果要用到索引，就用第一种。

2.排序

2.1冒泡排序：

每次取出相邻两元素，大的往后小的往前。

例：{5，4，3，2，1}冒泡排序

    public static void main(String[] args) {
        int[] a = new int[5];
        a[0] = 5;
        a[1] = 4;
        a[2] = 3;
        a[3] = 2;
        a[4] = 1;
        for (int i = 0; i < a.length-1; i++){  //循环次数
            for (int j = 0; j < a.length-1; j++){  //取值比较
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;//交换
                }
            }
        }
        for(int k=0;k<5;k++) {
            System.out.println(a[k]);
        }
    }

2.2选择排序：

第一个元素开始，与后面每一个元素比较，小的和当前元素交换。

2.2.1普通选择排序：

例：{3，4，5，1，2}选择排序

    public static void main(String[] args) {
        int[] a = new int[5];
        a[0] = 3;
        a[1] = 4;
        a[2] = 5;
        a[3] = 1;
        a[4] = 2;
        for (int i = 0; i < a.length-1; i++)  //循环次数
        {
            for (int j = i+1; j < a.length; j++)  //取值比较
            {
                if (a[i] > a[j]) {
                    int temp = a[j];
                    a[j]=a[i];
                    a[i]=temp;//交换
                }
            }
        }
        for(int k=0;k<a.length;k++) {
            System.out.println(a[k]);
        }
    }

2.2.2：选择排序优化

两者区别在于优化后每趟循环只需交换一次元素，但普通选择排序每趟需要多次。

   public static void main(String[] args) {
        int[] a = new int[5];
        a[0] = 3;
        a[1] = 4;
        a[2] = 5;
        a[3] = 1;
        a[4] = 2;
        for (int i = 0; i < a.length-1; i++)  //循环次数
        {
            int min = i;//min用来确定最小值的下标
            for (int j = i+1; j < a.length; j++)  //取值比较
            {
                if (a[min] > a[j]) {
                  min = j;
                }
            }
            int temp=a[min];
            a[min]=a[i];
            a[i]=temp;//交换
        }
        for(int k=0;k<5;k++) {
            System.out.println(a[k]);
        }
    }

3.折半查找

普通查找效率太低，为了提高效率有了折半查找，又叫二分查找。数组必须是有序数组。

步骤:

1.找到高位，低位和中间位置。

2.将要查找的数与中间位置的数比较

3.比查找的数大，高位移动到中位前一位；比查找数小，低位移动到中位后一位。

4.确定新的中间位置继续重复2，3步的操作，直到低位比高位大。

例：有一个数组 int[] array = {7,3,6,5,4,5,2,1,9}; 使用折半查找法判断数组是否包含2.

public class age {
    public static void main(String[] args){
        int[]array={7,3,6,5,4,5,2,1,9};
        for(int i=0;i<array.length-1;i++){
            int min=i;
            for(int j=i+1;j<array.length;j++){
                if(array[min]>array[j]){
                    min=j;
                }
            }
            int temp=array[min];
            array[min]=array[i];
            array[i]=temp;
        }//选择优化排序
        int key=2;//需要查找的值
        int high=array.length-1;
        int low=0;
        while(low<=high) {
            int mid = (high + low / 2);//确定中间位置
            if(mid>key){
                high=mid-1;//大于在左半部分
            }
            else if(mid<key){
                low=mid+1;//小于在右半部分
            }
            else{
                System.out.println(mid);//找到就输出位置
                break;
            }
        }//折半查找
    }
}

问题以及小细节总结：

写数组循环时长度的写法

最开始我在写数组循环的长度时总是会数数组的长度，然后循环直接写数字，这种写法虽然运行没问题，但实际这个写法是错误的。

正确写法应该是数组名.length，而不是通过人去计算出长度，再去给计算机，如果数组很长那既花时间还容易出错。而计算机可以用数组名.length计算出长度，并不需要去做多余的操作。

2.找出数组最大值

错误原因：有两处错误，首先是从题来看，代码写的是错误的，最后应该输出的是max的值，而并非a[i]的值；

其次是运行错误，是因为输出的a[i]超出了数组长度，最开始不理解为什么会超出长度，后来发现原因在for循环里面，因为数组下标最大只能到长度减1的位置，当下标的值和长度相等时会跳出循环，此时i已经是长度的值也就是5，所以输出就会提示超出边界。

解决方案：将输出的a[i]改成max即可。

正确结果：

3.杨辉三角

特点：每一行数字是由上一行相对位置的前一个数和后一个数相加得到。

可以想象哈夫曼树每个数的父母。杨辉三角的数就相当于由其父母相加得到的。

import java.util.Scanner;
public class demo {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        System.out.println("输入行数");
         int row=s.nextInt();
         int [][]a=new int[row][row*2+1];
         a[0][row]=1;
         for(int i=1;i<a.length;i++){ //因为下标0即第一行只有一个数需要赋值，前面已经赋值过，则i从1开始
             for(int j=1;j<a[i].length-1;j++){ //因为每一行第一个数和最后一个数没有对应的父母，所以下标从1到长度减2。
                 a[i][j]=a[i-1][j-1]+a[i-1][j+1];
             }
         }
         for(int i=0;i<a.length;i++){ //遍历输出
             for(int j=0;j<a[i].length;j++){
                 if(a[i][j]!=0){
                     System.out.print(a[i][j]+"\t");
                 }
                 else{
                     System.out.print(" \t");
                 }
             }
             System.out.println();    //用于换行
         }
     }
}

这里要注意： 1.输出的print和println ,两者区别在于println输出完后会换行，而print的光标仍在结束处停着。

2. a.length和a[i].length: 二维数组，a.length是直接输出二维数组的长度，a[i].length是输出二维数组里对应下标为i的一维数组的长度。

3. \t是补全当前字符串长度到8的整数倍