java (三)【数组】遍历、排序、折半查找

数组

数组的定义：同一种类型数据的集合，其实数组就是一个容器。

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

格式一：

元素类型[]数组名 = new 元素类型[元素个数或数组长度]

int [] arr=new int [5];

格式二：

元素类型[]数组名=new 元素类型[]{元素，元素...}；

int [] arr =new int [] {3,5,1,7};

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

//用于打印数组中的元素，元素间用逗号隔开
public class hello {

    public static void main(String[] args) {
    int [] arr= {1,2,3,4,54};
    qwe(arr);
    }
    public static void qwe(int [] arr)
    {
        for (int i =0;i<arr.length;i++) //数组中有一个可以直接获取数组元素个数，length，使用方法：数组名.length=
        {
            if(i!=arr.length-1)
                System.out.print(arr[i]+",");
            else
                System.out.println(arr[i]);
        }
    }
    }

---

 

内存结构

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存

1. 数组和对象，通过new建立的实例都存放在堆内存中
2. 每一个实体都有内存地址值
3. 实体中的变量都有默认初始化值
4. 实体不在被使用，会在不确定的时间内被垃圾回收器回收

---

 选择排序

  //获取数组元素中的最大值
  public class hello {
  
      public static void main(String[] args) {
     int [] arr= {1,2,3,4,54};
      int x =qwe(arr);
      System.out.println(x);
      }
     public static int qwe(int [] arr)
     {
         int max =arr[0];
         for(int i=1; i<arr.length;i++)
        {
             if (arr[i]>max)
             max=arr[i];
     }
        return max;
    }
     }

冒泡排序

定义：相邻的两个元素进行比较，如果符合条件换位

 

public class asd {

    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 54 };
        System.out.print("排序前");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
        qwe(arr);
        System.out.println();
        System.out.print("排序后");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }

    public static void qwe(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - x - 1; y++) {
                if (arr[y] < arr[y + 1]) {
                    int temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
        }
    }
}

 折半查找

定义：必须要保证该数组是有序的数组

public class asd {
    public static void main(String[] args) {
//        int  [] arr ={3,4,5,6,2,3,4};
//        int index=qwe(arr,4);
//        System.out.println("index="+index);
        int []arr ={1,3,4,5,7,8,12,33,455,666,777};
        int index=zxc_1(arr,3);
        System.out.println("index="+index);
    }
    //折半查找第一种方法
    public static int zxc(int []arr,int key)
    {
        int min,max,mid;
        min=0;
        max=arr.length-1;
        mid=(min+max)/2;
        while (arr[mid]!=key)
        {
            if(key >arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            if(min>max)
                return -1;
            mid =(max+min)/2;
        }
        return mid;
    }
    //折半查找第二种方法
    public static int zxc_1(int[] arr,int key)
    {
        int min,max,mid;
        min=0;
        max=arr.length-1;
        while (min<=max)
        {
            mid =(max+min)/2;
            if(key>arr[mid])
                min=mid +1;
            else if (key<arr[mid])
                max=mid-1;
            else 
                return mid;
        }
        return -1;
    }
    //定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在
    public static int qwe(int []arr,int key)
    {
        for (int x=0;x<arr.length;x++)
        {
            if(arr[x]==key)
                return x;
        }
        return -1;
    }
}

 

 练习：有一个有序数组，想要将一个元素插入到该数组中

public class asd {
    public static void main(String[] args) {
        int []arr ={1,3,4,5,7,8,12,33,455,666,777};
        int index=zxc_1(arr,3);
        System.out.println("index="+index);
    }
    public static int zxc_1(int[] arr,int key)
    {
        int min,max,mid;
        min=0;
        max=arr.length-1;
        while (min<=max)
        {
            mid =(max+min)/2;
            if(key>arr[mid])
                min=mid +1;
            else if (key<arr[mid])
                max=mid-1;
            else 
                return mid;
        }
        return min;
    }
    
}