查找算法总结之一（静态查找表）

静态查找表（Static Search Table）：只作查找操作的查找表；
动态查找表（Dynamic Search Table）：在查找过程中同时插入不存在的元素，或者是删除已经存在的元素。
静态查找主要有3种：顺序查找、折半查找、分块查找（索引顺序查找）

---

顺序查找 ：一个一个的查找，时间复杂度为O(n)

/**
     * @param input
     * @param key
     * @return 返回关键字在数组中的位置，-1表示没有查找到该关键字
     */
    public static int seqSearch(int []input,int key){
        for(int i=0;i<input.length-1;i++){
            if(input[i]==key){
                return i;
            }
        }
        return -1;
    }

折半查找 ：先确定待查找记录所在的范围（区间），然后逐步缩小范围直至找到或者找不到该记录为止，时间复杂度为O(logn)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class BinarySearch {
    /**
     * @param input
     * @param key
     * @return 返回关键字在数组中的位置，-1表示没有查找到该关键字
     */
    public static int binarySearch(int[]input,int key){
        int high = input.length-1;
        int low = 0;
        while(high>=low){
            int mid = (low+high)/2;
            if(input[mid]==key)
                return mid;
            else if(input[mid]>key){
                high = mid-1;
            }else if(input[mid]<key){
                low = mid+1;
            }
        }
        return -1;
    }
    public static void bubbleSort(int [] input,int n){
        //外围循环n-1次，每次确定一个元素的位置，位于尾部
        for(int i=0;i<n-1;i++){
            //标记位，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。
            boolean flag = false;
            //内部循环，相邻元素进行比较，比较次数逐步减1
            for(int j=0;j<n-1-i;j++){
                //从小到大排序
                if(input[j]>input[j+1]){
                    int temp = input[j];
                    input[j] = input[j+1];
                    input[j+1] = temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }       
    }   
    public static void main(String[] args) throws IOException {
        StreamTokenizer cin = new StreamTokenizer (new BufferedReader(new InputStreamReader(System.in)));
        while(cin.nextToken()!=cin.TT_EOF){
            int n =(int)cin.nval;
            int []input = new int[n];
            for(int i=0;i<n;i++){
                cin.nextToken();
                input[i] = (int)cin.nval;
            }
            bubbleSort(input,input.length);
            binarySearch(input,5);
            System.out.print(binarySearch(input,5));            
        }
    }
}

索引顺序表的查找 ：一般使用分块查找，首先对每个子表建立一个索引项，其中包括两项内容：关键字项（其值为子表中的最大关键字）、指针项（指示该子表的第一个元素在表中的位置）。索引表按关键字有序，则表或者有序或者分块有序。即是，块内无序，块间有序。

例：