数组的两种种排序方式和查找方式举例

数组的查找方式

第一种（最简单）普通查找：实现功能原理：获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在，这种查找是从头到后查找。代码如下：

publicclassSearchTest {

   publicstaticint search(int[] a,int key){

     for(int i=0;i<a.length;i++){

        if(a[i]==key){

           return i;

        }

     }

     return -1;

   } 

   publicstaticvoidmain(String[] args) {

     int a[]={1,2,3,5,6,7,8};

     int value=4;

     int index=search(a,value);

     System.out.println(index);

   }

}

 

第二种二分查找（BinarySearch，折半查找）：二分查找可以提高效率，但实现二分查找的条件是该数组必须是有序的数组。

publicclassBinarySeachTest {

  publicstaticintbinarySearch(int[]a,int value){

    int low = 0;

     int high =a.length - 1;

     int middle;

 

     while(low <= high)

     {

        middle= (low + high) / 2;

 

        for(int i = 0; i < a.length; i++)

        {

           System.out.print(a[i]);

 

           if(i == middle)

           {

               System.out.print("#");

           }

 

           System.out.print(" ");

        }

        

        System.out.println();

 

 

        if(a[middle] == value)

        {

           return middle;

        }

 

        if(value <a[middle])

        {

           high= middle - 1;

        }

        if(value >a[middle])

        {

           low= middle + 1;

        }

     }

 

     return -1;

  }

  

  publicstaticvoid main(String[] args) {

     int[]i={1,2,3,4,5,6,7,8,9,12};

     

     int value=2;

     int index=binarySearch(i,value);

     System.out.println(index);

  }

}

数组排序

选择排序：

原理：第一个和第二个，第三个等元素比，确定了最小值（最大值），再拿第二个和后面元素挨个比。一直到最后，最后一个不用比；所以就是arr[].length-1

第一轮比完之后，开始第二轮就不考虑前面已经放好的元素。所以，代码如下：

publicclassArraySort {

publicstaticvoidsort(int[]a){

  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[i];

           a[i]=a[j];

           a[j]=temp;

        }

     }

  }

}

  publicstaticvoid main(String[] args) {

     int arr[]={2,7,4,8,3,9,5};

     sort(arr);

     for(int i=0;i<arr.length;i++){

        System.out.println(arr[i]);

     }

  }

}

冒泡排序

冒泡排序原理：相邻的两个元素进行比较，果符合条件排位，我们第一圈进行比较后，最后一位值出现了最后。代码如下：

publicstatic void bundleSort(inta[]){

       for(int i=0;i<a.length-1;i++){

          for(intj=0;j<a.length-i-1;j++){//-x;是让每一次的比较元素减少 -1：避免索引越界

             if(a[j]>a[j+1]){

                int temp=a[j];

                a[j]=a[j+1];

                a[j+1]=temp;

             }

          }

       }

}

publicstaticvoidmain(String[] args) {

  intarr[]={5,2,7,3,6,8,4,1};

  bundleSort(arr);

  for(int i=0;i<arr.length;i++){

     System.out.println(arr[i]);

  }

}

}

 

对于开发中我们就可以使用java定义好的Arrays类中sort（）方法排序，性能高，速度快

publicclassArraysTest {

     publicstaticvoidmain(String[] args) {

     intarray[]={3,7,1,6,5,2,4,8,9};

     Arrays.sort(array);

     for(int i=0;i<array.length;i++){

        System.out.println(array[i]);

     }

  }

}

 

 

小总结：发现无论什么排序，都需要对满足条件的元素进行位置置换，所以可以把这部分相同的代码出来，单独封装成一个函数。代码如下：

  public static void swap(int[] array,int a,int b){

    int temp=array[a];

 array[a]=array[b];

array[b]=temp;

}