国产欧美一区二区精品仙草咪,欧美在线播放一区,国产精品一区免费观看

周强 — Thu, 19 May 2011 08:44:00 GMT

�Q�一�Q��_杰斯�Ҏ��法�Q�时间复杂度O(n2)�Q?br />       �q�杰斯特拉（Dijkstra�Q�算法是求某个源点到其余各顶点的最短�\径，�q�是一个按路径长度递增的次序��生最短�\径的��法�?br />       首先引进一个辅助向量D,它的每个分量D[i]表示当前所扑ֈ�的从始点v到每个终点vi的最短�\径的长度。它的初态�ؓ�Q�若从v到vi有弧�Q�则D[i]为弧上的权��|��否则�|�D[i]为无�I�大。显�Ӟ��长度为D[j]=Min{D[i]|vi属于V}的�\径就是从v出发的长度最短的一条最短�\径。因此，在一般情况下�Q�下一条长度次短的最短�\径的长度必�ؓD[j]=Min{D[i]|vi 属于 V-S} 其中D[i]或者�ؓ弧（v,vi)上的权��|��或者是D[k](vk属于S)和弧�Q�vk,vi�Q�上的权��g��和。算法步骤如下：
(1)假设用带权的��L��矩阵arcs来表�C�带权有向图�Q�arcs[i][j]表示�?vi,vj)上的权倹{��若(vi,vj)不存在，则置arcs[i][j]为无�I�大。S为已扑ֈ�从v出发的最短�\径的�l�点的集合，它的初始状态�ؓ�I�集。那么，从v出发到图上其余各��点�Q�终点）vi,可能辑ֈ�的最短�\径长度的初��gؓ�Q?br />D[i]=G.arcs[v][vi],vi属于V
(2)选择Vj�Q��?br />   D[j]=Min{D[i]|vi 属于V-S}
vj ��是当前求得的一条从v出发的最短�\径的�l�点。��o
   S=S�Q�c��｛ｊ�?br />(3)   修改从v出发到集合V-S上�Q一��点vk可达的最短�\径长度。如果D[j]+arcs[j][k](4) 重复操作(2),(3)�?n-1�ơ。由此求得从v到图上其余各��点的最短�\径是依�\径长度递增的序列�?br />
�Q�二�Q�弗�z�伊�?Floyd)��法�Q�时间复杂度为O(n3)�Q?br />弗洛伊�d�Q�Floyd�Q�算法是求图中每一寚w��点之间的最短�\径，旉��复杂度�ؓO(n3).
弗洛伊�d��法仍从囄��带权��L��矩阵cost出发�Q�其基本思想�?:
假设求从��点vi到vj的最短�\径。如果从vi到vj有弧�Q�则从vi到vj存在一条长度arcs[i][j]的�\径，该�\径不一定是最短�\径，��需�q�行n�ơ试探。首先考虑路径(vi,v0,vj)是否存在�Q�即判别弧（vi,v0�Q�和(v0,vj)是否存在)�?如果存在�Q�则比较(vi,vj)�?vi,v0,vj)是否存在(卛_��别弧(vi,v0)�?v0,vj)是否存在).如果存在�Q�则比较(vi,vj)�?vi,v0,vj)的�\径长度取长度较短者�ؓ从vi到vj的中间顶点的序号不大�?的最短�\径。假如在路径上再增加一个顶点v1,也就是说�Q�如�?vi,...v1)�?v1...vj)分别为当前找到的中间��点的序号不大于0的最短�\径，那么�Q�vi,...,v1,...vj�Q�就有可能是从vi到vj的中间顶点的序号不大�?的最短�\径。将它和已经得到的从vi到vj中间的顶点序号不大于0的最短�\径相比较�Q�从中选出中间��点的序号不大于1的最短�\径之后，再增加一个顶点v2,�l�箋�q�行试探。依�ơ类推。在一般情况下�Q�若(vi,...,vk)�?vk,...vj)分别是从vi到vk和从vk到vj的中间顶点的序号不大于k-1的最短�\径，则将(vi,...vk,...vj)和已�l�得到的从vi到vj且中间顶点序号不大于k-1的最短�\径相比较�Q�其长度较短者便是从vi到vj的中间顶点的序号不大于k的最短�\径。这��P��在经�q�n�ơ比较后�Q�最后求得的必是从vi到vj的最短�\径�?br />现定义一个n阶方阵序�?br />D(-1),D(0),D(1),...D(k),...D(n-1)
其中
D(-1)[i][j]=G.arcs[i][j].
D(k)[i][j]=Min{D(k-1)[i][j],D(k-1)[i][k]+D(k-1)[k][j]} 0<=k<=n-1
从上�q�计��公式可见，D(1)[i][j]是从vi到vj的中间顶点的序号不大�?的最短�\径的长度。D(k)[i][j]是从vi到vj的中间顶点的序号不大于k的最短�\径的长度。D(n-1)[i][j]��是从vi到vj的最短�\径的长度�?br />

周强 2011-05-19 16:44 发表评论

最��生成树

周强 — Thu, 19 May 2011 03:09:00 GMT

安全边：在每一�ơ�P代之前， A是某个最��生成树的一个子集。在��法的每一步中�Q�确定一条边�Q�u,v),使得��它加入集合A后，仍然不违反这个��@环不�{�式�Q�A U {(u,v)}仍然是某一个最��生成树的子集。称�q�样的边为A的安全边�?br />
识别安全边的定理�Q�设图G=(V,E)是一个无向连通图�Q��ƈ且在E上定义了一个具有实数值的加权函数w.设A是E的一个子集，它包含于G的某个最��生成树中。设�?S,V-S)是G的�Q意一个不妨害A的割�Q�且�?u,v)是通过�?S,V-S)的一条轻边，则边(u,v)寚w��合A来说是安全的�?br />

推论�Q�设G=(V,E)是一个无向联通图�Q��ƈ且在E上定义了相应的实数值加权函数w.设A是E的子集，�q�包含于G的某一最��生成树中。设C=(Vc,Ec)为森林GA=(V,A) 的一个连通分支。如果边是连接C和Ga中其他某联通分支的一条轻边，�?u,v)寚w��合A来说是安�?

在Kruskal(克鲁斯卡��?��法和Prim(普里�?��法
在Kruskal��法中，集合A是一个森林，加入集合A中的安全�Ҏ��L��图中�q�接两个不同联通分支的最��权辏V��在Prim��法中，集合A仅�Ş成单��|��Q�添加入集合A的安全边��L��q�接树与一个不在树中的��点的最��权辏V�?br />
Kruskal(克鲁斯卡��?��法(O(ElgE))�Q?br />该算法找出森林中�q�接��L��两棵树的所有边中，��h��最��权值的�?u,v)作�ؓ安全边，�q�把它添加到正在生长的森林中。设C1和C2表示�?u,v)�q�接的两��|��Q�因�?u,v)必是�q�接C1和其他某��|��的一条轻边，所以由上面推论可知�Q?u,v)对C1来说是安全边。Kruskal ��法同时也是一�U�贪心算法，因�ؓ在算法的每一步中�Q�添加到��林中的边的权值都是尽可能��的�?br />下面是伪代码:
MST-KRUSKAL(G,w)
A<--�I�集
for each vertex v 属于 V[G]
      do MAKE-SET(v)
sort the edges of E into nondecreasing order by weight w
for each edge(u,v)属于E,taken in nondecreasing order by weight
   do if FIND-SET(u)!=FIND-SET(v)
            then A<--AU{(u,v)}
                     UNION(u,v)
return A

FIND-SET(u)�q�回包含u的集合中的一个代表元素。于是通过��试FIND-SET(u)是否�{�同于FIND-SET(v)�Q�就可以��定��点u和v是否属于同一��|��。通过�q�程UNION�Q�可以实现树与树的合�q��?br />

Prim��法(O(ElgV))
    Prim��法的特�Ҏ��集合A中的�Ҏ��L��形成单棵树。树从�Q意根��点r开始�Ş成，�q��渐生成�Q�直臌��树覆盖了V中的所有顶炏V��在每一步，一条连接了树A与Ga=(V,A)中某孤立��点的轻边被加入树A中。由推论可知�Q�该规则仅加入对A安全的边�Q�因此当��法�l�止�Ӟ��A中的边�Ş成了一��|��生成树。因此每�ơ添加到树中的边都是使树的权��可能小的边�Q�因此，上述�{�略也是“贪心“的�?br />
伪代码如下：
MST-PRIM(G,w,r)

for each u 属于V[G]
            do key[u] <--�I�集
                  n[u]<--NIL

key[r]<--0
Q<--V[G]
while Q!=�I�集
    do u<---EXTRACT-MIN(Q)
         for each v属于Adj[u]
               do if v 属于Q and w(u,v)                     then n[u]<---u
                            key[v]<--w(u,v)

参考：��法��D��

周强 2011-05-19 11:09 发表评论

周强 — Wed, 11 May 2011 02:25:00 GMT

转蝲�Q�http://m.shnenglu.com/converse/archive/2007/08/29/31179.html

/********************************************************************
created:    2007/08/28
filename:     avltree.c
author:        Lichuang

purpose:    AVL树的实现代码,
            参考资�?/span><<数据�l�构与算法分�?/span>-C语言描述>>, 作者Allen Weiss
*********************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct AVLTree
{
    int nData;
    struct AVLTree* pLeft;
    struct AVLTree* pRight;
    int nHeight;
}AVLTree;

int Max(int a, int b);
int Height(AVLTree* pNode);
AVLTree* Insert(int nData, AVLTree* pNode);
AVLTree* SingleRotateWithLeft(AVLTree* pNode);
AVLTree* SingleRotateWithRight(AVLTree* pNode);
AVLTree* DoubleRotateWithLeft(AVLTree* pNode);
AVLTree* DoubleRotateWithRight(AVLTree* pNode);
void DeleteTree(AVLTree** ppRoot);
void PrintTree(AVLTree* pRoot);

int main()
{
    int i;
    AVLTree* pRoot = NULL;

    srand((unsigned int)::time(NULL));

    for (i = 0; i < 100000000; ++i)
    {
        pRoot = Insert(::rand(), pRoot);
    }

    //PrintTree(pRoot);

    DeleteTree(&pRoot);

    return 0;
}

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

int Height(AVLTree* pNode)
{
    if (NULL == pNode)
        return -1;

    return pNode->nHeight;
}

AVLTree* Insert(int nData, AVLTree* pNode)
{
    if (NULL == pNode)
    {
        pNode = (AVLTree*)malloc(sizeof(AVLTree));
        pNode->nData = nData;
        pNode->nHeight = 0;
        pNode->pLeft = pNode->pRight = NULL;
    }
    else if (nData < pNode->nData)          // 插入到左子树�?br>    {
        pNode->pLeft = Insert(nData, pNode->pLeft);
        if (Height(pNode->pLeft) - Height(pNode->pRight) == 2)    // AVL树不�q��
        {
            if (nData < pNode->pLeft->nData)
            {
                // 插入��C��左子树左�? 做单旋�{
                pNode = SingleRotateWithLeft(pNode);
            }
            else
            {
                // 插入��C��左子树右�? 做双旋�{
                pNode = DoubleRotateWithLeft(pNode);
            }
        }
    }
    else if (nData > pNode->nData)          // 插入到右子树�?br>    {
        pNode->pRight = Insert(nData, pNode->pRight);
        if (Height(pNode->pRight) - Height(pNode->pLeft) == 2)    // AVL树不�q��
        {
            if (nData > pNode->pRight->nData)
            {
                // 插入��C��叛_��树右�? 做单旋�{
                pNode = SingleRotateWithRight(pNode);
            }
            else
            {
                // 插入��C��叛_��树左�? 做双旋�{
                pNode = DoubleRotateWithRight(pNode);
            }
        }
    }

    pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;

    return pNode;
}

/********************************************************************
      pNode                                pNode->pLeft
      /                                             \
pNode->pLeft                      ==>              pNode
           \                                       /
          pNode->pLeft->pRight                   pNode->pLeft->pRight
*********************************************************************/
AVLTree* SingleRotateWithLeft(AVLTree* pNode)
{
    AVLTree* pNode1;

    pNode1 = pNode->pLeft;
    pNode->pLeft = pNode1->pRight;
    pNode1->pRight = pNode;

    // �l�点的位�|�变�? 要更新结点的高度�?br>    pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
    pNode1->nHeight = Max(Height(pNode1->pLeft), pNode->nHeight) + 1;

    return pNode1;
}

/********************************************************************
pNode                                   pNode->pRight
     \                                  /
     pNode->pRight           ==>    pNode
     /                                   \
pNode->pRight->pLeft                     pNode->pRight->pLeft
*********************************************************************/
AVLTree* SingleRotateWithRight(AVLTree* pNode)
{
    AVLTree* pNode1;

    pNode1 = pNode->pRight;
    pNode->pRight = pNode1->pLeft;
    pNode1->pLeft = pNode;

    // �l�点的位�|�变�? 要更新结点的高度�?br>    pNode->nHeight = Max(Height(pNode->pLeft), Height(pNode->pRight)) + 1;
    pNode1->nHeight = Max(Height(pNode1->pRight), pNode->nHeight) + 1;

    return pNode1;
}

AVLTree* DoubleRotateWithLeft(AVLTree* pNode)
{
    pNode->pLeft = SingleRotateWithRight(pNode->pLeft);

    return SingleRotateWithLeft(pNode);
}

AVLTree* DoubleRotateWithRight(AVLTree* pNode)
{
    pNode->pRight = SingleRotateWithLeft(pNode->pRight);

    return SingleRotateWithRight(pNode);
}

// 后序遍历树以删除�?br>void DeleteTree(AVLTree** ppRoot)
{
    if (NULL == ppRoot || NULL == *ppRoot)
        return;

    DeleteTree(&((*ppRoot)->pLeft));
    DeleteTree(&((*ppRoot)->pRight));
    free(*ppRoot);
    *ppRoot = NULL;
}

// 中序遍历打印树的所有结�? 因�ؓ左结�?nbsp;< 父结�?nbsp;< 右结�? 因此打印出来数据的大��是递增�?br>void PrintTree(AVLTree* pRoot)
{
    if (NULL == pRoot)
        return;

    static int n = 0;

    PrintTree(pRoot->pLeft);
    printf("[%d]nData = %d\n", ++n, pRoot->nData);
    PrintTree(pRoot->pRight);
}

周强 2011-05-11 10:25 发表评论

动态规划（三）

周强 — Mon, 04 Apr 2011 05:45:00 GMT

最长公共子序列实现

参考算法导论第208��?br>
#include
#include
#include

void LCS(char *p,char *q)
{
   int lenP,lenQ;
   int *s,*t;
   lenP=strlen(p);
   lenQ=strlen(q);
   int i,j;

   if((s=(int*)malloc(sizeof(int)*(lenP+1)*(lenQ+1)))==NULL)
   {
       perror("malloc error");
       exit(1);
   }

   if((t=(int*)malloc(sizeof(int)*(lenP+1)*(lenQ+1)))==NULL)
   {
       perror("malloc error");
       exit(1);
   }

   for(i=0;i<(lenP+1);i++)
       s[i]=0;
   for(i=0;i<(lenQ+1);i++)
       s[i*(lenP+1)]=0;

   for(i=1;i<(lenQ+1);i++)
   {
       for(j=1;j<(lenP+1);j++)
       {
           if(q[i-1]==p[j-1])
           {
               s[i*(lenP+1)+j]=s[(i-1)*(lenP+1)+j-1]+1;
               t[i*(lenP+1)+j]=3;
           }else if(s[(i-1)*(lenP+1)+j]               s[i*(lenP+1)+j]=s[i*(lenP+1)+j-1];
               t[i*(lenP+1)+j]=1;
           }else{
               s[i*(lenP+1)+j]=s[(i-1)*(lenP+1)+j];
               t[i*(lenP+1)+j]=2;
           }
       }
   }
   /*输出矩阵�l�果*/
   printf("output the result:\n");
   for(i=0;i<(lenQ+1);i++)
   {
       for(j=0;j<(lenP+1);j++)
       {
           printf("%d ",s[i*(lenP+1)+j]);
       }
       printf("\n");
   }

   printf("output the result ��头 1表示向左�Q?表示向上�Q?表示斜向�?\n");
   for(i=0;i<(lenQ+1);i++)
   {
       for(j=0;j<(lenP+1);j++)
       {
           printf("%d ",t[i*(lenP+1)+j]);
       }
       printf("\n");
   }

   i=lenQ;
   j=lenP;
   /*倒序输出LCS*/
   printf("倒序输出LCS\n");
   while(i>1 || j>1)
   {
       if(t[i*(lenP+1)+j]==3)
       {
           printf("%c ",p[j-1]);
           i--;
           j--;
       }else if(t[i*(lenP+1)+j]==2)
       {
           i--;
       }else
           j--;
   }
   printf("\n");
}

int main()
{
   char *p="BDCABA";
   char *q="ABCBDAB";
   LCS(p,q);
}

周强 2011-04-04 13:45 发表评论

动态规�?�?

周强 — Sun, 03 Apr 2011 13:28:00 GMT

矩阵链乘法实玎ͼ��法��D�� P197�Q?br>#include
#include

#define MAX 65536

void printMatrix(int *s,int len,int i,int j)
{
   if(i==j)
       printf("A%d",i+1);
   else{
       printf("(");
       printMatrix(s,len,i,s[i*len+j]);
       printMatrix(s,len,s[i*len+j]+1,j);
       printf(")");
   }

}

void matrixOrder(int p[][2],int len)
{
   int *m,*s;
   int i,j,k;
   if((m=malloc(len*len*sizeof(int)))==NULL)
   {
       perror("malloc error");
       exit(1);
   }

   if((s=malloc(len*len*sizeof(int)))==NULL)
   {
       perror("malloc error");
       exit(1);
   }

   for(i=0;i       m[i*len+i]=0;

   for(i=1;i   {
       for(j=0;j+i       {
           m[j*len+j+i]=MAX;
           for(k=j;k           {
               if((p[j][0]*p[k][1]*p[i+j][1]+m[j*len+k]+m[(k+1)*len+i+j])               {
                   m[j*len+j+i]=p[j][0]*p[k][1]*p[i+j][1]+m[j*len+k]+m[(k+1)*len+i+j];
                   s[j*len+j+i]=k;
               }
           }
       }
   }

   printf("##### then matrix m\n");
   for(i=0;i   {
       for(j=0;j       {
           printf("%d ",m[i*len+j]);
       }
       printf("\n");
   }
   printf("##### the matrix s\n");
   for(i=0;i   {
       for(j=0;j       {
           printf("%d ",s[i*len+j]);
       }
       printf("\n");
   }

    printMatrix(s,len,0,5);
    printf("\n");
}

int main()
{
    int p[6][2]={{30,35},{35,15},{15,5},{5,10},{10,20},{20,25}};
    matrixOrder(p,6);
}

周强 2011-04-03 21:28 发表评论

周强 — Sun, 03 Apr 2011 13:26:00 GMT

动态规划是通过�l�合子问题的解而解��x��个问题�?br>动态规划算法设计可以分�?个步�?br>�Q?�Q�描�q�最优解的结�?br>�Q?�Q�递归定义最优解的�?br>�Q?�Q�按自底向上的方式计��最优解的�?br>�Q?�Q�由计算出的�l�果构造一个最优解

装配�U�调度实�?��法��D��192��?

参考算法导�?�W?5�?br>
#include
#include

int schedule(int a[][6],int t[][5],int e[],int x[])
{

   int f[2][6];
   int l[2][5];
   int totalMin;
   int lastL;
   int i,k;
   f[0][0]=e[0]+a[0][0];
   f[1][0]=e[1]+a[1][0];

   for(i=1;i<6;i++)
   {
       if(f[0][i-1]<(f[1][i-1]+t[1][i-1]))
       {
           f[0][i]=f[0][i-1]+a[0][i];
           l[0][i-1]=1;
       }else{
           f[0][i]=f[1][i-1]+t[1][i-1]+a[0][i];
           l[0][i-1]=2;
       }

       if(f[1][i-1]<(f[0][i-1]+t[0][i-1]))
       {
           f[1][i]=f[1][i-1]+a[1][i];
           l[1][i-1]=2;
       }else{
           f[1][i]=f[0][i-1]+t[0][i-1]+a[1][i];
           l[1][i-1]=1;
       }
   }

   for(i=0;i<2;i++)
   {
       for(k=0;k<6;k++)
       {
           printf("%d ",f[i][k]);
       }
       printf("\n");
   }

   if((x[0]+f[0][5])<(x[1]+f[1][5]))
   {
       totalMin=x[0]+f[0][5];
       lastL=1;
   }else{
       totalMin=x[1]+f[1][5];
       lastL=2;
   }
   printf("totalMin=%d\n",totalMin);

   if(lastL==1)
   {
       printf("S (1,6) ");
       k=0;
   }else{
       printf("S (2,6) ");
       k=1;
   }

   for(i=4;i>=0;i--)
   {
       if(l[k][i]==1)
       {
           printf("S (1, %d) ",i+1);
           k=0;
       }else{
           printf("S (2, %d) ",i+1);
           k=1;
       }
   }
   printf("\n");
}

int main()
{
   int a[2][6]={{7,9,3,4,8,4},{8,5,6,4,5,7}};
   int t[2][5]={{2,3,1,3,4},{2,1,2,2,1}};
   int e[2]={2,4};
   int x[2]={3,2};

   schedule(a,t,e,x);

}

周强 2011-04-03 21:26 发表评论

周强 — Sat, 02 Apr 2011 13:43:00 GMT

/*�U�黑树设计与实现
*参考算法导�?br>*http://m.shnenglu.com/converse/archive/2008/11/10/66530.html

插入时有三种情况�Q�这里只考虑z的父节点是z的祖父节点的左孩子，z的父节点是z的祖父节点的叛_��子对�U�C��一��P��
�Q?�Q?z的叔叔y是红色的�Q�改变颜�?提升x�Q?br>�Q?�Q?z的叔叔y是黑色的�Q�而且z是右孩子�Q�左旋）
�Q?�Q?z的叔叔y是黑色的�Q�而且z是左孩子�Q�右旋加改变颜色�Q?br>
删除时有四种情况�Q�这里只考虑z是z的父节点的左孩子�Q�z是z的父节点的右孩子对称也一��P��
�Q?�Q�x的兄弟w是红色的�Q�左旋加改变颜色�Q?br>�Q?�Q�x的兄弟w是黑色的�Q�而且w的两个孩子都是黑色的�Q�改变颜�Ԍ��提升x)
�Q?�Q�x的兄弟w是黑色的�Q�w的左孩子是红色的�Q�右孩子是黑色的(改变颜色加右�?
�Q?�Q�x的兄弟w是黑色的�Q�而且w的右孩子是红色的�Q�改变颜色加左旋�Q?br>*/

#include
#include
#include

/*定义颜色枚�D�c�d��*/
typedef enum color_t
{
   RED=0,
   BLACK=1
}color_t;

/*定义�l�构�?/
typedef struct rb_node_t
{
   int key;
   color_t color;
   struct rb_node_t *left,*right,*parent;
}rb_node_t;

/* ��试是否为红黑树*/
int isRedBlackTree(rb_node_t *root,int count)
{
   if(root==NULL)
   {
       printf("黑高度�ؓ %d\n",count);
       if(count!=12)/*通过��试该测试用例黑高度�?2�Q�不��h��普遍�?/
       {
           printf("not a redblack tree\n");
           exit(1);
       }
   }else{
       if(root->color==BLACK)
       {
           count++;
       }
       else{
           if((root->left!=NULL &&root->left->color==RED)||
                   (root->right!=NULL && root->right->color==RED))
           {
               printf("child color RED\n");
           }
       }
       isRedBlackTree(root->left,count);
       isRedBlackTree(root->right,count);
   }

}

/*中序打印节点用于��试*/
void midPrint(rb_node_t *root)
{
    if(root!=NULL)
    {
        midPrint(root->left);
        printf("%d ",root->key);
        if(root->color==RED)
            printf("RED ");
        else
            printf("BLACK ");
        midPrint(root->right);
    }
}
/*先序打印节点用于��试*/
void prePrint(rb_node_t *root)
{
    if(root!=NULL)
    {

        printf("%d ",root->key);
        if(root->color==RED)
            printf("RED ");
        else
            printf("BLACK ");
        prePrint(root->left);
        prePrint(root->right);
    }
}

/*创徏节点*/
rb_node_t * createNode(int key)
{
    rb_node_t *newNode;
    if((newNode=malloc(sizeof(rb_node_t)))==NULL)
    {
        printf("malloc error");
        return NULL;
    }
    newNode->color=RED;
    newNode->left=NULL;
    newNode->right=NULL;
    newNode->key=key;
    newNode->parent=NULL;
    return newNode;
}

/*左旋*/
rb_node_t * leftRotate(rb_node_t *root,rb_node_t *node)
{
    rb_node_t *right;
    right=node->right;

    if(node->right=right->left)
    {
        right->left->parent=node;
    }
    right->left=node;
    if(right->parent=node->parent)
    {
        if(node->parent->left==node)
            node->parent->left=right;
        else
            node->parent->right=right;
    }else
        root=right;
    node->parent=right;
    return root;

}

/*��x��*/
rb_node_t *rightRotate(rb_node_t *root,rb_node_t *node)
{
    rb_node_t *left;
    left=node->left;
    if(node->left=left->right)
        left->right->parent=node;
    left->right=node;
    if(left->parent=node->parent)
    {
        if(node->parent->left==node)
            node->parent->left=left;
        else
            node->parent->right=left;
    }else
        root=left;
    node->parent=left;
    return root;
}

/*查找节点�Q�若扑ֈ�则返回该节点�Q�若没找到返回NULL�q�且��父节点保存到save�?/
rb_node_t * rb_search_auxiliary(int key,rb_node_t *root,rb_node_t **save)
{
    rb_node_t *node,*parent;
    node=root;
    parent=NULL;
    while(node)
    {
        parent=node;
        if(node->key            node=node->right;
        else if(node->key>key)
            node=node->left;
        else
            return node;
    }
    if(save)
        *save=parent;
    return NULL;
}

/*查找节点*/
rb_node_t * rb_search(int key,rb_node_t *root)
{
    return rb_search_auxiliary(key,root,NULL);
}

/*插入节点后进行调��_��使其满��U�黑树性质*/
rb_node_t * rb_insert_reblance(rb_node_t *root,rb_node_t *node)
{
    rb_node_t *parent,*uncle,*grandParent,*temp;
    while((parent=node->parent)&&(parent->color==RED))
    {
        grandParent=parent->parent;
        if(parent==grandParent->left)
        {
            uncle=grandParent->right;
            if(uncle!=NULL && uncle->color==RED)
            {
                parent->color=BLACK;
                uncle->color=BLACK;
                grandParent->color=RED;
                node=grandParent;
            }else{
                if(node==parent->right)
                {
                    root=leftRotate(root,parent);
                    temp=parent;
                    parent=node;
                    node=temp;
                }
                //printf("##########\n");
                //print(root);
                //printf("\n");
                parent->color=BLACK;
                grandParent->color=RED;
                root=rightRotate(root,grandParent);

                //printf("##########\n");
            //    print(root);
            //    printf("\n");
            }
        }else{
            uncle=grandParent->left;
            if(uncle!=NULL && uncle->color==RED)
            {
                parent->color=BLACK;
                uncle->color=BLACK;
                grandParent->color=RED;
                node=grandParent;
            }else{
                if(node==parent->left)
                {
                    root=rightRotate(root,parent);
                    temp=parent;
                    parent=node;
                    node=temp;
                }
                parent->color=BLACK;
                grandParent->color=RED;
                root=leftRotate(root,grandParent);

            }
        }
    }
    root->color=BLACK;
    return root;
}

/*�U�黑树插入节�?/
rb_node_t * rb_insert(rb_node_t *root,int key)
{
    rb_node_t *parent,*newNode;
    newNode=createNode(key);

    if(rb_search_auxiliary(key,root,&parent)!=NULL)
    {
        printf("already exixt\n");
        return root;
    }
    if(parent==NULL)
    {
        root=newNode;
    }else{
        newNode->parent=parent;
        if(parent->key            parent->right=newNode;
        else
            parent->left=newNode;
    }
//    print(root);
//    printf("\n");
    root=rb_insert_reblance(root,newNode);
    return root;
}

/*删除黑节点后�q�行调整�Q��其满��红黑树性质*/
rb_node_t *rb_delete_reblance(rb_node_t *root,rb_node_t *node,rb_node_t *parent)
{
    rb_node_t *brother;
    while((node==NULL ||node->color==BLACK)&&((node!=root)))
    {
        if(node==parent->left)
        {
            brother=parent->right;
            if(brother->color==RED)
            {
                brother->color=BLACK;
                parent->color=RED;
                root=leftRotate(root,parent);
                brother=parent->right;
            }
            if((!brother->left || brother->left->color==BLACK)&&
                    (!brother->right || brother->right->color==BLACK))
            {
                brother->color=RED;
                node=parent;
                parent=parent->parent;
            }else{
                if(!brother->right || brother->right->color==BLACK)
                {
                    brother->color=RED;
                    brother->left->color=BLACK;
                    root=rightRotate(root,brother);
                    brother=parent->right;
                }
                brother->color=parent->color;
                parent->color=BLACK;
                brother->right->color=BLACK;
                root=leftRotate(root,parent);
                node=root;
            }

        }else{
            brother=parent->left;
            if(brother->color==RED)
            {
                brother->color=BLACK;
                parent->color=RED;
                root=rightRotate(root,parent);
                brother=parent->left;
            }

            if((!brother->left ||brother->left->color==BLACK) &&
                    (!brother->right ||brother->right->color==BLACK))
            {
                brother->color=RED;
                node=parent;
                parent=parent->parent;
            }else {
                if(!brother->left || brother->left->color==BLACK)
                {
                    brother->color=RED;
                    brother->right->color=BLACK;
                    root=leftRotate(root,brother);
                    brother=parent->left;
                }
                brother->color=parent->color;
                parent->color=BLACK;
                brother->left->color=BLACK;
                root=rightRotate(root,parent);
                node=root;
            }
        }
    }
    node->color=BLACK;
    return root;
}

rb_node_t *rb_delete(rb_node_t *root,int key)
{
    rb_node_t *node,*old,*child,*parent;
    color_t color;
    child=NULL;

    if((node=rb_search(key,root))==NULL)
    {
        printf("not find the node\n");
        return root;
    }

    old=node;

    if(node->left!=NULL && node->right!=NULL)
    {
        node=node->right;
        while(node->left!=NULL)
        {
            node=node->left;
        }
        child=node->right;
        parent=node->parent;
        if(child)
            child->parent=parent;
        if(parent->left==node)
            parent->left=child;
        else
            parent->right=child;

        if(node->parent==old)
        {
            parent=node;
        }
        color=node->color;
        node->left=old->left;
        node->right=old->right;
        node->color=old->color;
        node->parent=old->parent;
        if(old->parent)
        {
            if(old->parent->left==old)
                old->parent->left=node;
            else
                old->parent->right=node;
        }else
            root=node;
        old->left->parent=node;
        if(old->right)
            old->right->parent=node;
        free(old);
    }else{
        parent=node->parent;
        if(node->left!=NULL)
            child=node->left;
        else
            child=node->right;
        if(child)
            child->parent=parent;

        if(parent)
        {
            if(parent->left==node)
                parent->left=child;
            else
                parent->right=child;
        }else
            root=child;
        color=node->color;
        free(node);
    }
    if(color==BLACK)
        rb_delete_reblance(root,child,parent);
    return root;
}

int main()
{
    int i,count=900000;
    int key;
    rb_node_t *root=NULL,*node=NULL;

    srand(time(NULL));
    int num=0;
    for(i=1;i    {
        key=rand()%count;
        if(root=rb_insert(root,key))
        {
            printf("[i=%d] insert key %d,success!\n",i,key);
        }else{
            printf("[i=%d] insert key %d error!\n",i,key);
            exit(1);
        }
//        printf("当前树中节点\n");
//        midPrint(root);
//        printf("\n");

        if((node=rb_search(key,root)))
        {
            printf("[i=%d] search key %d success!\n",i,key);
        }else{

            printf("[i=%d] search key %d error!\n",i,key);
            exit(1);
        }

        if(!(i%10))
        {

        //    prePrint(root);
            if((root=rb_delete(root,key)))
            {
                printf("[i=%d] delete key %d success\n",i,key);
            }else
            {
                printf("[i=%d] erase key %d error\n",i,key);
                exit(1);
            }

        }

    }

    /*printf("#########�U�序遍历\n");
    prePrint(root);
    printf("\n");

    printf("$$$$$$$$$中序遍历\n");
    midPrint(root);
    printf("\n");
    */
    printf("the root color %d\n",root->color);
    isRedBlackTree(root,0);

    return 0;
}

周强 2011-04-02 21:43 发表评论

周强 — Mon, 28 Mar 2011 08:15:00 GMT

#include
#include
#include

/*�l�构体节�?/
typedef struct _node{
   int key;
   struct _node *left;
   struct _node *right;
   struct _node *parent;
}node;

/*插入节点*/
void insert(node *root,node *toInsert)
{
   node *p,*q;
   p=root;
   q=NULL;
   if(toInsert==NULL || root==NULL)
   {
       return;
   }

   while(p!=NULL)
   {
       q=p;/*记录父节�?/
       if(toInsert->keykey)
       {
           p=p->left;
       }else{
           p=p->right;
       }
   }
   if(toInsert->keykey)
   {
       q->left=toInsert;
   }else{
       q->right=toInsert;
   }
   toInsert->parent=q;
   toInsert->left=NULL;
   toInsert->right=NULL;
}

/*递归中序遍历根节�?/
void middleSearch(node *root)
{
   if(root!=NULL)
   {
       middleSearch(root->left);
       printf("%d\t",root->key);
       middleSearch(root->right);
   }
}
/*先序遍历*/
void preSearch(node *root)
{
   if(root!=NULL)
   {
       printf("%d\t",root->key);
       preSearch(root->left);
       preSearch(root->right);
   }
}

/*查找�q�回节点关键字�ؓkey的节�?/
node* search(node *root,int key)
{
   node *p=root;
   while(p!=NULL)
   {
       if(keykey)
       {
           p=p->left;
       }else if(key>p->key)
       {
           p=p->right;
       }else
           break;
   }
   return p;
}

/*查找二叉树最��?/
node *minimun(node *root)
{
   node *p=root;
   if(p==NULL)
       return p;
   while(p->left!=NULL)
       p=p->left;
   printf("min %d\n",p->key);
   return p;
}

/*查找二叉树最大�?/
node *maximun(node *root)
{
   node *p=root;
   if(p==NULL)
       return;
   while(p->right!=NULL)
       p=p->right;
   printf("max %d\n",p->key);
   return p;
}
/*找节点后�l?/
node* successor(node *x)
{
   node *p;
   if(NULL==x)
       return x;
   if(x->right!=NULL)
       return minimun(x->right);
   p=x->parent;
   while(p!=NULL && p->right==x)
   {
       x=p;
       p=p->parent;
   }
   return p;
}

/*删除节点*/
void delete(node *root,node *toDelete)
{
   node *p,*q;
   int key;
   if(root==NULL || toDelete==NULL)
       return ;
   p=toDelete->parent;

   /*�W�一�U�情况，要删除的节点的左叛_��树都为空*/
   if(toDelete->left ==NULL && toDelete->right ==NULL)
   {
       if(p==NULL)/*要删除的是根节点*/
       {
           free(toDelete);
           return;
       }
       if(p->left==toDelete)
       {
           p->left=NULL;
       }else
           p->right=NULL;
       free(toDelete);

   }

   /*�W�二�U�情况，要删除的左子树�ؓ�I�，叛_��树不为空*/
   else if(toDelete->left==NULL)
   {
       if(p==NULL)
       {
           q=root->right;
           root->key=q->key;
           root->left=q->left;
           root->right=q->right;

           free(q);
           return;
       }
       else if(p->left==toDelete)
       {
           p->left=toDelete->right;
       }else
           p->right=toDelete->right;
       toDelete->right->parent=p;
       free(toDelete);
   }

   /* �W�三�U�情况，要删除的叛_��树�ؓ�I�，左子树不为空*/
   else if(toDelete->right==NULL)
   {
       if(p==NULL)
       {
           q=root->left;
           root->key=q->key;
           root->left=q->left;
           root->right=q->right;
           root->parent=NULL;
           free(q);
           return;
       }
       else if(p->left==toDelete)
       {
           p->left=toDelete->left;
       }else
           p->right=toDelete->right;
       toDelete->parent=p;
       free(toDelete);
   }

   /* �W�四�U�情况，要删除的左右子树都不为空*/
   else{
           q=successor(toDelete);
           key=q->key;
           delete(root,q);
           toDelete->key=key;
   }
}

int main()
{
   node *root;

   int a[12]={15,5,3,12,10,13,6,7,16,20,18,23};
   node *toInsert;
   node *x,*y;
   int i;
   /*创徏头节�?/
   if((root=(node*)malloc(sizeof(node)))==NULL)
   {
       perror("malloc error");
       exit(1);
   }
   root->key=a[0];
   /*插入节点*/
   for(i=1;i<12;i++)
   {
       if((toInsert=(node*)malloc(sizeof(node)))==NULL)
       {
           perror("malloc error");
           exit(1);
       }
       toInsert->key=a[i];
       insert(root,toInsert);
   }

   /*中序遍历*/
   middleSearch(root);
   printf("\n");
   /*先序遍历*/
   preSearch(root);
   printf("\n");

   /*最大�?/
   maximun(root);
   /*最��?/
   minimun(root);

   /*查找关键字节点及其前�?/
   x=search(root,6);
   y=successor(x);
   if(y!=NULL)
       printf("节点 6 后驱 %d\n",y->key);

   x=search(root,3);
   y=successor(x);
   if(y!=NULL)
       printf("节点 3 后驱 %d\n",y->key);

   x=search(root,13);
   y=successor(x);
   if(y!=NULL)
       printf("节点 13 后驱 %d\n",y->key);

   x=search(root,23);
   y=successor(x);
   if(y!=NULL)
       printf("节点 23 后驱 %d\n",y->key);

   /*删除节点*/
   printf("before delete the node\n");
   x=search(root,13);

   delete(root,x);
   printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    if((toInsert=(node*)malloc(sizeof(node)))==NULL)
    {
        perror("malloc error");
        exit(1);
    }
    toInsert->key=13;
    insert(root,toInsert);
    printf("\n中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    printf("\nbefore delete the node\n");
    x=search(root,16);
    delete(root,x);
    printf("\nafter delete the node\n");
    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    if((toInsert=(node*)malloc(sizeof(node)))==NULL)
    {
        perror("malloc error");
        exit(1);
    }
    toInsert->key=16;
    insert(root,toInsert);
    printf("\n中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    printf("\nbefore delete the node\n");
    x=search(root,5);
    delete(root,x);
    printf("\nafter delete the node\n");
    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);
    if((toInsert=(node*)malloc(sizeof(node)))==NULL)
    {
        perror("malloc error");
        exit(1);
    }
    toInsert->key=5;
    insert(root,toInsert);

    printf("\n中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    printf("\nbefore delete the node\n");
    x=search(root,15);

    delete(root,x);
    printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);

    printf("\n");

    printf("before delete the node\n");
    x=search(root,16);

    delete(root,x);
    printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);
    printf("\n");

    printf("before delete the node\n");
    x=search(root,18);

    delete(root,x);
    printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);
    printf("\n");

    printf("before delete the node\n");
    x=search(root,20);

    delete(root,x);
    printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);
    printf("\n");

    printf("before delete the node\n");
    x=search(root,23);

    delete(root,x);
    printf("\nafter delete the node\n");

    printf("中序遍历\n");
    middleSearch(root);
    printf("\n先序遍历\n");
    preSearch(root);
    printf("\n");
}

周强 2011-03-28 16:15 发表评论

周强 — Tue, 22 Mar 2011 02:28:00 GMT

/*快速排序算法实玎ͼ�快序排序��法最坏复杂度为O(n^2),�q�_��复杂度�ؓO(nlgn),而且该比例因子比较少*/

#include
#include

void print(int A[],int len)
{
   int i;
   for(i=0;i   {
       printf("%d ",A[i]);
   }
   printf("\n");
}

int quickPart(int A[],int begin,int end)
{
   int key,i,j,temp;
   key=A[end-1];
   i=begin-1;
   for(j=begin;j   {
       if(A[j]       {
           i++;
           temp=A[i];
           A[i]=A[j];
           A[j]=temp;
       }
   }
   i++;
   temp=A[i];
   A[i]=key;
   A[end-1]=temp;
   return (i);
}

void quickSort(int A[],int begin,int end)
{
   int q;
   if(end>begin)
   {
       q=quickPart(A,begin,end);
       quickSort(A,begin,q);
       quickSort(A,q+1,end);
   }
}

int main()
{
   int A[8]={2,8,7,1,3,5,6,4};
   quickSort(A,0,8);
   printf("after sort\n");
   print(A,8);
}

周强 2011-03-22 10:28 发表评论

堆排序c语言实现

周强 — Mon, 21 Mar 2011 13:48:00 GMT

/*堆排�?实现�Q�算法复杂度O(nlgn)*/
#include
#include

/*假设节点i的左叛_��树都是最大堆�Q�操作��节点i的子树变成最大堆*/
void maxHeap(int A[],int len,int i)
{
    int l,r,large,temp;
    l=2*i;
    r=2*i+1;
    large=i;
    if(l    {
        if(A[l]>A[i])
        {
            large=l;
        }
    }
    if(r    {
        if(A[r]>A[large])
        {
            large=r;
        }
    }

    if(large!=i)
    {
        temp=A[large];
        A[large]=A[i];
        A[i]=temp;
        maxHeap(A,len,large);
    }
}

/*建立大根�?/
void buildMaxHeap(int A[],int len)
{
    int i;
    for(i=len/2-1;i>=0;i--)
        maxHeap(A,len,i);
}

/*堆排�?/
void maxHeapSort(int A[],int len)
{
    int i,temp;
    buildMaxHeap(A,len);
    printf("建立大跟堆\n");
    for(i=0;i        printf("%d ",A[i]);
    printf("\n");

    for(i=len;i>1;i--)
    {
        temp=A[0];
        A[0]=A[i-1];
        A[i-1]=temp;
        printf("%d ",A[i-1]);
        buildMaxHeap(A,i-1);
    }
    printf("\n");
}

/*��试堆排�?/
int main()
{
    int i;
    int A[11]={4,1,3,2,16,9,10,14,8,7,6};
    maxHeapSort(A,11);

    for(i=0;i<11;i++)
    {
        printf("%d ",A[i]);
    }
    printf("\n");
}

周强 2011-03-21 21:48 发表评论

周强 — Tue, 15 Mar 2011 08:15:00 GMT

今天复习了下一些常见的排序��法,�q�用c语言实现了下。代码如下：
#include
#include

#define MAX 65536 /*用于归�ƈ排序中的哨兵*/

/*��单插入排�?旉��复杂度�ؓo(n2),�E�_��排序�Q�适合已经排好序的*/
void insertSort(int arr[],int len)
{
    int i,j;
    int key;
    for(i=1;i    {
        key=arr[i];
        for(j=i-1;j>=0;j--)
        {
            if(arr[j]>key)
                arr[j+1]=arr[j];
            else
                break;
        }
        arr[j+1]=key;
    }
}

/*选择排序�Q�时间复杂度为o(n2),不稳定排序，适合规模比较��的*/
void selectSort(int arr[],int len)
{
    int i,j,temp;
    for(i=0;i    {
        for(j=i+1;j        {
            if(arr[i]>arr[j])
            {
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
}

/*冒��排序�Q�时间复杂度为o(n2),�E�_��排序�Q�适合规模比较��的*/
void bubbleSort(int arr[],int len)
{
    int i,j,temp;
    for(i=0;i    {
        for(j=0;j        {
            if(arr[j]>arr[j+1])
            {
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}

/*合�ƈ�Q�归�qӞ��排序,旉��复杂度�ؓo(nlogn),�E�_��排序�Q�适合规模比较大的排序*/
void merge(int arr[],int p,int q,int r)
{
    int *A,*B;
    int n1,n2,i,j,k;
    n1=q-p+1;
    n2=r-q;
    if((A=(int*)malloc((n1+1)*sizeof(int)))==NULL)
    {
        perror("malloc error");
        exit(1);
    }
    if((B=(int*)malloc((n2+1)*sizeof(int)))==NULL)
    {
        perror("malloc error");
        exit(1);
    }
    for(i=0;i    {
        A[i]=arr[p+i];
    }
    A[i]=MAX;
    for(i=0;i    {
        B[i]=arr[q+i+1];
    }
    B[i]=MAX;
    i=0;j=0;
    for(k=p;k<=r;k++)
    {
        if(A[i]>B[j])
        {
            arr[k]=B[j];
            j++;
        }else{
            arr[k]=A[i];
            i++;
        }
    }
}

void mergeSort(int arr[],int begin,int end)
{
    int mid;
    if(begin    {
        mid=(begin+end)/2;
        mergeSort(arr,begin,mid);
        mergeSort(arr,mid+1,end);
        merge(arr,begin,mid,end);
    }
}

int main()
{
    int a[8]={5,2,4,7,1,3,2,6};
    int b[8]={5,2,4,7,1,3,2,6};
    int c[8]={5,2,4,7,1,3,2,6};
    int d[8]={5,2,4,7,1,3,2,6};

    int i;
    /*��试插入排序*/
    insertSort(a,8);
    printf("after 插入排序\n");
    for(i=0;i<8;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");

    /*��试选择排序*/
    selectSort(b,8);
    printf("after 选择排序\n");
    for(i=0;i<8;i++)
    {
        printf("%d ",b[i]);
    }
    printf("\n");

    /*��试冒��排序*/
    bubbleSort(c,8);
    printf("after 冒��排序\n");
    for(i=0;i<8;i++)
    {
        printf("%d ",c[i]);
    }
    printf("\n");

    /*��试归�ƈ排序*/
    mergeSort(d,0,7);

    printf("after 归�ƈ排序\n");
    for(i=0;i<8;i++)
    {
        printf("%d ",d[i]);
    }
    printf("\n");
}

周强 2011-03-15 16:15 发表评论

KMP��法实现

周强 — Wed, 02 Mar 2011 04:23:00 GMT

#include
#include
#include

/*naive string-matching algorithm,T为原始字�W�串�Q�P为需要匹配的字符�?/
void naiveMatch(char *T,char *P)
{
    int lenT,lenP,i,j;
    lenT=strlen(T);
    lenP=strlen(P);
    if(lenT    {
        perror("input error");
        return ;
    }
    for(i=0;i<(lenT-lenP+1);i++)
    {
        for(j=0;j        {
            if(T[i+j]!=P[j])
                break;
        }
        if(j==lenP)
            printf("string match at place %d\n",i);
    }
}

/*kmp预处理需要的匚w��?/
void getNext(char *p,int next[])
{
    int len,i,j;
    len=strlen(p);
    next[0]=0;
    for(i=1;i    {
        j=next[i-1];
        while((p[i-1]!=p[j-1])&&(j!=0))
        {
            j=next[j-1];
//            printf("j= %d\n",j);
        }
        next[i]=j+1;
        printf("next[i]=%d\n",next[i]);
    }
}

/*kmp字符串匹配算�?/
void kmp(char *t,char *p,int next[])
{
    int lent,lenp,i,j;
    lent=strlen(t);
    lenp=strlen(p);
    i=0;
    j=0;
    while(i<(lent))
    {
        if((j==-1)||(t[i]==p[j]))
        {
            i++;
            j++;

//            printf("i=%d,j=%d\n",i,j);
        }
        else
        {

//            printf("in else i=%d,j=%d\n",i,j);
            j=next[j]-1;
        }
        if(j==(lenp))
        {
            printf("match at place %d\n",i-lenp);
        }
    }
}

int main()
{
    char p[10]="0001";
    char t[20]="000010001010001";
    naiveMatch(t,p);/*��试普通字�W�串匚w��法*/
    char p1[10]="abaabcac";
    char t1[20]="acabaabaabcacaabc";
    int len=strlen(p1);
    int *next;
    next=(int*)malloc(sizeof(int)*len);
    getNext(p1,next);
    kmp(t1,p1,next);/*��试kmp��法*/

    getNext(p,next);
    kmp(t,p,next);/*��试kmp��法*/
}

周强 2011-03-02 12:23 发表评论