排序算法--插入排序

插入排序原理：假设给数组Array排序 ，从第二个元素开始排序，就假定的条件是待排序的数字的前面所有的元素已经有序！如从第二个元素开始，前面的一个元素一定是有序的。如果第一个元素比第二个元素大，将一后移。借用算法导论书上的图



第一次从第二个元素开始，

到给下标是N的元素排序的时候，[0....N-1]的元素已经是有序的，这个时候，是从N-1的下标开始比较，如果N-1大于N，就将N-1后移。然后继续比较

N-2和N元素的大小，如果还是大于N，N-2后移，到一个不大于N的元素的时候，直接将N的数组赋给改元素的后一个元素。

public static void insertSort(int [] arr)
    {
        
        for(int i=2;i<arr.length;i++)
        {
            
            int temp = arr[i];
            
            int k = i-1;
            while(k>=0 && arr[k]>temp)
            {
                
                arr[k+1]=arr[k];
                k--;
            }
            arr[k+1]=temp;
            
            
        }
    }

 从上面可以看出改算法的时间复杂度为O(n*n)

 

问题的提出：假设有A,B两个文件，文件里面都是url地址，各有10亿条，如何找出AB两个文件里面都存在的Url。(内存装不下任何一个文件的十分之一）

解决方法：首先在不考虑内存的情况下，我们最传统的方法就是是遍历AB两个文件一个一个的比较，这个方法是能找出结果，但是时间复杂度是o(n2)，对于没一个url都要去遍历一遍另外的一个文件。

　　而Bloom Filter可以解决该问题，同时在时间和空间的开销上都是很小的。原理如下：

1.建立一个byte数组 ，长度为LEN,数组的长度越长发送错误的概率越低

2.读取A的每一个记录，对每一个记录建立一个hash，假设hash值是D

3可以将数组的(LEN-1) & D 位标识值1

4.对于查询是否包含该记录的请求，可以直接查看数组的(LEN-1) & D 的值是否为1，如果为1表示存在

测试代码如下：

import java.util.ArrayList;
import java.util.List;

/**
 * 布尔过滤，bit的越大发生的错误的概率越小，哈希的函数和次数也决定啦错误的概率
 * 
 * @author zxc
 * 
 */
public class BoolFilter {
    private byte[] bits;
    private int size;

    public BoolFilter(int size) {
        this.size = size;
        bits = new byte[size];
    }

    public void add(String str) {
        int hash = str.hashCode();
        bits[(size - 1) & hash] = 1;
    }

    public boolean contain(String str) {
        return bits[(size - 1) & str.hashCode()] == 1;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BoolFilter filter = new BoolFilter(10000000);
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 99; i++) {
            String str = java.util.UUID.randomUUID().toString();
            list.add(str);
            filter.add(str);
        }

        for (int i = 0; i < 10; i++) {
            String str = java.util.UUID.randomUUID().toString();
            System.out.println(filter.contain(str));
        }
        System.out
                .println("----------------------------------------------------------");

        for (int i = 0; i < 10; i++) {
            // String str = java.util.UUID.randomUUID().toString();
            System.out.println(filter.contain(list.get(i)));
        }

    }

}

 

可能大家会有疑问为什么byte数组搞的那么长10000000，这个该算法的本身有关，如果byte的数组长度为1，那么对于任何的处理都是查询处理存在。

而byte越长，那么出现的hash碰撞的概率就越小，同时hash的次数越多出现的概率也越低，但是都不能保证不发生错误。只是降低了错误的概率。