必记算法

 

public static void insertSort(int[] a){
        for(int j=1;j<a.length;j++){
            int key=a[j];
            int i=j-1;
            while(i>=0&&key<a[i]){
                a[i+1]=a[i];
                i--;
            }
            a[i+1]=key;
        }
    }
    
    public static void merge(int[] a,int p,int q,int r){
        int n1=q-p+1;
        int n2=r-q;
        
        int[]left=new int[n1+1];
        int[]right=new int[n2+1];
        
        for(int i=0,j=p;i<n1;i++,j++){
            left[i]=a[j];
        }
        for(int i=0,j=q+1;i<n2;i++,j++){
            right[i]=a[j];
        }
        left[n1]=Integer.MAX_VALUE;
        right[n2]=Integer.MAX_VALUE;
        
        int i=0,j=0;
        for(int k=p;k<=r;k++){
            if(left[i]<=right[j]){
                a[k]=left[i++];
            }
            else{
                a[k]=right[j++];
            }
        }
    }
    
    public static void mergeSort(int[]a ,int p,int r){
        if(p<r){
            int q=(p+r)/2;
            mergeSort(a,p,q);
            mergeSort(a,q+1,r);
            merge(a,p,q,r);
        }
    }
    public static void bubbleSort(int[]a){
        for(int i=1;i<a.length;i++){
            for(int j=0;j<a.length-i;j++){
                if(a[j]>a[j+1]){
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
            }
        }
    }
    
    public static int partition(int[]a,int p,int r){
        int key=a[r];
        int i=p;
        for(int j=p;j<r;j++){
            if(a[j]<=key){
                //a[i] <--> a[j]
                 int tmp=a[i];
                a[i]=a[j];
                a[j]=tmp;
                
                i++;
            }
        }
        
        //a[i] <--> a[r]
        int tmp=a[i];
        a[i]=a[r];
        a[r]=tmp;
        
        return i;
    }
    public static void quickSort(int[]a,int p,int r){
        if(p<r){
            int q=partition(a,p,r);
            //int q=hoarePartition(a,p,r);
            quickSort(a,p,q-1);
            quickSort(a,q+1,r);
        }
    }
public static void insertSortRecursion(int[]a,int p){
        if(p>0){
            insertSortRecursion(a,p-1);
            
            int i=p-1;
            int key=a[p];
            while(i>=0&&key<a[i]){
                a[i+1]=a[i];
                i--;
            }
            a[i+1]=key;
        }
    }
    
    public static void insertSortUsingBinarySearch(int[]a){
        for(int j=1;j<a.length;j++){
            int key=a[j];
            int i=Search.binarySearch(a,0,j-1, key);
            if(i<0)
                i=-i-1;
            for(int k=j-1;k>=i;k--)
                a[k+1]=a[k];
            a[i]=key;
        }
    }

public static void selectSort(int[]a){
        for(int i=0;i<a.length-1;i++){
            int k=i;
            for(int j=k+1;j<a.length;j++){
                if(a[j]<a[k])
                    k=j;
            }
            if(k!=i){
                int tmp=a[k];
                a[k]=a[i];
                a[i]=tmp;
            }
        }
    }




public static int binarySearch(int[] a,int low,int high,int key){
        if(low>high)
            throw new IllegalArgumentException("low > high");
        
        while(low<=high){
            int mid=(low+high)/2;
            if(key<a[mid])
                high=mid-1;
            else if(key>a[mid])
                low=mid+1;
            else
                return mid;
        }
        return -(low+1);
    }
    
    public static int binarySearch(int[]a,int key){
        return binarySearch(a,0,a.length-1,key);
    }
    
    public static int binarySearchRecursion(int[] a,int low,int high,int key){
        if(low<=high){
            int mid=(low+high)/2;
            if(key<a[mid])
                return binarySearchRecursion(a,low,mid-1,key);
            else if(key>a[mid])
                return binarySearchRecursion(a,mid+1,high,key);
            else
                return mid;
        }
        else{
            return -(low+1);
        }
    }
    
    public static int binarySearchRecursion(int[]a,int key){
        return binarySearchRecursion(a,0,a.length-1,key);
    }






public static int bs_min2(int[] a,  int key) {
        /*假设n>=0, a[-1]<key&&a[n]>=key(但是程序并不访问这两个假想的元素)*/
        int low=-1, high=a.length;
        while(low+1!=high){
            /*invariant: a[low]<key && a[high]>=key && low<high */
            int mid=(low+high)/2;
            if(a[mid]<key)
                low=mid;
            else
                high=mid;
        }
        /*assert low+1=high && a[low]<key && a[high]>=key*/
        int p=high;
        if(p>=a.length||a[p]!=key)
            //p=-1;
            p=-(high+1);
        return p;
    }
public static int bs_max2(int[]a,int key){
        int l=-1,r=a.length;
        while(l+1!=r){
            int m=(l+r)/2;
            if(a[m]<=key)
                l=m;
            else
                r=m;
        }
        int p=l;
        if(p<=-1||a[p]!=key)
            p=-(l+1+1);
        return p;
    }

public int countInversions(int[]a,int p,int r){
        int inversion=0;
        if(p<r){
            int q=(p+r)/2;
            inversion+=countInversions(a, p, q);
            inversion+=countInversions(a, q+1, r);
            inversion+=mergeInversions(a, p, q, r);
        }
        return inversion;
    }
    
    public int mergeInversions(int[]a,int p,int q,int r){
        int n1=q-p+1;
        int n2=r-q;
        int[]left=new int[n1+1];
        int[]right=new int[n2+1];
        
        for(int i=0,j=p;j<=q;i++,j++){
            left[i]=a[j];
        }
        left[n1]=Integer.MAX_VALUE;
        
        for(int i=0,j=q+1;j<=r;i++,j++){
            right[i]=a[j];
        }
        right[n2]=Integer.MAX_VALUE;
        
        int inversion=0;
        int i=0,j=0;
        for(int k=p;k<=r;k++){
            if(right[j]<left[i]){
                inversion+=n1-i;
                /*for(int iter=i;iter<n1;iter++){
                    inversionPairs.add(new Pair(left[iter],right[j]));
                }*/
                
                a[k]=right[j++];
            }
            else{
                a[k]=left[i++];
            }
        }
        return inversion;
    }

public static int randomizedSelect(int[]a,int p,int r,int i){
        if(p==r){
            return a[p];
        }
        int q=randomizedPartition(a,p,r);
        int k=q-p+1;
        if(i==k){
            return a[q];
        }
        else if(i<k){
            return randomizedSelect(a,p,q-1,i);
        }
        else{
            return randomizedSelect(a,q+1,r,i-k);
        }
    }
    
    public static int randomizedSelect2(int[]a,int p,int r,int i){    
        int q=randomizedPartition(a,p,r);
        int k=q-p+1;
        while(i!=k){
            if(i < k){
                r=q-1;
            }
            else{//i > k
                p=q+1;
                i-=k;
            }
            q=randomizedPartition(a,p,r);
            k=q-p+1;
        }
        return a[q];
    }

int maxSum(int a[],int n){
    int max=INT_MIN;
    for(int i=0;i<n;i++){
        for(int j=i;j<n;j++){
            int s=0;
            for(int k=i;k<=j;k++){
                s+=a[k];
            }
            if(s>max)
                max=s;
        }
    }
    return max;
}

int maxSum2(int a[],int n){
    int max=INT_MIN;
    for(int i=0;i<n;i++){
        int s=0;
        for(int j=i;j<n;j++){
            s+=a[j];
            if(s>max)
                max=s;
        }
    }
    return max;
}

int maxSum3(int a[],int n){
    int*s=new int[n];
    s[0]=a[0];
    for(int i=1;i<n;i++){
        s[i]=s[i-1]+a[i];
    }
    int max=INT_MIN;
    for(int i=0;i<n;i++){
        if(s[i]>max)
            max=s[i];
    }
    for(int i=1;i<n;i++){
        for(int j=i;j<n;j++){
            int sum=s[j]-s[i-1];
            if(sum>max)
                max=sum;
        }
    }
    delete []s;
    return max;
}

int _max(int a,int b){
    return a>b?a:b;
}

int _max(int a,int b,int c){
    int m=a;
    if(b>m)
        m=b;
    if(c>m)
        m=c;
    return m;
}

int _maxSum4(int a[],int l,int r){
    if(l>r)
        return 0;
    if(l==r)
        return a[l];
    int m=(l+r)/2;
    int lmax=INT_MIN,lsum=0;
    for(int i=m;i>=l;i--){
        lsum+=a[i];
        if(lsum>lmax)
            lmax=lsum;
    }
    int rmax=INT_MIN,rsum=0;
    for(int i=m+1;i<=r;i++){
        rsum+=a[i];
        if(rsum>rmax)
            rmax=rsum;
    }
    
    return _max(lmax+rmax,_maxSum4(a,l,m),_maxSum4(a,m+1,r));
}
int maxSum4(int a[],int n){
    return _maxSum4(a,0,n-1);
}

int maxSum5(int a[],int n){
    /前i个元素中，最大子段和要么在前i-1个元素中（存储在maxsofar），
要么其结束为止为i(存储在maxendinghere)*/
    int maxsofar=INT_MIN,maxendinghere=0;
    for(int i=0;i<n;i++)    {
        maxendinghere=_max(maxendinghere+a[i],a[i]);
        maxsofar=_max(maxsofar,maxendinghere);
    }
    return maxsofar;
}

public static int LISLength(int[]a){
        int[]lens=new int[a.length];
        for(int i=0;i<a.length;i++){
            lens[i]=1;
            for(int j=0;j<i;j++){
                if(a[i]>=a[j]&&lens[j]+1>lens[i]){
                    lens[i]=lens[j]+1;
                }
            }
        }
        
        int max=Integer.MIN_VALUE;
        for(int i=0;i<a.length;i++){
            if(lens[i]>max)
                max=lens[i];
        }
        return max;
    }
    
    //若返回值为x,则a[x]>=val>a[x-1]
    private static int find(int[]a,int high,int val){
        int low=0;
        while(low<=high){
            int mid=(low+high)/2;
            if(val<a[mid])
                high=mid-1;
            else if(val>a[mid])
                low=mid+1;
            else
                return mid;
        }
        return low;
    }
    
    public static int LISLength2(int[]a){
        int[]lastElems=new int[a.length+1];
        lastElems[0]=Integer.MIN_VALUE;
        lastElems[1]=a[0];
        
        int maxLen=1;
        for(int i=1;i<a.length;i++){
            int j=find(lastElems,maxLen, a[i]);
            lastElems[j]=a[i];
            if(j>maxLen)
                maxLen=j;
        }
        return maxLen;
    }





public static int[] countingSort(int[] a, int k) {
        int[] b = new int[a.length];
        int[] c = new int[k];

        for (int i = 0; i < a.length; i++) {
            c[a[i]]++;
        }

        for (int i = 1; i < c.length; i++) {
            c[i] += c[i - 1];
        }

        for (int i = a.length - 1; i >= 0; i--) {
            b[--c[a[i]]] = a[i];
        }

        return b;
    }

#include <stdlib.h>
int bigrand(){
    return RAND_MAX*rand()+rand();
}

int rand(int l,int u){
    return l+bigrand()%(u-l+1);
}
void genknuth(int m,int n)
{
    for(int i=0;i<n;i++){
        int r=bigrand();
        if(r%(n-i)<m){
            cout<<i<<' ';
            m--;
        }
    }
    cout<<endl;
}

void gensets(int m,int n){
    set<int> s;
    while(s.size()<m){
        s.insert(bigrand()%n);
    }
    for(set<int>::iterator it=s.begin();it!=s.end();++it){
        cout<<*it<<' ';
    }
    cout<<endl;
}

void genshuf(int m,int n){
    int* a=new int[n];
    for(int i=0;i<n;i++)
        a[i]=i;
    for(int i=0;i<m;i++){
        int j=rand(i,n-1);
        int t=a[i];a[i]=a[j];a[j]=t;
    }
    sort(a,a+m);
    for(int i=0;i<m;i++)
        cout<<a[i]<<' ';
    cout<<endl;

    delete []a;
}
题目：有两个长为n的非递减数组A和B，把B接在A的后面变成长为2n的数组C。设计算法求C的中位数（第n小数）。
思路：O(n)的算法很容易找到，关键是用二分的思想设计logn算法。这题关键是用好a和b数组中脚标和为定值的元素的大小关系。
            直观想法是：如果中位数在数组a中，那么若a[m]<b[n-m-2]，此时比a[m]小的数最多只有n-2个，即a[m]不可能为第n小数，偏小更新左界;若a[m]> b [n-m-1],此时比a[m]小的数至少有n个，a[m]不可能为第n小数，偏大更新右界;若a[m]介于b[n-m-2]与b [n-m-1]则a[m]恰好为第n小数。 中位数在数组b中的情况类似。

int findNthNumber(int a[], int b[], int n){
    int l = 0, r = n -1;
    int m;
    while(l <= r){
        m = (l + r) / 2;
        if(m <= n - 2 && a[m] < b[n - m -2]){
            //此时比a[m]小的数最多只有n-2个，即a[m]不可能为第n小数，偏小更新左界
            l = m + 1;
        }
        else if (a[m] < b [n - m - 1]){
            //此时比a[m]小的数恰好有n-1个，a[m]就是第n小数，返回
            return a[m];
        }
        else r = m - 1;//此时比a[m]小的数至少有n个，即a[m]不可能为第n小数，偏大更新右界
    }
    //中位数在b数组中的情况，和上面类似
    l = 0, r = n -1;
    while(l <= r){
        m = (l + r) / 2;
        if(m <= n - 2 && b[m] < a[n - m -2]){
            l = m + 1;
        }
        else if (b[m] < a [n - m - 1]){
            return b[m];
        }
        else r = m - 1;
    }
}

也可以取a[m]与b[n-m-2]中较大的一个，然后与a[m+1]和b[n-m-1]作比较，简化后的代码如下
int findNthNumber(int a[], int b[], int n){
    int l = 0, r = n -1;
    int m, tmp;
    while(l <= r){
        m = (l + r) / 2;
        tmp = (a[m] < b [n - m - 2] ? b[n - m - 2] : a[m]);
        //tmp取a[m]与b[n-m-2]中较大的一个，然后与a[m+1]和b[n-m-1]作比较
        if(tmp > b [n - m - 1]){
            r = m - 1;
        }
        else if(tmp > a [m + 1]){
            l = m + 1;
        }
        else return tmp;
    }
}
//输入一个字符串，找出其中出现的相同的且长度最长的字符串。eg：input:banana  output:ana.
int comlen(const char* str1,const char* str2){
    assert((str1!=0)&&(str2!=0));
    int len=0;
    while(*str1!='\0'&&*str2!='\0'&&*str1++==*str2++){
        len++;
    }
    return len;
}

bool less(char* str1,char* str2){
    return strcmp(str1,str2)<=0;
}

void longestRepeatedSubstring(char* string){
    int n=strlen(string);
    char** a=new char*[n];
    for(int i=0;i<n;i++){
        a[i]=string+i;
    }
    sort(a,a+n,::less);

    int maxlen=-1,maxi;
    for(int i=0;i<n-1;i++){
        int len=comlen(a[i],a[i+1]);
        if(len>maxlen){
            maxlen=len;
            maxi=i;
        }
    }

    printf("%.*s\n",maxlen,a[maxi]);

    delete []a;
}

 待续。。。