BlogJava-Java杂家-随笔分类-Memorandum

求连续正整数使得其和为给定的一个正整数的构造性解法

DoubleH — Thu, 01 Dec 2011 14:09:00 GMT

如题：求连续正整数使得其和为给定的一个正整数

下面给出我的解法，几乎可以一步到位求出来

实现代码如下：

/**
*Author: Koth (http://weibo.com/yovn)
*Date:  2011-12-01
*/
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

int solve(int Y,int& X){
    int m=0;
    int t=Y;
    if(Y<=0){
        X=Y;
        return 1;
    }
    while((t&1)==0){
        m+=1;
        t=t>>1;
    }
    if(m==32){
        X=Y;
        return 1;
    }
    int lastK=32;
    for(;lastK>m+1;lastK--){
        if(Y &(1<<(lastK-1))){

            break;
        }

    }

    //its a number st. exp(2,K)
    if(lastK==(m+1)){
        X=Y;
        return 1;
    }
    int k=1<<(m+1);
    int b=(Y>>m)-(1<<(lastK-m-1));

    X=(1<<(lastK-m-2))+(b+1-k)/2;

    if(X<=0){
        k=k-1-((0-X)<<1);
        X=0-X+1;
    }

    return k;

}

int main(int argc,char* argv[]){
    if(argc<=1){
        fprintf(stdout,"Usage:%s number\n",argv[0]);
        return 0;
    }
    int Y=atoi(argv[1]);
    int X=0;
    int k=solve(Y,X);
    fprintf(stdout,"%d=",Y);
    for(int i=0;i<k;i++){
        fprintf(stdout,"%d",X+i);
        if(i<(k-1)){
            fprintf(stdout,"+");
        }
    }
    fprintf(stdout,"\n");
    return 0;
}

DoubleH 2011-12-01 22:09 发表评论

向上取整的一个应用

DoubleH — Mon, 04 May 2009 03:45:00 GMT

问题：
有个链表（List)，有N个元素，当N很大的时候，我们通常想分批处理该链表。假如每次处理M条(0
问题很简单，我们需要次，这里我们用<>表示向上取整,[]表示向下取整，那么怎么来表示这个值呢？
我们可以证明：
=[(N-1)/M]+1 (0
不失一般性，我们设N=Mk+r(0<=r 1）当r>0时，

左边：=<(Mk+r)/M>==k+=k+1
右边：[(N-1)/M]+1=[(Mk+r-1)/M]+1=[k+(r-1)/M]+1=k+1+[(r-1)/M]=k+1
2）当r=0
左边：=k
右边：[(N-1)/M]+1=[(Mk-1)/M]+1=[(M(k-1)+M-1)/M]+1=[k-1+(M-1)/M]+1=k+[(M-1)/M]=k

命题得证。

有了这个公式，我们在Java代码里可以这样计算:

int nn=(N-1)/M +1
.

因为'/'是往下取整的。

DoubleH 2009-05-04 11:45 发表评论

《算法概论》第一章习题35证明（Wilson定理)

DoubleH — Fri, 10 Apr 2009 14:38:00 GMT

   今天买了本《算法概论》影印注释版，仔细看了第一章，果然名不虚传，很是吸引人。
第一章的习题难度适中，这里抽出第35题来，这题是证明Wilson定理。
Wilson定理：
   N是一个素数当且仅当: (N-1)! ≡ -1(mod N)

证明：
首先我们证明若N是素数，那么等式成立，对于N=2,这是很明显的。以下证明N>2 的情形。
1）若N是素数，那么关于N同余的乘法群G={1,2,3....N-1}
    群G每个元素都有逆元，映射 f:a -> a^-1 ，f(a)=a^-1 是一个一一映射。现在，任取一个元素，它的逆元要么是其它一个元素，或者是它本身。我们假设其中元素x的逆元是它本身，那么x*x ≡1(mod N) =>(x+1)*(x-1)=K*N,而N是素数，所以要么x=N-1,要么x=1。也就是说，除了这两个元素，其它的元素的逆元都是映射到别的元素的。而N>2,是奇数，所以元素共有N-1个，也就是偶数个元素。这样，除了1和N-1外剩余的N-3个元素刚好结成两两一对(x,y)(逆元是唯一的）使得f(x)=y=x^-1,也就是xy≡1(mod N).
现在把G的元素全部乘起来，让互为逆元的元素组成一对那么(N-1)!=1*(N-1)*(x1*y1)*(x2*y2)...(xk*yk)≡1*(N-1)*1*1...1 (mod N)≡-1(mod N).
    这样，我们证明了一个方向了，下面我们证明另一个方向

2）若(N-1)! ≡ -1(mod N)成立，则N是素数，若不然，令 N是和数。则(N-1)!肯定整除N,因为N的每个因子p满足p>1,p    现在令(N-1)!=K1*N.又(N-1)! ≡ -1(mod N) => K1*N ≡ -1(mod N),由同余性质知，存在K2使得K1*N+1=K2*N,两边同时除以N得K1+1/N=K2.显然，这是不可能的，所以若(N-1)! ≡ -1(mod N)成立，则N是素数

证明完毕！

这里用群的概念能够简化一定的描述，其实可以完全不用群的概念的，只不过这样一来，描述更长点，繁琐点！

DoubleH 2009-04-10 22:38 发表评论

有意思的“电灯泡问题”

DoubleH — Wed, 05 Mar 2008 07:00:00 GMT

过道里依次挂着标号是1，2，3, ......，100的电灯泡，开始它们

都是灭着的。当第一个人走过时，他将标号为 1 的倍数的电灯泡的开关

线拉了一下；当第二个人走过时，他将标号为 2 的倍数的电灯泡的开关

线拉了一下；当第三个人走过时，他将标号为 3 的倍数的电灯泡的开关

线拉了一下；......  如此进行下去，当第一百个人走过时，他将标号为

100 的倍数的电灯泡的开关线拉了一下。

问：当第一百个人走过后，过道里亮着的电灯泡标号是多少？





我的思路：

设标号为K的灯泡被拉了L(K)次，那么当L(K)为奇数的时候，灯泡是亮的。

那么那些标号被拉了奇数次呢？

K=1时，很显然是只拉了1次，最后是亮的。

其次K>=2时，据题意，K号灯第1次，和第K次肯定是拉下了，其余的只会被第K的因子次拉，

据因式分解定理，数K分解为

K=p1^(n1)*p2^(n2)*.....pi^(ni)

其中p1,p2,...pi为素数。

那么，K有那些因子呢？

其实可以考虑任一个因子，他可能是从n1个p1中选若干个（0个到n1个)，从n2个p2中选若干个。。。。。（当全是0个的时候，这个特殊的因子是1）

这样，根据乘法原理，总共有L(K)=(n1+1)*(n2+1)*(n3+1).....

比如，12=2^2*3

一种有3*2=6个因子，他们是1,2,3,4,6,12.



现在考虑要使L(K)为奇数，那么n1,n2,n3不能有一个是奇数，或则，有一个ni+1为偶数，而偶数与任何数相乘仍为偶数。

从而，n1,n2,n3都为偶数,都能被2除。

因为n1,n2,n3都为偶数，显然该数必须是个平方数，可写成K=(X)^2.

从而，1，4，9，16，25，36，49，64，81，100最后是亮的。

DoubleH 2008-03-05 15:00 发表评论

伸展树与半伸展树Java实现

DoubleH — Tue, 18 Dec 2007 16:39:00 GMT

摘要: 伸展树与半伸展树属于自组织的数据结构，能按访问频率调整节点的位置调整一般通过如下方式： 1）绕根的单旋转，跟AVL的单旋转类似 2）一字型旋转(ZigZig Rotation) 3)之字形旋转(ZigZag Rotation) 旋转操作较简单，有点点繁琐。半伸展树不做完全的一字型旋转，它只让父节点绕祖父节点做单旋转。不管怎样，每次访问(插入/查找，删除时展开被删除父节... 阅读全文

DoubleH 2007-12-19 00:39 发表评论

一种新的AVL平衡树删除操作的实现

DoubleH — Tue, 18 Dec 2007 10:30:00 GMT

摘要: AVL树的是一种平衡的二叉搜索树。每次插入，删除的时候需要一个局部的平衡化操作。实现AVL树的插入操作一般不是很难，清楚的理解了平衡因子以及旋转操作实现起来就没多大问题了。难点一般在于删除操作的实现，教科书上一般用很大的篇幅来详细说明各种情况，看起来很凌乱，理解起来很是费劲。考虑到可以把删除操作看成插入操作的逆操作，这里我给出另一种较为清晰的实现方式： 1）删除的时候做一个标记的过程 ... 阅读全文

DoubleH 2007-12-18 18:30 发表评论

使用赢者树的外部排序

DoubleH — Sun, 16 Dec 2007 00:08:00 GMT

外部排序实现使用堆来生成若干个顺串，然后使用多路归并算法来生成最终排序好的内容。

本来打算使用败者树，结果发现败者树当参与的竞赛者相对较多的情况下，没有全部完成就被空节点充满了。
这个按照它的严格算法，其实也是可以知道不能保证总是能排完的。天快亮了，才彻底放弃使用败者树。改成实现赢者树，结果发现赢者树能保证不出错，实现竟也顺手。

最后整了个测试文件500M的随机内容，2~3分钟排序完成了（应该还可以优化），感觉还行。

代码较多，最要考虑到以后可能要重用。

package algorithms.extsort;

import java.io.IOException;

import algorithms.MinHeap;

/**
* @author yovn
*
*/
public class ExternalSorter {



    public void sort(int heapSize,RecordStore source,RunAcceptor mediator ,ResultAcceptor ra)throws IOException
    {
        MinHeap<Record> heap=new MinHeap<Record>(Record.class,heapSize);
        for(int i=0;i<heapSize;i++)
        {
            Record r=source.readNextRecord();
            if(r.isNull())break;
            heap.insert(r);
        }

        Record readR=source.readNextRecord();
        while(!readR.isNull()||!heap.isEmpty())
        {

            Record curR=null;
            //begin output one run
            mediator.startNewRun();
            while(!heap.isEmpty())
            {
                curR=heap.removeMin();

                mediator.acceptRecord(curR);

                if (!readR.isNull()) {
                    if (readR.compareTo(curR) < 0) {
                        heap.addToTail(readR);
                    } else
                        heap.insert(readR);
                }
                readR=source.readNextRecord();

            }
            //done one run
            mediator.closeRun();

            //prepare for next run
            heap.reverse();
            while(!heap.isFull()&&!readR.isNull())
            {

                heap.insert(readR);
                readR=source.readNextRecord();

            }


        }
        RecordStore[] stores=mediator.getProductedStores();
//        LoserTree  lt=new LoserTree(stores);
        WinnerTree  lt=new WinnerTree(stores);

        Record least=lt.nextLeastRecord();
        ra.start();
        while(!least.isNull())
        {
            ra.acceptRecord(least);
            least=lt.nextLeastRecord();
        }
        ra.end();

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


    public static void main(String[] args) throws IOException
    {
//        RecordStore store=new MemRecordStore(60004,true);
//        RunAcceptor mediator=new MemRunAcceptor();
//        ResultAcceptor ra=new MemResultAcceptor();
        ExternalSorter sorter=new ExternalSorter();

        RecordStore store=new FileRecordStore("test_sort.txt");
        RunAcceptor mediator=new FileRunAcceptor("test_sort");
        ResultAcceptor ra=new FileRecordStore("test_sorted.txt");


        sorter.sort(70000, store, mediator, ra);
    }

}

其余的都打包在此！

源码

DoubleH 2007-12-16 08:08 发表评论

图及其算法复习（Java实现) 三：最小支撑树（Prim,Kruskal算法）

DoubleH — Fri, 14 Dec 2007 15:48:00 GMT

六。最小支撑树MST
给定一个简单有向图，要求权值最小的生成树，即求最小支撑树问题。
所谓生成树，就是说树的顶点集合等于给定图的顶点集合，且边集合包含于图的边集合。
也就说找出构成树的，经过所有顶点的，且权值最小的边集。
树的定义是要求无回路的，然后是要求连通的。

有两个比较经典的算法是：
1）Prim算法：该算法的思想跟Dijstra算法非常相似，Dijstra算法中每次求出下一个顶点时依据的是离初始顶点最近的，而Prim算法则找离V1整个集合最近的，也就是从V1中某个节点出发到该顶点的边的权值最小。
其原理也是每次找局部最优，最后构成全局最优。
实现如下

@Override
    public Edge[] prim() {
        MinHeap<Edge> heap=new MinHeap<Edge>(Edge.class,numEdges);
        Edge[] edges=new Edge[numVertexes-1];
        //we start from 0
        int num=0;//record already how many edges;
        int startV=0;
        Arrays.fill(visitTags, false);
        Edge e;
        for(e=firstEdge(startV);isEdge(e);e=nextEdge(e))
        {
            heap.insert(e);
        }
        visitTags[startV]=true;

        while(num<numVertexes-1&&!heap.isEmpty())//tree's edge number was n-1
        {

            e=heap.removeMin();

            startV=toVertex(e);
            if(visitTags[startV])
            {
                continue;
            }
            visitTags[startV]=true;
            edges[num++]=e;
            for(e=firstEdge(startV);isEdge(e);e=nextEdge(e))
            {
                if(!visitTags[toVertex(e)])//can't add already visit vertex, this may cause cycle
                heap.insert(e);
            }



        }
        if(num<numVertexes-1)
        {
            throw new IllegalArgumentException("not connected graph");
        }
        return edges;
    }

/**
     * A Graph example
     * we mark the vertexes  with 0,1,2,.14 from left to right , up to down
     * S-8-B-4-A-2-C-7-D
     * |   |   |   |   |
     * 3   3   1   2   5
     * |   |   |   |   |
     * E-2-F-6-G-7-H-2-I
     * |   |   |   |   |
     * 6   1   1   1   2
     * |   |   |   |   |
     * J-5-K-1-L-3-M-3-T
     *
     */
    public static void testPrimMST() {



        DefaultGraph g=new DefaultGraph(15);
        g.setEdge(0, 1, 8);
        g.setEdge(1, 0, 8);//its a undirected graph
        g.setEdge(1, 2, 4);
        g.setEdge(2, 1, 4);
        g.setEdge(2, 3, 2);
        g.setEdge(3, 2, 2);
        g.setEdge(3, 4, 7);
        g.setEdge(4, 3, 7);

        g.setEdge(0, 5, 3);
        g.setEdge(5, 0, 3);
        g.setEdge(1, 6, 3);
        g.setEdge(6, 1, 3);
        g.setEdge(2, 7, 1);
        g.setEdge(7, 2, 1);
        g.setEdge(3, 8, 2);
        g.setEdge(8, 3, 2);
        g.setEdge(4, 9, 5);
        g.setEdge(9, 4, 5);


        g.setEdge(5, 6, 2);
        g.setEdge(6, 5, 2);
        g.setEdge(6, 7, 6);
        g.setEdge(7, 6, 6);
        g.setEdge(7, 8, 7);
        g.setEdge(8, 7, 7);
        g.setEdge(8, 9, 2);
        g.setEdge(9, 8, 2);


        g.setEdge(10, 5, 6);
        g.setEdge(5, 10, 6);
        g.setEdge(11, 6, 1);
        g.setEdge(6, 11, 1);
        g.setEdge(12, 7, 1);
        g.setEdge(7, 12, 1);
        g.setEdge(13, 8, 1);
        g.setEdge(8, 13, 1);
        g.setEdge(14, 9, 2);
        g.setEdge(9, 14, 2);

        g.setEdge(10, 11, 5);
        g.setEdge(11, 10, 5);
        g.setEdge(11, 12, 1);
        g.setEdge(12, 11, 1);
        g.setEdge(12, 13, 3);
        g.setEdge(13, 12, 3);
        g.setEdge(13, 14, 3);
        g.setEdge(14, 13, 3);

        g.assignLabels(new String[]{"S","B","A","C","D","E","F","G","H","I","J","K","L","M","T"});
        Edge[] edges=g.prim();
        int total=0;
        for(int i=0;i<edges.length;i++)
        {
            System.out.println(edges[i].toString(g));
            total+=edges[i].getWeight();
        }
        System.out.println("MST total cost:"+total);
}

2)Kruskal算法：
该算法开始把，每个节点看成一个独立的两两不同的等价类，每次去权值最小的边，如果关联这条边的两个顶点在同一个等价类里那么这条边不能放入MST（最小生成树）中，否则放入MST中，并把这两个等价类合并成一个等价类。
继续从剩余边集里选最小的边，直到最后剩余一个等价类了。
该算法涉及等价类的合并/查找,一般用父指针树来实现。下面先给出父指针树实现的并查算法。
带路径压缩的算法，其查找时间代价可以看做是常数的。

package algorithms;

/**
* @author yovn
*
*/
public class ParentTree {


    private static class PTreeNode
    {
        int parentIndex=-1;
        int numChildren=0;//only make sense in root

        void setParent(int i) {

            parentIndex=i;

        }
    }
    PTreeNode[] nodes;
    int numPartions;
    public ParentTree(int numNodes)
    {
        nodes=new PTreeNode[numNodes];
        numPartions=numNodes;
        for(int i=0;i<numNodes;i++)
        {
            nodes[i]=new PTreeNode();
            nodes[i].parentIndex=-1;//means root

        }

    }

    /**
     * use path compress
     * @param i
     * @return
     */
    public int find(int i)
    {
        if(nodes[i].parentIndex==-1)
        {
            return i;
        }
        else
        {
            nodes[i].setParent(find(nodes[i].parentIndex));//compress the path
            return nodes[i].parentIndex;
        }
    }

    public int numPartions()
    {
        return numPartions;
    }
    public boolean union(int i,int j)
    {
        int pi=find(i);
        int pj=find(j);
        if(pi!=pj)
        {
            if(nodes[pi].numChildren>nodes[pj].numChildren)
            {
                nodes[pj].setParent(pi);
                nodes[pj].numChildren+=nodes[pi].numChildren;
                nodes[pi].numChildren=0;

            }
            else
            {
                nodes[pi].setParent(pj);
                nodes[pi].numChildren+=nodes[pj].numChildren;
                nodes[pj].numChildren=0;
            }
            numPartions--;
            return true;
        }
        return false;
    }

}

从边集里权最小的边，我们又可以借助最小值堆来完成。有了父指针树以及最小值堆，现实Kruskal算法就很简单了：

@Override
    public Edge[] kruskal() {
        Edge[] edges=new Edge[numVertexes-1];
        ParentTree ptree=new ParentTree(numVertexes);
        MinHeap<Edge> heap=new MinHeap<Edge>(Edge.class,numEdges);
        for(int i=0;i<numVertexes;i++)
        {
            for(Edge e=firstEdge(i);isEdge(e);e=nextEdge(e))
            {
                heap.insert(e);
            }
        }
        int index=0;
        while(ptree.numPartions()>1)
        {
            Edge e=heap.removeMin();
            if(ptree.union(fromVertex(e),toVertex(e)))
            {
                edges[index++]=e;
            }
        }
        if(index<numVertexes-1)
        {
            throw new IllegalArgumentException("Not a connected graph");
        }
        return edges;

    }

OK，到此，图论的大概的算法算是复习完了。

DoubleH 2007-12-14 23:48 发表评论

图及其算法复习（Java实现) 二：拓扑排序，最短路径问题

DoubleH — Fri, 14 Dec 2007 13:00:00 GMT

摘要: 四拓扑排序考虑一个任务安排的例子，比如有很多任务T1,T2,.... 这些任务又是相互关联的，比如Tj完成前必须要求Ti已完成，这样T1,T2....序列关于这样的先决条件构成一个图，其中如果Ti必须要先于Tj完成，那么就是该图中的一条路径，路径长度为1的就是一条边。拓扑排序就是把这些任务按照完成的先后顺序排列出来。显然，这样的顺序可能不是唯一的，比如Tk，T... 阅读全文

DoubleH 2007-12-14 21:00 发表评论

图及其算法复习（Java实现) 一：存储结构，深度优先周游，广度优先周游

DoubleH — Fri, 14 Dec 2007 06:46:00 GMT

摘要: 很早就想总结一下了，一直没有时间，OK，进入正题。一图的基本概念及存储结构图G是由顶点的有穷集合，以及顶点之间的关系组成，顶点的集合记为V，顶点之间的关系构成边的集合E G=(V,E). 说一条边从v1,连接到v2,那么有v1Ev2(E是V上的一个关系）《=》∈E. 图有有向图，无向图之分，无向图的一条边相当于有向图的中两条边，即如果无向图... 阅读全文

DoubleH 2007-12-14 14:46 发表评论

排序算法复习（Java实现）(二）：归并排序，堆排序，桶式排序，基数排序

DoubleH — Thu, 13 Dec 2007 17:03:00 GMT

摘要: 六归并排序算法思想是每次把待排序列分成两部分，分别对这两部分递归地用归并排序，完成后把这两个子部分合并成一个序列。归并排序借助一个全局性临时数组来方便对子序列的归并，该算法核心在于归并。 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.c... 阅读全文

DoubleH 2007-12-14 01:03 发表评论

排序算法复习（Java实现）(一）：插入，冒泡，选择，Shell,快速排序

DoubleH — Wed, 12 Dec 2007 17:08:00 GMT

为了便于管理，先引入个基础类：

package algorithms;

/**
* @author yovn
*
*/
public abstract class Sorter<E extends Comparable<E>> {

    public abstract void sort(E[] array,int from ,int len);

    public final void sort(E[] array)
    {
        sort(array,0,array.length);
    }
    protected final void swap(E[] array,int from ,int to)
    {
        E tmp=array[from];
        array[from]=array[to];
        array[to]=tmp;
    }

}

一插入排序
该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序：

package algorithms;
/**
* @author yovn
*/
public class InsertSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    public void sort(E[] array, int from, int len) {
         E tmp=null;
          for(int i=from+1;i<from+len;i++)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j--)
              {
                  if(tmp.compareTo(array[j-1])<0)
                  {
                      array[j]=array[j-1];
                  }
                  else break;
              }
              array[j]=tmp;
          }
    }



}

二冒泡排序
这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

package algorithms;

/**
* @author yovn
*
*/
public class BubbleSorter<E extends Comparable<E>> extends Sorter<E> {

    private static  boolean DWON=true;

    public final void bubble_down(E[] array, int from, int len)
    {
        for(int i=from;i<from+len;i++)
        {
            for(int j=from+len-1;j>i;j--)
            {
                if(array[j].compareTo(array[j-1])<0)
                {
                    swap(array,j-1,j);
                }
            }
        }
    }

    public final void bubble_up(E[] array, int from, int len)
    {
        for(int i=from+len-1;i>=from;i--)
        {
            for(int j=from;j<i;j++)
            {
                if(array[j].compareTo(array[j+1])>0)
                {
                    swap(array,j,j+1);
                }
            }
        }
    }
    @Override
    public void sort(E[] array, int from, int len) {

        if(DWON)
        {
            bubble_down(array,from,len);
        }
        else
        {
            bubble_up(array,from,len);
        }
    }

}

三，选择排序
选择排序相对于冒泡来说，它不是每次发现逆序都交换，而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
相对与插入排序来说，选择排序每次选出的都是全局第i小的，不会调整前i个元素了。

package algorithms;
/**
* @author yovn
*
*/
public class SelectSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        for(int i=0;i<len;i++)
        {
            int smallest=i;
            int j=i+from;
            for(;j<from+len;j++)
            {
                if(array[j].compareTo(array[smallest])<0)
                {
                    smallest=j;
                }
            }
            swap(array,i,smallest);

        }

    }

}

四 Shell排序
Shell排序可以理解为插入排序的变种，它充分利用了插入排序的两个特点：
1）当数据规模小的时候非常高效
2）当给定数据已经有序时的时间代价为O(N)
所以，Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，知道最后成一个块，并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列

package algorithms;

/**
* @author yovn
*/
public class ShellSorter<E extends Comparable<E>> extends Sorter<E>  {

    /* (non-Javadoc)
     * Our delta value choose 2^k-1,2^(k-1)-1,.7,3,1.
     * complexity is O(n^1.5)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {

        //1.calculate  the first delta value;
        int value=1;
        while((value+1)*2<len)
        {
            value=(value+1)*2-1;

        }

        for(int delta=value;delta>=1;delta=(delta+1)/2-1)
        {
            for(int i=0;i<delta;i++)
            {
                modify_insert_sort(array,from+i,len-i,delta);
            }
        }

    }

    private final  void modify_insert_sort(E[] array, int from, int len,int delta) {
          if(len<=1)return;
          E tmp=null;
          for(int i=from+delta;i<from+len;i+=delta)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j-=delta)
              {
                  if(tmp.compareTo(array[j-delta])<0)
                  {
                      array[j]=array[j-delta];
                  }
                  else break;
              }
              array[j]=tmp;
          }

    }
}

五快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤：
1）选择一个枢纽元素（有很对选法，我的实现里采用去中间元素的简单方法）
2）使用该枢纽元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并把枢纽元素放在合适的位置。
3）根据枢纽元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，对左边的，右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法，也可以说是最有技巧的部分。

package algorithms;

/**
* @author yovn
*
*/
public class QuickSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        q_sort(array,from,from+len-1);
    }


    private final void q_sort(E[] array, int from, int to) {
        if(to-from<1)return;
        int pivot=selectPivot(array,from,to);



        pivot=partion(array,from,to,pivot);

        q_sort(array,from,pivot-1);
        q_sort(array,pivot+1,to);

    }

    private int partion(E[] array, int from, int to, int pivot) {
        E tmp=array[pivot];
        array[pivot]=array[to];//now to's position is available

        while(from!=to)
        {
            while(from<to&&array[from].compareTo(tmp)<=0)from++;
            if(from<to)
            {
                array[to]=array[from];//now from's position is available
                to--;
            }
            while(from<to&&array[to].compareTo(tmp)>=0)to--;
            if(from<to)
            {
                array[from]=array[to];//now to's position is available now
                from++;
            }
        }
        array[from]=tmp;
        return from;
    }

    private int selectPivot(E[] array, int from, int to) {

        return (from+to)/2;
    }

}

还有归并排序，堆排序，桶式排序，基数排序，下次在归纳。

DoubleH 2007-12-13 01:08 发表评论

树的非递归遍历粗糙版

DoubleH — Thu, 11 Oct 2007 08:05:00 GMT

/**
*
*/

import java.util.Stack;
import java.util.Vector;

/**
* @author yovn
*
*/
public class TreeDemo {

    static interface NodeVistor
    {
         <T> void visit(BinaryTreeNode<T> node);
    }
    static class BinaryTree<T>
    {
        BinaryTreeNode<T> root;

        public BinaryTree(BinaryTreeNode<T> root) {
            this.root=root;
        }

        //no recursion ,pre-order
        void NLRVisit(NodeVistor visitor)
        {
            BinaryTreeNode<T> pointer=root;
            Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
            while(!stack.isEmpty()||pointer!=null)
            {
                if(pointer!=null)
                {
                    visitor.visit(pointer);
                    if(pointer.rightChild!=null)
                    {
                        stack.push(pointer.rightChild);
                    }
                    pointer=pointer.leftChild;
                }
                //go to right child
                else
                {
                    pointer=stack.pop();

                }
            }
        }

        //no recursion , in-order
        void LNRVisit(NodeVistor visitor)
        {
            BinaryTreeNode<T> pointer=root;
            Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
            while(!stack.isEmpty()||pointer!=null)
            {
                if(pointer!=null)
                {
                    stack.push(pointer);

                    pointer=pointer.leftChild;
                }
                //no left child here, then visit root and then go to right child
                else
                {
                    pointer=stack.pop();
                    visitor.visit(pointer);
                    pointer=pointer.rightChild;

                }
            }
        }


        //no recursion ,post-order,this one is the most complex one.
        //we need know from which side ,it back(left or right)
        void LRNVisit(NodeVistor visitor)
        {
            if(root==null)return;
            BinaryTreeNode<T> pointer=root;
            Stack<BinaryTreeNode<T>> stack=new Stack<BinaryTreeNode<T>>();
            while(true)
            {

                //mark left
                while(pointer!=null)
                {
                    stack.push(pointer);
                    pointer=pointer.leftChild;
                }


                pointer=stack.pop();

                while(pointer.visitedRight)//back from right child, so we can visit it now.
                {
                    visitor.visit(pointer);
                    if(stack.isEmpty())return;
                    pointer=stack.pop();
                }

                pointer.visitedRight=true;
                stack.push(pointer);

                pointer=pointer.rightChild;


            }

        }


        void levelOrder(NodeVistor visitor)
        {
            if(root==null)return;
            BinaryTreeNode<T> pointer=root;
            Vector<BinaryTreeNode<T>> queue=new Vector<BinaryTreeNode<T>>();

            queue.add(pointer);
            while(!queue.isEmpty())
            {
                BinaryTreeNode<T> node=queue.remove(0);
                visitor.visit(node);
                if(node.leftChild!=null)
                {
                    queue.add(node.leftChild);
                }
                if(node.rightChild!=null)
                {
                    queue.add(node.rightChild);
                }

            }

        }

    }
    static class BinaryTreeNode<T>
    {

        BinaryTreeNode(T data)
        {
            this.data=data;
        }
        T data;
        boolean visitedRight;
        BinaryTreeNode<T> leftChild;
        BinaryTreeNode<T> rightChild;
    }

    /**
     *
     */
    public TreeDemo() {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        BinaryTreeNode<String> root=new BinaryTreeNode<String>("A");
        root.leftChild=new BinaryTreeNode<String>("B");
        root.rightChild=new BinaryTreeNode<String>("C");


        root.leftChild.leftChild=new BinaryTreeNode<String>("D");

        root.rightChild.leftChild=new BinaryTreeNode<String>("E");

        root.rightChild.rightChild=new BinaryTreeNode<String>("F");

        root.rightChild.leftChild.rightChild=new BinaryTreeNode<String>("G");

        root.rightChild.rightChild.leftChild=new BinaryTreeNode<String>("H");
        root.rightChild.rightChild.rightChild=new BinaryTreeNode<String>("I");

        NodeVistor visitor=new NodeVistor()
        {

            @Override
            public <T> void visit(BinaryTreeNode<T> node) {
                System.out.print("'"+node.data+"'");

            }

        };

        BinaryTree<String> tree=new BinaryTree<String>(root);


        System.out.println("pre-order visit");
        tree.NLRVisit(visitor);
        System.out.println();
        System.out.println("in-order visit");

        tree.LNRVisit(visitor);

        System.out.println();
        System.out.println("post-order visit");

        tree.LRNVisit(visitor);

        System.out.println();
        System.out.println("level-order visit");

        tree.levelOrder(visitor);
    }

}

DoubleH 2007-10-11 16:05 发表评论

表达式求值Java粗糙版

DoubleH — Tue, 09 Oct 2007 14:48:00 GMT

/**
*
*/
package com.yovn.algo;

import java.util.Stack;
import java.util.Vector;

/**
* @author yovn
*
*/
public class Caculator {


    class Item
    {
        boolean ops;
        int value;

        Character opVal;
        int opPriority;
    }

    Stack<Item> opStack=new Stack<Item>();
    Vector<Item> calcStack=new Vector<Item>();
    /**
     *
     */
    public Caculator() {
        // TODO Auto-generated constructor stub
    }




    public int calc()
    {
        Stack<Item> tmp=new Stack<Item>();
        while(!calcStack.isEmpty())
        {
            Item it=calcStack.remove(0);

            if(!it.ops)
            {
                tmp.push(it);
            }
            else
            {
                int op2=tmp.pop().value;
                int op1=tmp.pop().value;
                Item newItem=new Item();
                newItem.ops=true;
                switch(it.opVal)
                {
                case '+':
                    newItem.value=op1+op2;

                    break;
                case '-':
                    newItem.value=op1-op2;
                    break;
                case '*':

                    newItem.value=op1*op2;
                    break;
                case '/':
                    newItem.value=op1/op2;
                    break;
                }
                tmp.push(newItem);
            }
        }
        return tmp.pop().value;
    }
    /**
     * 1)数字直接输出
     * 2)开括号则压栈
     * 3）闭括号把栈中元素依次输出直到遇到开括号
     * 4）运算符时
     *     a)循环，当栈非空，并且栈顶元素不是开括号，并且栈顶运算符优先级不低于输入的运算符的优先级，反复将其输出
     *     b）把输入运算符压栈
     * 5）输出栈内剩余元素
     * @param in
     * @return
     */
    public String transInfixToPosfix(String in)
    {
        char[] cin=in.toCharArray();
        StringBuffer buffer=new StringBuffer();

        for(int i=0;i<cin.length;i++)
        {
            Item newItem=new Item();
            newItem.opPriority=1;
            newItem.ops=false;

            switch(cin[i])
            {

            case '+':
                newItem.opPriority=1;
                newItem.ops=true;
                newItem.opVal='+';
                doOps(buffer, newItem);

                break;
            case '-':
                newItem.opPriority=1;
                newItem.ops=true;
                newItem.opVal='-';
                doOps(buffer, newItem);
                break;
            case '*':
                newItem.opPriority=2;
                newItem.ops=true;
                newItem.opVal='*';
                doOps(buffer, newItem);
                break;
            case '/':
                newItem.opPriority=2;
                newItem.ops=true;
                newItem.opVal='/';
                doOps(buffer, newItem);
                break;

            case '(':
                newItem.ops=true;
                newItem.opVal='(';
                opStack.push(newItem);

                break;
            case ')':
                boolean meetClose=false;
                while(!opStack.isEmpty())
                {
                    Item item=opStack.peek();
                    if(item.ops&&item.opVal!='(')
                    {
                        calcStack.add(item);
                        opStack.pop();
                        buffer.append(item.opVal);
                    }
                    else if(item.ops)
                    {
                        opStack.pop();
                        meetClose=true;
                        break;
                    }
                }
                if(!meetClose)
                {
                    throw new RuntimeException();
                }
                break;

            default:
                int j=i;
                for(;j<cin.length&&cin[j]>='0'&&cin[j]<='9';j++);
                if(j==i)
                {
                    throw new RuntimeException("wrong input.");
                }
                newItem.ops=false;
                newItem.value=Integer.parseInt(new String(cin,i,j-i));
                buffer.append(newItem.value);
                calcStack.add(newItem);
                i=j-1;
                break;


            }
        }
        while(!opStack.isEmpty())
        {
            Item item=opStack.pop();
            calcStack.add(item);
            buffer.append(item.opVal);

        }
        return buffer.toString();

    }

    private void doOps(StringBuffer buffer, Item newItem) {
        while(!opStack.isEmpty())
        {
            Item item=opStack.peek();
            if(item.opVal!='('&&item.opPriority>=newItem.opPriority)
            {
                calcStack.add(item);
                opStack.pop();
                buffer.append(item.opVal);
            }
            else
            {
                break;
            }
        }
        opStack.push(newItem);
    }


    /**
     * @param args
     */
    public static void main(String[] args) {
        Caculator calc=new Caculator();

        System.out.println("1+2*3+7-(4/2+8)/5="+calc.transInfixToPosfix("1+2*3+7-(4/2+8)/5"));
        System.out.println("value is:"+calc.calc());

    }

}

DoubleH 2007-10-09 22:48 发表评论

Java2EXE Builder 1.0.0

DoubleH — Sun, 15 Jul 2007 15:32:00 GMT

摘要: 这周末看不进书了，于是完善了以前的Java转EXE工具
以前的工具运行时要把所有的class载入，这对于大点的项目是不合适的。
这个版本调整了一下Loader的机制，保持EXE跟类文件浑然一体的同时又可以延迟加载class.
另外这个版本的加密强度提高很多，用来代替那些class混淆软件应该也不错。：）阅读全文

DoubleH 2007-07-15 23:32 发表评论

KMP fast string find

DoubleH — Tue, 10 Jul 2007 10:19:00 GMT

**
* Demonstrate KMP algorithm in Java
*
*
*/
public class KMP {


    public static int indexOf(String target,String pattern)
    {
        int pLen=pattern.length();
        int tLen=target.length();

        //the fail function
        int failFunc[]=new int[pLen];

        failFunc[0]=-1;

        //build fail function
        for(int i=1;i<pLen;i++)
        {
            int j=failFunc[i-1];
            while(pattern.charAt(i)!=pattern.charAt(j+1)&&j>=0)
            {
                //recursion
                j=failFunc[j];
            }
            if(pattern.charAt(i)==pattern.charAt(j+1))
            {
                failFunc[i]=j+1;
            }
            else
            {
                failFunc[i]=-1;
            }
        }

        int pPos=0,tPos=0;

        while(tPos<tLen&&pPos<pLen)
        {
            if(target.charAt(tPos)==pattern.charAt(pPos))
            {
                //match ,then do forward
                tPos++;
                pPos++;
            }
            else if(pPos==0)
            {
                //target go forward
                tPos++;
            }
            else
            {
                //target postion don't change,pattern go back
                pPos=failFunc[pPos-1]+1;
            }
        }

        if(pPos<pLen)return -1;
        else return tPos-pLen;



    }

}

DoubleH 2007-07-10 18:19 发表评论

OS Development Enivironment Setup

DoubleH — Sat, 26 May 2007 06:25:00 GMT

1)DJGPP v203
2)Nasm 0.98.39
3)gcc args:
gcc -Wall -O -fomit-frame-pointer -nostdinc -fno-builtin

4)link.ld
ld -T link.ld

OUTPUT_FORMAT("binary")
ENTRY(start)
phys = 0x00100000;
SECTIONS
{
  .text phys : AT(phys) {
    code = .;
    *(.text)
    *(.rodata)
    . = ALIGN(4096);
  }
  .data : AT(phys + (data - code))
  {
    data = .;
    *(.data)
    . = ALIGN(4096);
  }
  .bss : AT(phys + (bss - code))
  {
    bss = .;
    *(.bss)
    . = ALIGN(4096);
  }
  end = .;
}

5)Bootable CD
mkisofs -R -b boot/grub/eltorito.s2 -no-emul-boot -boot-load-size 4 -boot-info-table -o yovnos.iso iso

DoubleH 2007-05-26 14:25 发表评论