黑马程序员--数组的应用

最新推荐文章于 2024-10-11 13:19:10 发布

ErYouList

最新推荐文章于 2024-10-11 13:19:10 发布

阅读量365

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/ErYouList/article/details/49256799

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、获取指定值

1、通过遍历的方法获取最大值

class ArrayDemo{
       public static void main(String[] args) {
             int[] arr= {5,1,-2,17,3,100};
             int max = getMax(arr);
             System.out.println("max = " + max);
       }
       public static int getMax(int[] arr){
             int maxElement = arr[0];
             for(int x:arr)
             {
//当遍历到的元素比maxElement大时赋值给maxElement
                   if(x > maxElement)
                        maxElement = x;
            }
            return maxElement;
      }
}

二、排序

1、冒泡排序

思路：

!、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
!!、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数第二小的元素。
!!!、依次类推，直到最后一个元素。

class ArrayDemo2{
           public static void main(String[]args) {
                int[] arr={5,1,-2,17,3,100};
                System.out.print("排序前数组：" );
                printArray(arr);
                selectSort(arr);
                System.out.print("排序后数组：" );
                printArray(arr);
          }
   
           public static void selectSort(int[] arr){
                 for(int x = 0; x < arr.length - 1; x++){
                       for(int y = x + 1; y <arr.length; y++)
                       {
                         //比较两个元素大小,如果被比较的元素小,则交换位置
                             if(arr[x] >arr[y])
                             {
                                 int temp = arr[x];
                                 arr[x] = arr[y];
                                 arr[y] = temp;
                            }
                      }
                }
          }
           public static void printArray(int[] arr){
                System.out.print("[" );
                for(int x = 0; x < arr.length; x++){
                       if(x != arr.length - 1)
                           System.out.print(arr[x] + "," );
                       else
                           System.out.println(arr[x] + "]" );
                }
          }
    }

2、 Arrays类中已经定义了sort方法进行自然升序排序，需要排序时直接使用就行了。

代码：

import java.util.Arrays;
 
    class ArrayDemo3{
           public static void main(String[]args) {
                 int[] arr={89,34,-270,17,3,100};
                 System.out.print("排序前数组：" );
                 printArray(arr);
                 Arrays.sort(arr);
                 System.out.print("排序后数组：" );
                 printArray(arr);
          }
         
           public static void printArray(int[] arr){
                System.out.print("[" );
                 for(int x = 0; x < arr.length; x++){
                       if(x != arr.length - 1)
                           System.out.print(arr[x] + "," );
                       else
                           System.out.println(arr[x] + "]" );
                }
          }
}

三、二分查找

1、如果一个数组是无序的，那么可以通过简单遍历查找的方式查找到某个元素所在的角标。但是如果一个数组是有序的，那么就可以通过一种更高效的方式达到相同的目的，也就是二分查找。

需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。

思路：

!、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标，作为最大值，再定义一个变量，存储最小值与最大值的一半，也就是中间位置，然后将已知元素与中间值位元素进行比较。

!!、如果比中间值元素大，则将最小值变为中间值加1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复

!!!、如果比中间值元素小，则将最大值变为中间值减1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复

代码：

package com.itheima;
class  ArrayDemo4
{ 
    public static void main(String[] args)  
    { 
        int[] arr={2,6,9,11,15,19,22,30}; 
        //打印数组 
        printArray(arr); 
        int key=20; 
        //用第一种折半方式输出插入的角标值 
        System.out.println("当key=20在数组arr中插入的角标位置是："+arrayDemo1(arr,key)); 
        key=1; 
        //用第二种折半方式输出插入的角标值 
        System.out.println("当key=1在数组arr中插入的角标位置是："+arrayDemo2(arr,key)); 
    } 
 
    //折半查找<一> 
    public static int arrayDemo1(int[] arr,int key) 
    { 
        int min=0,max=arr.length-1,mid=(max+min)/2; 
        while(key!=arr[mid]) 
        { 
            if(min>max) 
                return min; 
            else if(key>arr[mid]) 
                min=mid+1; 
            else  
                max=mid-1; 
            mid=(max+min)>>>1;//折半操作            
        } 
        return mid;  
    } 
 
    //折半查找<二> 
    public static int arrayDemo2(int[] arr,int key) 
    { 
        int min=0,max=arr.length-1,mid; 
 
        while(min<max) 
        { 
            mid=(max+min)>>>1;//折半操作 
            if(key>arr[mid]) 
                min=mid+1; 
            else if(key<arr[mid]) 
                max=mid-1; 
            else 
                return mid; 
        } 
        return min;  
    } 
 
    //遍历数组 
    public static void printArray(int[] arr) 
    { 
        System.out.print("["); 
        for (int x=0;x<arr.length;x++) 
        { 
            if(x!=arr.length-1) 
                System.out.print(arr[x]+","); 
            else 
                System.out.print(arr[x]+"]"); 
        } 
        //换行 
        System.out.println();
    }
}package com.itheima;
class  ArrayDemo4
{ 
    public static void main(String[] args)  
    { 
        int[] arr={2,6,9,11,15,19,22,30}; 
        //打印数组 
        printArray(arr); 
        int key=20; 
        //用第一种折半方式输出插入的角标值 
        System.out.println("当key=20在数组arr中插入的角标位置是："+arrayDemo1(arr,key)); 
        key=1; 
        //用第二种折半方式输出插入的角标值 
        System.out.println("当key=1在数组arr中插入的角标位置是："+arrayDemo2(arr,key)); 
    } 
 
    //折半查找<一> 
    public static int arrayDemo1(int[] arr,int key) 
    { 
        int min=0,max=arr.length-1,mid=(max+min)/2; 
        while(key!=arr[mid]) 
        { 
            if(min>max) 
                return min; 
            else if(key>arr[mid]) 
                min=mid+1; 
            else  
                max=mid-1; 
            mid=(max+min)>>>1;//折半操作            
        } 
        return mid;  
    } 
 
    //折半查找<二> 
    public static int arrayDemo2(int[] arr,int key) 
    { 
        int min=0,max=arr.length-1,mid; 
 
        while(min<max) 
        { 
            mid=(max+min)>>>1;//折半操作 
            if(key>arr[mid]) 
                min=mid+1; 
            else if(key<arr[mid]) 
                max=mid-1; 
            else 
                return mid; 
        } 
        return min;  
    } 
 
    //遍历数组 
    public static void printArray(int[] arr) 
    { 
        System.out.print("["); 
        for (int x=0;x<arr.length;x++) 
        { 
            if(x!=arr.length-1) 
                System.out.print(arr[x]+","); 
            else 
                System.out.print(arr[x]+"]"); 
        } 
        //换行 
        System.out.println();
    }
}

2、 Arrays类中已经定义了binarySearch方法进行二分查找，需要二分查找时直接使用就行了。

代码：

package com.itheima;
    import java.util.Arrays;
   
    class ArrayDemo5{
           public static void main(String[]args) {
             int[] arr={2,6,9,11,15,19,22,30};
             //如果存在返回的具体的角标位置，不存在返回的是-插入点-1
             int index = Arrays.binarySearch(arr,20);
             System.out.println("index = " + index );
          }
    }

查找API，发现binarySearch方法的返回结果为：如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

所以得到的结果是一个负数。

四、数组与集合的相互应用

示例：

需求：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}

思路：

!、数组的长度是固定的,不知道数组中有几个重复元素因此不能判定新数组的长度,用集合存入

!!、需要得到的数组为有序的,因此用ArrayList集合最佳

!!!、遍历原数组的元素,并逐个加入到ArrayList集合中,同时用contains判断集合中是否已经存在该元素,如果不存在则加入,由此可完成去重复功能

!!!!、用toArray方法可将集合返回数组

代码：

import java.util.*;
public class ArrayDemo6 {
      publicstatic void main(String[] args) {
           //TODO Auto-generated method stub
           Integer[] a = {4,2,4,6,1,2,4,7,8};
           //定义一个ArrayList集合,明确集合中的元素均为整数,加泛型限定
           ArrayList<Integer>arr = new ArrayList<Integer>();
           System.out.print("原数组是:");
           ma(a);
           inti=0;
           //用循环语句遍历原数组的元素,并加入到集合中
           while(i<a.length)
           {
                 if(!arr.contains(a[i]))//判断集合中是否已存在该元素
                 arr.add(a[i]);
                 i++;
           }
           Object[]b =arr.toArray();
           System.out.print("新数组是:");
           ma(b);
      }
      //定义ma方法以遍历获取数组中的元素并打印
      staticvoid ma(Object[] aaa){
           System.out.print("{");
           for(intx=0;x<aaa.length;x++){
                 if(x==0){
                 System.out.print(aaa[x]);
                 }
                 else{
                      System.out.print(","+aaa[x]);
                 }
           }
           System.out.println("}");
      }