查找排序算法

简单的查找，从数组第一个元素开始，逐个与给定值比对，相等，返回数组下标，如果整个数组比对结束没有找到相等的，返回-1.

1、二分查找法（binary search）：前提条件，待查找的元素要有序。

先确定三个量：low、heigh、和middle，分别表示一次查询的开始、结束和中间下标

[java] view plain copy

1. public class BinarySearch  
2. {  
3.     public static int binarySearch(int[] array,int value)  
4.     {  
5.         int low = 0;  
6.         int high = array.length -1;  
7.         int middle;       
8.         while(low <= high)  
9.         {     
10.             middle = (low +high) / 2;  
11.             /* 这一段可以打印每次查找的中间结果，就是middle的位置 
12.             for(int i = 0; i < array.length; i++) 
13.             { 
14.                 System.out.print(array[i]); 
15.                 if(i == middle) 
16.                 { 
17.                     System.out.print("*"); 
18.                 } 
19.                 System.out.print(" "); 
20.             } 
21.             System.out.println(); 
22.             */  
23.             if(value == array[middle])  
24.             {  
25.                 return middle;  
26.             }  
27.             if(value < array[middle])  
28.             {  
29.                 high = middle -1;  
30.             }  
31.             if(value > array[middle])  
32.             {  
33.                 low = middle + 1;  
34.             }                     
35.         }  
36.         return -1;  
37.     }  
38.   
39.     public static void main(String[] args)  
40.     {  
41.         int[] array = {1,2,3,4,5,6,7,8,9,10,11,12};  
42.   
43.         int index = binarySearch(array,15);  
44.   
45.         System.out.println(index);  
46.     }  
47. }  

打印的结果为（将打印代码有效）

[java] view plain copy

1. C:\javacode>java BinarySearch  
2. 1 2 3 4 5 6* 7 8 9 10 11 12  
3. 1 2 3 4 5 6 7 8 9* 10 11 12  
4. 1 2 3 4 5 6 7 8 9 10 11* 12  
5. 1 2 3 4 5 6 7 8 9 10 11 12*  
6. -1  

2、交换排序

数组中第一个元素与后面的逐一比较，如果大于则交换，这样，最小的数就被找到，放在数组中下标0处，然后再对第二个元素进行同样的操作，找出第二小的数据，循环后，按从小到大顺序排列。

3、快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

4、对于java中的常量的命名规则：所有单词的字母都是大写，如果有多个单词，那么使用下划线即可，比如说：

Public static final int AGE_OF_PERSON=20；

在Java中声明final常量时通常都会加上static关键字，这样对象的每个实例都会访问唯一一份常量值。