java基础语法（三）---数组

java基础语法（三）—数组

---

一、数组

• 概念：同一种类型数据的集合。（数组是一种容器）

• 数组的特点：

  1. 数组元素依次存放，使用连续的内存。
  2. 数组长度一旦确定就不能够改变。

• 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

• 格式：
  格式1：
  元素类型[] 数组名=new 元素类型[数组长度]；
  格式2：
  元素类型[] 数组名=new 元素类型[]{元素，元素，……}；
  格式3：
  元素类型[] 数组名={元素，元素，……}；

---

二、练习

2.1 选择排序

• 用选择排序的方法将数组从小到大排序。
• 思路：
  
  1. 将数组中的第一个元素依次与数组中的其他元素比较，如果第一个元素大于某元素，则与该元素互换位置。 第一轮结束后，数组中第一个元素就是该数组中最小的元素。
  2. 将数组中的第二个元素依次与（除第一个元素和自身外）其他元素比较，如果有元素比第二个元素小，就与第二个元素互换位置。第二轮结束后，第二元素就是数组中倒数第二小的元素。
  3. 依次类推，直到倒数第二个元素。
• 代码：

class ArrayDemo4 
{
    public static void main(String[] args) 
    {
        //定义一个int类型的数组
        int[] arr ={3,6,23,12,34,4};
        printArr(arr);
        System.out.println("----------------------");
        selectSort(arr);
        //将排序后的元素打印出来。
        printArr(arr);
    }
    public static void selectSort(int[] arr)
    {
        //外循环，从数组的第一个元素开始到数组的倒数第二个元素
        for(int x=0;x<arr.length-1;x++)
        {
            int num=arr[x];
            int index=x;
            for(int y=x+1;y<arr.length;y++)
            {   
                //数组元素依次与它后面的元素相比较
                if(arr[x]>arr[y])
                swap(arr,x,y);
            }
        }
    }
    //定义一个方法，使得数组中两个元素互换位置
    public static void swap(int[] arr,int x,int y)
    {
        int temp=arr[y];
        arr[y]=arr[x];
        arr[x]=temp;
    }
    //定义一个方法依次将数组中的元素打印出来。
    public static void printArr(int[] arr)
    {
        for(int x=0;x<arr.length;x++)
            System.out.println("arr["+x+"]="+arr[x]);
    }
}

• 输出结果：

2.2 冒泡排序

• 需求：用冒泡排序的方法对数组进行排序。
• 思路：
  
  1. 在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。经过第一轮比较，最大的元素就已经存储到数组最右边的角标中了。
  2. 然后第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
  3. 最后依照此方式，一直到只有第一和第二个元素互相比较而结束。
• 代码：

class ArrayDemo5 
{
    public static void main(String[] args) 
    {
        //定义一个int类型的数组
        int[] arr ={3,6,23,12,34,4};
        printArr(arr);
        System.out.println("----------------------");
        bubbleSort(arr);
        //将排序后的数组打印出来
        printArr(arr);
    }
    public static void bubbleSort(int[] arr)
    {
        for(int x=0;x<arr.length-1;x++)
        {
            for(int y=0;y<arr.length-1-x;y++)
            {
                //元素与其右边的元素进行比较
                if(arr[y]>arr[y+1])
                    swap(arr,y,y+1);
            }               
        }
    }
    //定义一个方法，使得数组中两个元素互换位置
    public static void swap(int[] arr,int x,int y)
    {
        int temp=arr[y];
        arr[y]=arr[x];
        arr[x]=temp;
    }
    //定义一个方法依次将数组中的元素打印出来。
    public static void printArr(int[] arr)
    {
        for(int x=0;x<arr.length;x++)
            System.out.println("arr["+x+"]="+arr[x]);
    }
}

• 输出的结果：
  

2.3 折半查找

• 需求：用折半查找法查询数组中的元素。

• 思路：

  1. 对数组进行排序。
  2. 定义三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
  3. 查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
  4. 如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max=mid-1，mid=(max+min)/2，然后转到第3步操作。
  5. 如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min=mid+1，mid=(max+min)/2，然后转到第3步操作。
  6. 如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值（此处为while循环的结束条件），此时返回-1。

• 代码：

import java.util.Arrays;
class ArrayDemo7 
{
    public static void main(String[] args) 
    {
        int[] arr ={3,6,23,-12,34,4};
        //对数组进行排序
        Arrays.sort(arr);
        //调用binarySearch方法查找元素的角标
        int index=binarySearch(arr,6);
        System.out.println(index);
    }
    public static int binarySearch(int arr[],int key)
    {
        int min=0;
        //将max初始化为最大角标
        int max=arr.length-1;
        int mid=(min+max)/2;
        while(arr[mid]!=key)
        {
            if(key>arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            //数组中没有该元素，返回-1.
            if (max<min)
                return -1;
            mid=(min+max)/2;
        }
        return mid;
    }
}

• 输出结果：