数组常见算法

来源：互联网发布：蓝桥杯全国软件大赛编辑：程序博客网时间：2024/06/15 01:09

5，关于数组常见算法的代码剖析：

5.1拆分查找：

[java] view plain copy
 print?
class HalfSearch   
{  
    /* 
    在一个有序的数组中查找一个元素的位置； 
    例如：有数组{0,2,4,6,8,10,12}查找10的位置index=5 
    */  
    public static void main(String[] args)   
    {  
        int[] arr=new int[]{0,2,4,6,8,10,12};  
        int index=getIndex(arr,12);  
        System.out.println("index="+index);  
    }  
    //一般性做法，效率较低的算法  
    /* 
    public static int getIndex(int[] arr,int key) 
    { 
        for(int i=0;i<arr.length;i++) 
        { 
        if(arr[i]==key) 
            return i; 
        } 
        return -1; 
    } 
    */  
    //折半查找法  
    /* 
    public static int getIndex(int[] arr,int key) 
    { 
    int min=0; 
    int max=arr.length-1; 
    int mid=(min+max)/2; 
    while(arr[mid]!=key) 
        { 
            if(key>arr[mid]) 
                min=mid+1; 
            else 
                max=mid-1; 
            if(min>max)        //判断查找不到的情况，返回-1 
                return -1; 
                mid=(min+max)/2;   //折半 
        } 
        return mid; 
    } 
    */  
    //折半查找法的第二种方式：效率稍高  
  
    public static int getIndex(int[] arr,int key)  
    {  
        int min=0;  
        int max=arr.length-1;  
        int mid;  
        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;  
    }  
}  

5.2选择排序：

[java] view plain copy
 print?
class SelectSort   
{  
    public static void main(String[] args)   
    {  
        int[] arr=new int[]{2,1,5,3,6,4,8,9,7};  
        System.out.println("原数组：");  
        Print(arr);  
        System.out.println();  
        System.out.println("排序后：");  
        SelectSort(arr);  
    }  
    //选择排序，对一个数组进行升序排列  
    //打印原数组  
    public static void Print(int[] arr)  
    {  
        System.out.print("[ ");  
        for(int i=0;i<arr.length;i++)  
            {  
                if(i!=arr.length-1)  
                    System.out.print(arr[i]+", ");  
                else  
                    System.out.print(arr[i]+"]");  
            }  
    }  
    //选择排序  
    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;  
                            }  
                    }  
            }  
        Print(arr);  
    }  
}  

5.3冒泡排序：

[java] view plain copy
 print?
class  BubbleSort  
{  
    public static void main(String[] args)   
    {  
        int[] arr=new int[]{2,1,5,3,6,4,8,9,7};  
        System.out.println("原数组：");  
        Print(arr);  
        System.out.println();  
        System.out.println("排序后：");  
        BubbleSort(arr);  
    }  
    //打印原数组  
    public static void Print(int[] arr)  
    {  
        System.out.print("[ ");  
        for(int i=0;i<arr.length;i++)  
            {  
                if(i!=arr.length-1)  
                    System.out.print(arr[i]+", ");  
                else  
                    System.out.print(arr[i]+"]");  
            }  
    }  
    //冒泡排序  
    public static void BubbleSort(int[] arr)  
    {  
        for(int i=0;i<arr.length;i++)                  //for(int i=arr.length-1;i>0;i--)  
        {  
            for(int j=0;j<arr.length-i-1;j++)        //for(int j=0;j<x;j++)  
            {  
                if(arr[j]>arr[j+1])  
                {  
                int temp=arr[j];  
                arr[j]=arr[j+1];  
                arr[j+1]=temp;  
                }  
            }  
        }  
        Print(arr);  
    }  
}  

6.操作数组的工具类<Arrays>

Java.util包中封装了很多关于java数组的工具方法，这些方法都是静态的。

binarySearch;;(type[] a, type key) ：使用二分搜索法来搜索指定的 type 型数组，以获得指定的值。

binarySearchtype[] a, int fromIndex,int toIndex, type key) ：使用二分搜索法来搜索指定的 type 型数组的范围，以获得指定的值。

copyOfRange(type[] original, int from,int to)de> ：将指定数组的指定范围复制到一个新数组。

equals(type[] a, type[] a2) ：如果两个指定的 char 型数组彼此相等，则返回true。

fill(type[] a, type val) ：将指定的 byte 值分配给指定 type 节型数组的每个元素。

fill(type[] a, int fromIndex,int toIndex, type val) ：将指定的 type 值分配给指定 type 型数组指定范围中的每个元素。

sort(type[] a) ：对指定的 type 型数组按数字升序进行排序。

sort(type[] a, int fromIndex,int toIndex) ：对指定type 型数组的指定范围按数字升序进行排序。

toString(type[] a)：返回指定数组内容的字符串表示形式。

详情参见JDK 1.6API文档，有更好的解释。

总结：关于数组这一节的知识并不多，主要要学会数组的定义，理解好数组在内存中的表现形式，这对日后开发有很好的帮助。除此之外，还要掌握以上常见的排序算法，尤其是冒泡排序，虽然在开发中不常见，但是在面试时出现的概率很大。

此外，通过查阅API文档，发现了操作数组工具类Arrays有很多方法，在这里做了一些常见方法的总结，这些方法都是静态的，相当实用，例如sort方法，最好牢记下来，以便开发时直接拿来用，不必翻阅API文档。

0 0