精品久久8x国产免费观看,久久精品人人做人人爽电影蜜月,久久久一本精品99久久精品88

归�ƈ排序

Yu_ — Thu, 13 Oct 2011 11:34:00 GMT

摘要: 归�ƈ排序�Q�Merge sort�Q�是建立在归�q�操作上的一�U�有效的排序��法�Q�该��法是采用分��L��?
　　甌��I�间�Q��其大��ؓ两个已经排序序列之和�Q�该�I�间用来存放合�ƈ后的序列
　　讑֮�两个指针�Q�最初位�|�分别�ؓ两个已经排序序列的�v始位�|?
　　比较两个指针所指向的元素，选择相对��的元素攑օ�到合�q�空��_��q�移动指针到下一位置
　　重复步骤3直到某一指针辑ֈ�序列��? 阅读全文

Yu_ 2011-10-13 19:34 发表评论

B-树及B�Q�树

Yu_ — Wed, 05 Oct 2011 11:09:00 GMT

1、B树的定义
    B树是一�U��^衡的多分树（m叉树�Q�，通常我们说m阶的B树，它必��L��_��下条�Ӟ��
    �Q?�Q�每个结点至多有m个子�l�点�Q?br />    �Q?�Q�若根结点不是叶子结点，则至��有两棵子树�Q?/span>
    �Q?�Q�所有的叶结点在同一层；
    �Q?�Q�有k个子�l�点的非根结�Ҏ��好包含k-1个关键码�?/p>

2、B-树数据结�?/font>
#define M 4        //B-树的�Ӟ��暂设�?
#define false 0
#define true 1

typedef struct BTNode
{
    int                keynum;            //节点中关键字个数�Q�即节点的大��?/span>
    struct BTNode    *parent;        //指向双亲�l�点
    int                key[M+1];        //关键字向量，0号单元未�?/span>
    struct BTNode    *son[M+1];        //子树指针向量
    //Record        *recptr[M+1];    //记录指针向量�Q?号单元未�?文�g中��?
}BTNode, *BTree;        //B-树节点和B-树的�c�d��

typedef struct
{
    BTNode            *pt;            //指向扑ֈ�的节�?/span>
    int pos; //1...m,在节点中的关键字序号
    int                tag;            //1:查找成功�Q?:查找��p�|
}Result;        //B-树的查找�l�果�c�d��

//初始�?/span>
void init_BTree(BTree &root)
{
    root=NULL;
}

2、B树的查找
B树上的查找是一个顺指针查找�l�点和在�l�点内的关键码中查找交叉�q�行的过�E��?span style="color: red">从根�l�点开�?/span>�Q�在�l�点包含的关键码中查扄��定的关键码，扑ֈ�则查找成功；否则��定�l�定关键码可能在的子树，重复上面的操作，直到查找成功或者指针�ؓ�I�Zؓ止�?
下图昄��了在B树中查找关键�?1的过�E��?

int search(BTree &p,int key)
{
    int j;
    for(j=1; j<=p->keynum; j++)
        if(p->key[j] > key)
        {
            break;
        }
    return j-1;        //应该插入的位�|�的前一�?/span>
}
Result searchBtree(BTree &root, int key)
{
    //在m阶B树t上查扑օ�键码key�Q�反�?pt,i,tag)�?br />    //若查找成功，则特征值tag=1�Q�指针pt所指结点中�W�i个关键码�{�于key�Q?br />    //否则�Q�特征值tag=0,�{�于key的关键码记录,应插入在指针pt所指结点中�W�i个和�W�i+1个关键码之间
    int found=false;
    int i;
    BTree p=root,father=NULL;    //初始化，p指向待查节点�Q�q指向p的双�?/span>
    Result    result;        //SearchBTree函数�q�回�?/span>

    while(p && !found)
    {
        i=search(p,key);    //p->node[i].key≤Knode[i+1].key
        if(i>0 && p->key[i]==key)
        {
            found=true;        //扑ֈ�待查关键�?/span>
        }
        else
        {
            father=p;
            p=p->son[i];
        }
    }
    result.pos=i+1;        //pos是插入的位置,��C��?
    if(found)    //查找成功
    {
        result.pt=p;
        result.tag=1;
    }
    else    //查找不成功，�q�回key的插入位�|�i
    {
        result.pt=father;
        result.tag=0;
    }
    return result;
}//SearchBTree

3、B树的插入
首先是在恰当的叶子结点中��d��关键码，如果该结点中关键码不��过m-1个，则插入成功。否则要把这个结点分裂�ؓ两个。�ƈ把中间的一个关键码拿出来插到结点的父结炚w��厅R��父�l�点也可能是满的�Q�就需要再分裂�Q�再往上插。最坏的情况�Q�这个过�E�可能一直传到根�Q�如果需要分裂根�Q�由于根是没有父�l�点的，�q�时��徏立一个新的根�l�点。插入可能导致B树朝着根的方向生长�?nbsp;

B-树的生成从空树开始，逐个插入关键字而得。关键字的个数必��至��ؓ[m/2]-1�Q�每�ơ插入��d��最底层某个�l�端�l�点��d��一个关键字�Q�如果该�l�点关键字个数小于m-1则直接插入，如果发现新插入关键字后，关键字��L��过m-1个则�l�点需要分裂，做法如下�Q?

　　(a)假设�l�点p中已�l�含有m-1个关键字�Q�再插入一个关键字之后(插入总要保持关键字数�l�的大小有序�Q�从��到大排好序)�Q�可以将p分裂为p和p’�Q�其中p含有的信息�ؓ[m/2]-1([m]表示大于m的最��整�?�Q�p’含有的信息�ؓm-[m/2] ([m]表示大于m的最��整�?。然后将关键字K[m/2]和指向p’的指针则一��h��入到p的双亲结点中厅R�?

　　(b)��查双亲结点，如果双亲�l�点出现(a)的情况，则回到步骤a�l�箋执行。直到插入满��x��件�ؓ止，树的深度增加�q�程是随着插入而自下而上生长的过�E��?br /> 下图昄��了在B树中插入关键�?3的过�E��?

void split(BTree &q, int s, BTree &ap)
{
    // ��结点q分裂成两个结点，前一半保留，后一半移入新生结点ap
    int i;
    cout<<"分裂!"<<" "<<q->key[s]<<endl;
    ap=(BTree)malloc(sizeof(BTNode));        //生成新结点ap
    ap->son[0] = q->son[s];            //原来�l�点中间位置关键字相应指针指向的子树攑ֈ�新生成结点的0��子树中�?/span>
    for(i=s+1;i<=M;i++)        //后一半移入ap
    {
        ap->key[i-s]=q->key[i];
        ap->son[i-s]=q->son[i];
    }//for
    ap->keynum=M-s;
    ap->parent=q->parent;
    q->keynum=s-1;        //q的前一半保留，修改keynum
}//split

void NewRoot(BTree &root, int x, BTree &ap)        //生成新的根节�?/span>
{
    //生成含信�?root,r,ap)的新的根�l�点*root�Q�原root和ap为子树指�?/span>
    BTree p;
    p=(BTree)malloc(sizeof(BTNode));
    if(root)    //如果原来的树不是�I�树
        root->parent=p;                    //�q�来的根的双亲指针指向新�?/span>
    p->son[0]=root;                        //新根的第一个孩子节�Ҏ��原来的根节点
    root=p;        //root指向新根
    root->parent=NULL;                    //新根的双亲是�I�指�?/span>
    root->keynum=1;
    root->key[1]=x;                        //新根的第一个关键字��是前面分裂出来的关键字
    root->son[1]=ap;                    //新根的第二个孩子节点是原来的根中分裂出来的节�?/span>
    if(ap)        //如果原来的树不是�I�树
        ap->parent=root;                //原来的根中分裂出来的节点的双亲指针指向新�?/span>
}//NewRoot

void insert(BTree &q, int i, int key, BTree &ap)    //插入
{
    int j;
    for(j=q->keynum; j>=i; j--)
    {
        q->key[j+1]=q->key[j];
    }
    q->key[i]=key;
    for(j=q->keynum; j>=i; j--)
    {
        q->son[j+1]=q->son[j];
    }
    q->son[i]=ap;
    q->keynum++;
}//insert
void insertBtree(BTree &root, int key, BTree &q, int i)
{
    //在B-树T上节点q的key[i]和key[i+1]之间插入关键字key
    //若引赯��点过大，则沿双亲链进行必要的节点分裂整理�Q��T仍是M阶的B-�?/span>
    BTree ap=NULL;
    int x=key;
    int finished = false;
    int s;
    while(q && !finished)
    {
        insert(q, i, x, ap);    //��key和ap分别插入到q->key[i+1]和q->son[i+1]
        if(q->keynum <    M)
            finished = true;    //插入完成
        else
        {    //分裂�l�点*q
            s=ceil(M/2);
            x=q->key[s];
            split(q, s, ap);    //��q->key[s+1...M],q->son[s...M]和q->recptr[s+1...M]�U�d��到新节点*ap
            q=q->parent;
            if(q)
                i=search(q,x)+1;        //在双亲结�?q中去查找x的插入位�|?��C��?�Q�因为search()�q�回的是插入位置的前一�?/span>
        }//else
    }//while
    if(!finished)                //root是空�?参数q初��gؓNULL)或者根节点已分裂�ؓ节点*q�?ap
        NewRoot(root, x, ap);    //生成含信�?root,x,ap)的新的根节点*root�Q�原root和ap为子树指�?/span>
}//insertBtree

void SearchInsertBTree(BTree &root,int key)//搜烦插入
{
    //在m阶B�?t上结�?q的key[i],key[i+1]之间插入关键码key
    //若引��L��点过大，则沿双亲链进行必要的�l�点分裂调整�Q��*t仍�ؓm阶B�?/span>
    Result    rs;
    rs = searchBtree(root,key);
    if(!rs.tag)    //tag=0查找不成功，插入
    {
        cout<<"树中没有相同的节点，插入!"<<endl;
        insertBtree(root, key, rs.pt, rs.pos);    //在B-树T上节点re.pt的key[i]和key[i+1]之间插入关键字key
    }
    else
    {
        cout<<"树中已有相同的节�?"<<endl;
    }
}//InserBTree

4、B树的删除
B树中的删除操作与插入操作�c�M��Q�但要稍微复杂些。如果删除的关键码不在叶�l�点层，则先把此关键码与它在B树里的后�l�对换位�|�，然后再删除该关键码。如果删除的关键码在叶结点层�Q�则把它从它所在的�l�点里去掉，�q�可能导致此�l�点所包含的关键码的个数小�?-1。这�U�情况下�Q�考察该结点的左或叛_��弟，从兄弟结点移若干个关键码到该�l�点中来(�q�也涉及到它们的父结点中的一个关键码要做相应变化)�Q��两个�l�点所含关键码个数基本相同。只有在兄弟�l�点的关键码个数也很��，刚好�{�于 -1�Ӟ��q�个�U�d��不能�q�行。这�U�情况下�Q�要把将删除关键码的�l�点�Q�它的兄弟结点及它们的父�l�点中的一个关键码合�ƈ��Z��个结炏V�?

B+�?/strong>
　B+树是应文件系�l�所需而出的一�U?a target="_blank">B-�?/font>的变型树。一��m阶的B+树和m阶的B-树的差异在于�Q?

　　1.有n��子树的�l�点中含有n个关键字�?

　　2.所有的叶子�l�点中包含了全部关键字的信息�Q�及指向含这些关键字记录的指针，且叶子结�Ҏ��w�依关键字的大小自小而大��序链接�?

　　3.所有的非终端结点可以看成是索引部分�Q�结点中仅含其子树（根结点）中的最大（或最��）关键字�?

　　通常在B+树上有两个头指针�Q�一个指向根�l�点�Q�一个指向关键字最��的叶子�l�点�?br />

1、B+树的查找

　　对B+树可以进行两�U�查找运��：

　　1.从最��关键字起顺序查找；

　　2.从根�l�点开始，�q�行随机查找�?

　　在查找时�Q�若非终端结点上的剧�l�机�{�于�l�定��|��q�不�l�止�Q�而是�l�箋向下直到叶子�l�点。因此，在B+树中�Q�不��查找成功与否，每次查找都是��C��一条从根到叶子�l�点的�\径。其余同B-树的查找�c�M��?

2、B+树的插入

　　m阶B树的插入操作在叶子结点上�q�行�Q�假设要插入关键值a�Q�找到叶子结点后插入a�Q�做如下��法判别�Q?

　　①如果当前�l�点是根�l�点�q�且插入后结点关键字数目��于�{�于m�Q�则��法�l�束�Q?

　　②如果当前�l�点是非根结点�ƈ且插入后�l�点关键字数目小于等于m�Q�则判断若a是新索引值时转步�?#9315;后结束，若a不是新烦引值则直接�l�束�Q?

　　③如果插入后关键字数目大于m(阶数)�Q�则�l�点先分裂成两个�l�点X和Y�Q��ƈ且他们各自所含的关键字个数分别�ؓ�Q�u=大于(m+1)/2的最��整敎ͼ�v=��于(m+1)/2的最大整敎ͼ�

　　�׃��索引��g��于结点的最左端或者最右端�Q�不妨假讄��引��g��于结�Ҏ��右端�Q�有如下操作�Q?

　　如果当前分裂成的X和Y�l�点原来所属的�l�点是根�l�点�Q�则从X和Y中取出烦引的关键字，��这两个关键字组成新的根�l�点�Q��ƈ且这个根�l�点指向X和Y�Q�算法结束；

　　如果当前分裂成的X和Y�l�点原来所属的�l�点是非根结点，依据假设条�g判断�Q�如果a成�ؓY的新索引��|��则�{步骤④得到Y的双亲结点P�Q�如果a不是Y�l�点的新索引��|��则求出X和Y�l�点的双亲结点P�Q�然后提取X�l�点中的新烦引值a’�Q�在P中插入关键字a’�Q�从P开始，�l�箋�q�行插入��法�Q?

　　④提取�l�点原来的烦引值b�Q�自��向下，先判断根是否含有b�Q�是则需要先��b替换为a�Q�然后从根结点开始，记录�l�点地址P�Q�判断P的孩子是否含有烦引值b而不含有索引值a�Q�是则先��孩子结点中的b替换为a�Q�然后将P的孩子的地址赋值给P�Q��l�搜索，直到发现P的孩子中已经含有a值时�Q�停止搜索，�q�回地址P�?

3、B+树的删除

　　B+树的删除也仅在叶子结点进行，当叶子结点中的最大关键字被删除时�Q�其在非�l�端�l�点中的值可以作��Z��?#8220;分界关键�?#8221;存在。若因删除而�ɾl�点中关键字的个数少于m/2 �Q�m/2�l�果�?a target="_blank">上界�Q�如5/2�l�果�?�Q�时�Q�其和兄弟结点的合�ƈ�q�程亦和B-树类伹{�?

　　另外的看法，当作补充和丰富吧。B树，B-树和B+树是三个不同的概��c�?br />
B�?/strong>

　　二叉排序树（Binary Sort Tree�Q�又�U�C��叉查找树�Q�也叫B树�?

　　它或者是一��늩�树；或者是��h��下列性质的二叉树�Q?

　　(1)若左子树不空�Q�则左子树上所有结点的值均��于左子树所在树的根�l�点的��|��

　　(2)若右子树不空�Q�则叛_��树上所有结点的值均大于叛_��树所在树的根�l�点的��|��

　　(3)左、右子树也分别�ؓ二叉排序树；

1、二叉排序树�Q�B树）的查找：

　　旉��复杂度与树的深度的有兟�?

　　步骤�Q�若根结点的关键字值等于查扄��关键字，成功�?

　　否则�Q�若��于根结点的关键字��|��递归查左子树�?

　　若大于根�l�点的关键字��|��递归查右子树�?

　　若子树�ؓ�I�，查找不成功�?

2、二叉排序树�Q�B树）的插入和删除�Q?/span>

　　二叉排序树是一�U�动态树表。其特点是：树的�l�构通常不是一�ơ生成的�Q�而是在查找过�E�中�Q�当树中不存在关键字�{�于�l�定值的节点时再�q�行插入。新插入的结点一定是一个新��d��的叶子节点，�q�且是查找不成功时查找�\径上讉K��的最后一个结点的左孩子或叛_��子结炏V�?

　　插入��法�Q?

　　首先执行查找��法�Q�找��插结点的父亲�l�点�?

　　判断被插�l�点是其父亲�l�点的左儿子�q�是叛_��子。将被插�l�点作�ؓ叶子�l�点插入�?

　　若二叉树为空。则首先单独生成根结炏V�?

　　注意�Q�新插入的结�Ҏ��L��叶子�l�点�Q�所以算法复杂度是O(h)�?

　　删除��法�Q?

　　如果删除的结�Ҏ��有孩子，则删除后��法�l�束�Q?

　　如果删除的结点只有一个孩子，则删除后该孩子取代被删除�l�点的位�|�；

　　如果删除的结�Ҏ��两个孩子�Q�则选择叛_��子�ؓ根的树，它的左子树中�Q�值最��的点作为新的根�Q�同时在该最��值处开始，执行删除��法�Q�如此��l�到删除��法的前两种情况�Ӟ��删除��法�l�束�?

　　B树用途：查找信息快速，但是随着查找深度的增加，会媄响查扄��效率�Q�所以，通常会��用��^衡二叉树的��^衡算法来�q�行动态��^衡�?/p>

Yu_ 2011-10-05 19:09 发表评论

�q��二叉�?�Q�AVL树）

Yu_ — Mon, 03 Oct 2011 17:09:00 GMT
     摘要: 1、��^衡二叉树它是一��늩�树或它的左右两个子树的高度差的绝对��g��过1�Q��ƈ且左右两个子树都是一��^衡二叉树。　如图�Q?、动态��^衡技�?动态��^衡技术Adelson-Velskii �?Landis 提出了一个动态地保持二叉排序树��^衡的�Ҏ��Q�其基本思想是：　　在构造二叉排序树的过�E�中�Q�每当插入一个结�Ҏ��Q�首先检查是否因插入而破坏了树的�q��性，如果是因插入�l�点而破坏了树的�q��性，则找出其中最��不�q��子树�Q?..  阅读全文

Yu_ 2011-10-04 01:09 发表评论

Yu_ — Mon, 03 Oct 2011 03:00:00 GMT
1、顺序查找：�Q�有两种�Ҏ��Q?br />在一个已知无(或有序）序队列中扑և�与给定关键字相同的数的具体位�|��?br />①、让关键字与队列中的��g��W�一个开�?/span>逐个比较�Q�直到找��Z��l�定关键字相同的��gؓ止�?
int SeqSearch(Seqlist R�Q�KeyType K)
    {
      //在顺序表R[1..n]中顺序查扑օ�键字为K的结点，
      //成功时返回找到的�l�点位置�Q�失败时�q�回-1
      int i�Q?br />      for(i=0;i      {
           if(R[i].key==K) return i;
       }
      return -1�Q?nbsp;
    } //SeqSearch

②、从表中最后一个记录开始，逐个�q�行与关键字比较。直至第一个��|��elem[0]=key�Q��ؓ讄��“哨兵”。找不到�q�回0
int SeqSearch(Seqlist R�Q�KeyType K)
    {
      //在顺序表R[1..n]中顺序查扑օ�键字为K的结点，
      //成功时返回找到的�l�点位置�Q�失败时�q�回0
      int i�Q?br />      R[0].key=K�Q?//讄��哨兵
      for(i=R.len�Q�R[i].key!=K;i--)�Q?//从表后往前找
      return i�Q?//若i�?�Q�表�C�查扑֤�败，否则R[i]是要扄��l�点
    } //SeqSearch
比较�Q?font face="宋体">成功时的��序查找的��^均查��N��度：

    　在等概率情况下，p_i=1/n(1≤i≤n)�Q�故成功的��^均查��N��度�ؓ
        (n+…+2+1)/n=(n+1)/2
��x��找成功时的��^均比较次数约��长的一半�?br />若K��g��在表中，则须�q�行n+1�ơ比较之后才能确定查扑֤�败�?br />
2、折半查找：�Q�二分法查找�Q?必须有序)
①、假设数据是按升序排序的�Q�对于给定值x�Q�从序列的中间位�|�开始比较，如果当前位置值等于x�Q�则查找成功�Q?br />②、若x��于当前位置��|��则在数列的前半段中查找；若x大于当前位置值则在数列的后半�D�中�l�箋查找�Q�直到找��Cؓ止�?/span>
      int search(int *a,int key,int low,int high)
   {
      int mid;
　    mid = (low + high)/2;
      while(low      {
         if(a[mid] == key) return mid;
         else
         if (a[mid]>key)   high=mid;
               else low=mid;

           mid = (low + high)/2;
       }//while
      return -1;    //没有扑ֈ�
   }//search
用递归思想�Q?/span>
　int search(int *a,int key,int low,int high)
　　{
　   　int mid;
　　   if(low > high)
　   　return -1;
　   　mid = (low + high)/2;
　   　if(a[mid] == key) return mid;
　   　else if(a[mid] > key)   return search(a,key,low,mid -1);
　   　else return    search(a,key,mid + 1,high);
　　}

3�?br />/////////////////////待箋...

Yu_ 2011-10-03 11:00 发表评论

Yu_ — Mon, 03 Oct 2011 02:07:00 GMT
1、二叉搜索树是二叉树的一�U�，树的每个�l�点含有一个数据项�Q�每个数据项有一个键倹{��结点的存储位置是由键值的大小军_��的，所以二叉搜索树是关联式容器�?br />(1)�?nbsp;若它的左子树不空�Q�则左子树上所有结点的键值均��于它的根结点的键��|��
(2)、若它的叛_��树不�I�，则右子树上所有结点的键值均大于它的根结点的键��|��
(3)、它的左、右子树也分别�ؓ二叉排序树�?br />注意�Q�：�Q�二叉排序树是一�U?span style="color: red">动态树�?/span>�Q�树的结构通常不是一�ơ生成的。而是在查扄��q�程中，当树中不存在关键字等于给定值的节点时再�q�行插入。新插入的结点一定是一个新��d��?font color="#136ec2">叶子�l�点�Q��ƈ且是查找不成功时查找路径上访问的最后一个结点的左孩子或叛_��子结炏V�?br />
2、插入与查找��法�Q?br />查找�Q?br />�Q?�Q�、若二叉排序树非�I�，��给定��g��根节点的关键字值比较，若相�{�，则查找成功；
�Q?�Q�、若不等�Q�则当根节点的关键字值大于给定值时�Q�到根的左子树中�q�行查找�Q?br />�Q?�Q�、否则到根的叛_��树中�q�行查找。若扑ֈ��Q�则查找�q�程是走了一条从树根到所扑ֈ�节点的�\径；
�Q?�Q�、否则，查找�q�程�l�止于一��늩�树�?br />//① 、普通查找，查找不成功返回NULL
递归思想�Q?/span>
BiTree SearchBST (BiTree *T�Q�KeyType key)
{
    //在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元�?br />    //若查找成功，则返回指向该数据元素�l�点的指针，否则�q�回�I�指�?br />        if( (!T)||(key==T—>data.key))
            return (T)�Q?//查找�l�束,此时T为NULL�Q�或者�ؓ该结�?br />        else if (key< T—>data.key)
                return(SearchBST(T—>lchild�Q�key))�Q?//在左子树中��l�查�?br />                else
                return(SearchBST(T —>rchild�Q�key))�Q?/ 在右子树中��l�查�?br />    }//SearchBST

非递归思想�Q?br />BiTree SearchBST (BiTree *root�Q�KeyType key)
{
   BiTree *p�Q?br />   if( root �Q�＝ NULL)return NULL�Q?font size="2">//查找�l�束,此时根�ؓNULL�Q?/font>
   p �Q?root�Q?br />   while(p!=NULL)
   {
        if(p �Q?gt;key==Key)breat�Q?/font>
       if( Key < p ->key) p �Q�p �Q?gt;lchild�Q?font size="2">//在左子树中��l�查�?/font>
         else p �Q?p �Q?gt;rchild�Q?/在右子树中��l�查�?/font>
    }
   return p�Q?br />}
//② 、查找不成功�Q�返回插入位�|?br />    //在根指针T所指二叉排序树中递归地查扑օ�关键字等于key的数据元素，
    //若查找成功，则指针p指向该数据元素结点，�q�返回TRUE�Q?br />    //否则指针p指向查找路径上访问的最后一个结点�ƈ�q�回FALSE�Q?br />    //指针f指向T的双�Ԍ��其初始调用��gؓNULL
BOOL SearchBST(BiTree *T�Q�KeyType key�Q�BiTree *f�Q�BiTree &p)
{
        if(!T) {p=f�Q�return FALSE�Q�} //查找不成�?br />        else if (key==T—>data.key)
            {p=T�Q�return TRUE�Q�} //查找成功
           else if (keydata.key) SearchBST(T—>lchild�Q�key�Q�T�Q�p)�Q?//在左子树中��l�查�?br />                        else SearchBST(T—>rchild�Q�key�Q�T�Q�p)�Q?/在右子树中��l�查�?br />    }//SearchBST

插入�Q?br />�Q?�Q�、首先执行查扄��法，扑և�被插�l�点的父亲结炏V��没扑ֈ�则新建子�l�点
�Q?�Q�、判断被插结�Ҏ��其父亲结点的左、右儿子。将被插�l�点作�ؓ叶子�l�点插入�?
�Q?�Q�、若二叉树�ؓ�I�。则首先单独生成根结�?br />
��Z��BOOL SearchBST(BiTree *T�Q�KeyType key�Q�BiTree *f�Q�BiTree &p)的插入算�?br />相当于新建子树�?br /> //当二叉排序树T中不存在关键字等于e.key的数据元素时,插入e�q�返回TRUE�Q�否则返回FALSE
Status Insert BST(BiTree &T�Q�ElemType e)
{
            if(!SearchBST(T�Q�e.key�Q�NULL�Q�p) ) //�q�回P为插入的�l�点�?br />        { //先查找，不成功新建结�?br />            s=(BiTree)malloc(sizeof(BiTNode))�Q?br />            s->data=e�Q?s->lchild= s->rchild=NULL�Q?
            if (!p) T = s�Q?//被插�l�点*s为新的根�l�点 �Q�原树�ؓ�I?br />            else if (e.keydata.key) p->lchild=s�Q?//被插�l�点*s为左孩子
                    else p—>rchild=s //被插�l�点*s为右孩子
            return TRUE�Q?br />          }
        else
      return FALSE; //树中已有关键字相同的�l�点�Q�不再插�?br />    }// Insert BST

void InsertBST(BSTree *Tptr�Q�KeyType key)
      {
//若二叉排序树 *Tptr中没有关键字为key�Q�则插入�Q�否则直接返�?br />        BSTNode *f�Q?p=*TPtr�Q?//p的初值指向根�l�点
        while(p){ //查找插入位置
          if(p->key==key) return�Q?/树中已有key�Q�无��L��?br />          f=p�Q?//f保存当前查找的结�?/span>
          p=(keykey)?p->lchild�Q�p->rchild�Q?br />            //若keykey�Q�则在左子树中查找，否则在右子树中查�?br />         } //endwhile
         //f为插入的�l�点
        p=(BSTNode *)malloc(sizeof(BSTNode))�Q?br />        p->key=key�Q?p->lchild=p->rchild=NULL�Q?//生成新结�?br />        if(*TPtr==NULL) //原树为空
           *Tptr=p�Q?//新插入的�l�点为新的根
        else //原树非空时将新结点关p作�ؓ关f的左孩子或右孩子插入
          if(keykey)
            f->lchild=p�Q?br />          else f->rchild=p�Q?br />       } //InsertBST

4、删除算�?br />①删除操作的一般步�?br />(1) �q�行查找
    　查找�Ӟ��令p指向当前讉K��到的�l�点�Q�parent指向其双�?其初��gؓNULL)。若树中找不到被删结点则�q�回�Q�否则被删结�Ҏ��*p�?br />(2) 删去*p�?br />    　�?p�Ӟ��应将*p的子�?若有)仍连接在树上且保持BST性质不变。按*p的孩子数目分三种情况�q�行处理�?br />
②删除*p�l�点的三�U�情�?/strong>
(1)*p是叶�?卛_��的孩子数�?)
    　无须�q�接*p的子树，只需��?p的双�?parent中指�?p的指针域�|�空卛_��?br />
(2)*p只有一个孩�?child
    　只需��?child�?p的双亲直接连接后�Q�即可删�?p�?br /> 注意�Q?/font>
    　*p既可能是*parent的左孩子也可能是其右孩子�Q��?child可能�?p的左孩子或右孩子�Q�故共有4�U�状态�?br />(3)*p有两个孩�?br />    　先��oq=p�Q�将被删�l�点的地址保存在q中；然后�?q的中序后�l?p�Q��ƈ在查找过�E�中仍用parent��C��*p的双亲位�|��?q的中序后�l?p一定是*q的右子树中最左下的结点，它无左子树。因此，可以��删�?q的操作�{换�ؓ删去�?p的操作，卛_��释放�l�点*p之前��其数据复制�?q中，��q��当于删去�?q�?br />③二叉排序树删除算�?/strong>
分析�Q?br />    　上述三种情况都能�l�一到情�?2)�Q�算法中只需针对情况(2)处理卛_��?br />    　注意边界条�g�Q�若parent为空�Q�被删结�?p是根�Q�故删去*p后，应将child�|��ؓ栏V�?br />

��法�Q�删除关键字为key的结�?
void DelBSTNode(BSTree *Tptr�Q�KeyType key)
{
//在二叉排序树*Tptr中删��d��键字为key的结�?br /> BSTNode *parent=NUll�Q?p=*Tptr�Q?q�Q?child�Q?br /> while(p)
{
     //从根开始查扑օ�键字为key的待删结�?br />    if(p->key==key) break�Q?/已找刎ͼ�跛_��查找循环
    parent=p�Q?//parent指向*p的双�?br />    p=(keykey)?p->lchild�Q�p->rchild�Q?//在关p的左或右子树中��l�找
}
//注意�Q�也可以使用��Z��BOOL SearchBST(BiTree *T�Q�KeyType key�Q�BiTree *f�Q�BiTree &p)的查扄��?/strong>
//�l�果�?nbsp; parent 记录了要删除�l�点的父�l�点�Q�p指向要删除的�l�点

      if(!p) return�Q?//找不到被删结点则�q�回
     q=p�Q?//q��C��被删�l�点*p
     if(q->lchild && q->rchild) //*q的两个孩子均非空�Q�故�?q的中序后�l?p
    for(parent=q�Q�p=q->rchild�Q?p->lchild�Q?parent=p�Q�p=p=->lchild)�Q?br /> //现在情况(3)已被转换为情�?2)�Q�而情�?1)相当于是情况(2)中child=NULL的状�?br />    child=(p->lchild)?p->lchild�Q�p->rchild�Q?/若是情况(2)�Q�则child非空�Q�否则child为空
    if(!parent) //*p的双亲�ؓ�I�，说明*p为根�Q�删*p后应修改�Ҏ��?br />      *Tptr=child�Q?//若是情况(1)�Q�则删去*p后，树�ؓ�I�；否则child变�ؓ�?br />    else{ //*p不是根，��?p的孩子和*p的双亲进行连接，*p从树上被摘下
      if(p==parent->lchild) //*p是双亲的左孩�?br />        parent->lchild=child�Q?//*child作�ؓ*parent的左孩子
      else parent->rchild=child�Q?//*child作�ؓ parent的右孩子
      if(p!=q) //是情�?3)�Q�需��?p的数据复制到*q
        q->key=p->key�Q?//若还有其它数据域亦需复制
     } //endif
    free(p)�Q?/释放*p占用的空�?br /> } //DelBSTNode
�l�出三种情况的不同算�?br />�W�一�U�：
btree * DelNode(btree *p)
{
      if (p->lchild)
      {
            btree *r = p->lchild;   //r指向其左子树;
        while(r->rchild != NULL)//搜烦左子树的最双��的叶子结�?/span>r
        {
            r = r->rchild;
        }
            r->rchild = p->rchild;
            btree *q = p->lchild;   //q指向其左子树;
            free(p);
            return q;
      }
      else
      {
            btree *q = p->rchild;   //q指向其右子树;
            free(p);
            return q;
      }
}
�W�二�U�：
btree * DelNode(btree *p)
{
      if (p->lchild)
      {
            btree *r = p->lchild;   //r指向其左子树;
            btree *prer = p->lchild;   //prer指向其左子树;
        while(r->rchild != NULL)//搜烦左子树的最双��的叶子结�?/span>r
        {
                  prer = r;
            r = r->rchild;
        }

        if(prer != r)//�?/span>r不是p的左孩子�Q�把r的左孩子作�ؓr的父亲的叛_��?/span>
        {
                  prer->rchild = r->lchild;
                  r->lchild = p->lchild; //被删�l�点p的左子树作�ؓr的左子树
            }
        r->rchild = p->rchild; //被删�l�点p的右子树作�ؓr的右子树

            free(p);
            return r;
      }
      else
      {
            btree *q = p->rchild;   //q指向其右子树;
            free(p);
            return q;
      }
}

Yu_ 2011-10-03 10:07 发表评论

哈夫曼树

Yu_ — Sun, 02 Oct 2011 09:04:00 GMT

哈夫曼树定义为：�l�定n个权��g��为n个叶子结点，构造一��二叉树�Q�若带权路径长度辑ֈ�最��，�U�这��L��二叉树�ؓ最优二叉树�Q�也�U�Cؓ哈夫曼树(Huffman tree)�?br />1、那么什么是权�?/span>�Q�什么是路径长度�Q�什么是�?span style="color: red">权�\径长�?/span>呢？
权�?/span>�Q�哈夫曼树的权值是自己定义的，他的物理意义表示数据出现的次数、频率。可以用树的每个�l�点数据域data存放一个特定的数表�C�它的倹{�?span style="widows: 2; text-transform: none; text-indent: 0px; border-collapse: separate; font: medium Simsun; white-space: normal; orphans: 2; letter-spacing: normal; color: rgb(0,0,0); word-spacing: 0px; -webkit-border-horizontal-spacing: 0px; -webkit-border-vertical-spacing: 0px; -webkit-text-decorations-in-effect: none; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px" class="Apple-style-span">

路径长度�Q�在一��|��中，从一个结点往下可以达到的孩子或子孙结点之间的通�\�Q�称��\径�?span style="color: red">通�\中分支的数目�U�Cؓ路径长度。若规定根结点的层数�?�Q�则从根�l�点到第L层结点的路径长度为L-1�?br />
�l�点的带权�\径长�?/span>为：从根�l�点到该�l�点之间的�\径长度与该结点的权的乘积�?nbsp; 树中所有叶子节点的带权路径长度之和�Q?span style="color: red">WPL=sigma(w*l)

2、哈夫曼树的构造过�E�。（�l�合图例�Q?br />假设有n个权��|��则构造出的哈夫曼树有n个叶子结炏V�?n个权值分别设�?w1、w2�?#8230;、wn�Q�则哈夫曼树的构造规则�ؓ�Q?

　　(1) ��w1、w2�?#8230;�Q�wn看成是有n ��|��的森�?每棵树仅有一个结�?�Q?

　　(2) 在森林中选出两个根结点的权值最��的树合�qӞ��作�ؓ一��|��树的左、右子树�Q�且新树的根�l�点权��gؓ其左、右子树根结�Ҏ��g��和；

　　(3)从森林中删除选取的两��|��Q��ƈ��新树加入森林；

　　(4)重复(2)�?3)步，直到��林中只剩一��|��为止�Q�该树即为所求得的哈夫曼�?br />
3、哈夫曼树的应用�Q�哈夫曼�~�码�Q�前�~��~�码�Q?br />哈夫曼编�?/strong>

在数据通信中，通常需要把要传送的文字转换为由二进制字�W?�?�l�成的二�q�制�Ԍ��q�个�q�程被称之�ؓ�~�码(Encoding)。例如，假设要传送的甉|��为DCBBADD�Q�电文中只有A、B、C、D四种字符�Q�若�q�四个字�W�采用表(a)所�C�的�~�码�Ҏ��Q�则甉|��的代码�ؓ11100101001111�Q�代码总长度�ؓ14。若采用�?b) 所�C�的�~�码�Ҏ��Q�则甉|��的代码�ؓ0110101011100�Q�代码总长度�ؓ13�?/p>

字符集的不同�~�码�Ҏ��

哈夫曼树可用于构造总长度最短的�~�码�Ҏ��。具体构造方法如下：
��N��要编码的字符集�ؓ{d1,d2,…,dn}�Q�各个字�W�在甉|��中出现的�ơ数或频率集合�ؓ{w1,w2,…,wn}。以d1,d2,…,dn作�ؓ叶子�l�点�Q�以w1,w2,…,wn作�ؓ相应叶子�l�点的权值来构造一��哈夫曼树。规定哈夫曼树中的左分支代表0�Q�右分支代表1�Q�则从根�l�点到叶子结�Ҏ��l�过的�\径分支组成的0�?的序列便��l�点对应字符的编码就是哈夫曼�~�码(Huffman Encoding)�?/p>
在徏立不�{�长�~�码中，必须使�Q何一个字�W�的�~�码都不是另一个编码的前缀�Q�这��h��能保证译码的唯一性。例如，若字�W�A的编码是00�Q�字�W�B的编码是001�Q�那么字�W�A的编码就成了字符B的编码的后缀。这��P��对于代码�?01001�Q�在译码时就无法判定是将前两位码00译成字符A�q�是��前三位�?01译成B。这��L��~�码被称之�ؓ��h��二义性的�~�码�Q�二义性编码是不唯一的。而在哈夫曼树中，每个字符�l�点都是叶子�l�点�Q�它们不可能在根�l�点到其它字�W�结点的路径上，所以一个字�W�的哈夫曼编码不可能是另一个字�W�的哈夫曼编码的前缀�Q�从而保证了译码的非二义性�?/p>
下图��是甉|��DCBBADD的哈夫曼树：

4、哈夫曼树的实现

由哈夫曼树的构造算法可知，用一个数�l�存攑֎�来的n个叶子结点和构造过�E�中临时生成的结点，数组的大��ؓ2n-1。所以，哈夫曼树�c�HuffmanTree中有两个成员字段�Q�data数组用于存放�l�点�Q�leafNum表示哈夫曼树叶子�l�点的数目。结�Ҏ��四个域，一个域weight�Q�用于存放该�l�点的权��|��一个域lChild�Q�用于存放该�l�点的左孩子�l�点在数�l�中的序��P��一个域rChild�Q�用于存放该�l�点的右孩子�l�点在数�l�中的序��P��一个域parent�Q�用于判定该�l�点是否已加入哈夫曼树中�?/p>
哈夫曼树�l�点的结构�ؓ�Q�| 数据 | weight | lChild | rChild | parent |

     public class Node
    {
        char c; //存储的数据，��Z��个字�W?br />        private double weight; //�l�点权�?br />        private int lChild; //左孩子结�?br />        private int rChild; //叛_��子结�?br />        private int parent; //父结�?br />        //�l�点权值属�?br />        public double Weight
        {
            get
            {
                return weight;
            }
            set
            {
                weight = value;
            }
        }
        //左孩子结点属�?br />        public int LChild
        {
            get
            {
                return lChild;
            }
            set
            {
                lChild = value;
            }
        }
        //叛_��子结点属�?br />        public int RChild
        {
            get
            {
                return rChild;
            }
            set
            {
                rChild = value;
            }
        }
        //父结点属�?br />        public int Parent
        {
            get
            {
                return parent;
            }
            set
            {
                parent = value;
            }
        }
        //构造器
        public Node()
        {
            weight = 0;
            lChild = -1;
            rChild = -1;
            parent = -1;
        }
        //构造器
        public Node(double weitht)
        {
            this.weight = weitht;
            lChild = -1;
            rChild = -1;
            parent = -1;
        }

        //构造器
        public Node(int w, int lc, int rc, int p)
        {
            weight = w;
            lChild = lc;
            rChild = rc;
            parent = p;
        }
    }

    public class HuffmanTree
    {
        private Node[] data; //�l�点数组
        private int leafNum; //叶子�l�点数目
        //索引�?br />        public Node this[int index]
        {
            get
            {
                return data[index];
            }
            set
            {
                data[index] = value;
            }
        }
        //叶子�l�点数目属�?br />        public int LeafNum
        {
            get
            {
                return leafNum;
            }
            set
            {
                leafNum = value;
            }
        }
        //构造器
        public HuffmanTree(int n)
        {
            data = new Node[2 * n - 1];
            leafNum = n;
        }
        //创徏哈夫曼树
        public void Create(Node[] datain)
        {
            double minL, minR;
            minL = minR = double.MaxValue;
            int lchild, rchild;
            lchild = rchild = -1;

            int length = data.Length;
            //初始化哈夫曼�?br />            for (int i = 0; i < length; i++)
                data[i] = new Node();
            for (int i = 0; i < datain.Length; i++)
                data[i] = datain[i];

            //处理n个叶子结点，建立哈夫曼树
            for (int i = leafNum; i < length; i++)
            {
                //在全部结点中找权值最��的两个�l�点
                for (int j = 0; j < i; j++)
                {
                    if (data[j].Parent == -1)
                    {
                        if (data[j].Weight < minL)
                        {
                            minR = minL;
                            minL = data[j].Weight;
                            rchild = lchild;
                            lchild = j;
                        }
                        else if (data[j].Weight < minR)
                        {
                            minR = data[j].Weight;
                            rchild = j;
                        }
                    }
                }
                data[lchild].Parent = data[rchild].Parent = i;
                data[i].Weight = minL + minR;
                data[i].LChild = lchild;
                data[i].RChild = rchild;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            HuffmanTree tree = new HuffmanTree(5);
            Node[] nodes = new Node[] { new Node(1), new Node(2), new Node(2.5d), new Node(3), new Node(2.6d) };
            tree.Create(nodes);

            Console.ReadLine();
        }
    }

/////////////////////////////节选自�|�络上的资料�?/p>

Yu_ 2011-10-02 17:04 发表评论

优先队列

Yu_ — Sun, 02 Oct 2011 03:22:00 GMT
优先队列是不同于先进先出队列的另一�U�队列。每�ơ从队列中取出的是具�?span style="color: red">最高优先权的元素。每个元素都有一个优先权或�?br />/////用堆实现优先队列
1、把优先队列中的元素按优先��大小�l�织成堆�Q�堆��元素具有最大优先��?br />2、优先队列的插入与删除可以用堆的插入与删除实现�?br />3、优先队列在定义为priority_queue �Q�在STL�?include 中实现�?br /> priority_queue<int, vector<int>, greater<int> >qi2;
其中
�W�二个参��Cؓ容器�c�d��?br />�W�三个参��Cؓ比较函数�?br />

Yu_ 2011-10-02 11:22 发表评论

Yu_ — Sat, 01 Oct 2011 08:55:00 GMT
估计�q�要问问�Q�什么是堆，什么是堆排序？堆与计算机分配内存的堆相同吗�Q?br />很多资料�l�出�Q�堆的定义是
�Q?�Q�、n个关键字序列�Q�Kl�Q�K2�Q?#8230;�Q�Kn�Q�称�?Heap)�Q�当且仅当该序列满��如下性质(��U�Cؓ堆性质)�Q?br />ki≤K2i且ki≤K2i+1 �?nbsp; Ki≥K2i且ki≥K2i+1 (1≤i≤ n) //ki相当于二叉树的非叶结点，K2i则是左孩子，k2i+1是右孩子

�Q?�Q�若��此序列所存储的向量R[1..n]看做是一��?strong>完全二叉�?/strong>的存储结构，则堆实质上是满��如下性质的完全二叉树�Q?
　　树中��M��非叶�l�点的关键字均不大于(或不��于)其左叛_��?若存�?�l�点的关键字�?br />
�Q?�Q�、根�l�点(亦称为堆��?的关键字是堆里所有结点关键字�?span style="color: red">最��?/span>的堆�U�Cؓ��根�?/span>�Q�又�U�最��堆。根�l�点(亦称为堆��?的关键字是堆里所有结点关键字�?span style="color: red">最大�?/span>�Q�称为大根堆�Q�又�U?span style="color: red">最大堆�?br />
�Q?�Q�、堆中�Q一子树亦是堆�?br />�Q?�Q�、堆可以视�ؓ一��完全的二叉树，完全二叉树的一�?#8220;优秀”的性质是，除了最底层之外�Q�每一层都是满的，�q��得堆可以利用数组来表�C�（普通的一般的二叉树通常用链表作为基本容器表�C�）�Q�每一个结点对应数�l�中的一个元素�?/span>

那么堆排序呢�Q?br />堆排序其实就是将一�l�无序的序列变成堆的�q�程、下面我们一��L��看堆排序的算法�?br />2、堆排序
以最大堆��Z��Q�步骤�ؓ�Q?br />　　① 先将初始文�gR[1..n]建成一个大根堆,此堆为初始的无序�?
　　② 再将关键字最大的记录R[1](卛_��?和无序区的最后一个记录R[n]交换�Q�由此得到新的无序区R[1..n-1]和有序区R[n]�Q�且满��R[1..n-1].keys≤R[n].key
　　③�׃��交换后新的根R[1]可能�q�反堆性质�Q�故应将当前无序区R[1..n-1]调整为堆。然后再�ơ将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换�Q�由此得到新的无序区R[1..n-2]和有序区R[n-1..n]�Q�且仍满��_��p�R[1..n-2].keys≤R[n-1..n].keys�Q�同栯��R[1..n-2]调整为堆�?
　　……
　　直到无序区只有一个元素�ؓ止�?nbsp;
��一个无序的序列建成堆的�q�程实际上是一个反复筛选的�q�程。若��此序列看作是一��完全二叉树�Q�则最后一个非�l�端�l�点是[n/2](不大于n/2的整敎ͼ��Q�因此筛选过�E�只需从[n/2]开始。要建成一个大��堆�Q�即先选择一个值最大的元素�q�与序列中的最后一个元素交换，然后对序列前n-1元素�q�行�{�选，从新调整��Z��个大��堆�Q�直到结束�?span class="Apple-converted-space">
��法描述如下�Q?span class="Apple-converted-space">

typedef int[] Elem;//采用��序存储表示完全二叉�?span class="Apple-converted-space">

void HeapAdjust(Elem &e,int s,int m)
{//e中s...m的元素除e[s]之外已经满��堆的定义�Q�e[i] <=e[2*i]&&e[i] <=e[2*i+1]
//或e[i]> =e[2*i]&&e[i]> =e[2*i+1]),调整e[s]使的e[s...m]成�ؓ一个大��堆�?span class="Apple-converted-space">
selem=e[s];
for(i=2*s;i <=m;i*=2)//沿着��D��大的元素�Q�结点）向下�{��?span class="Apple-converted-space">
{
if(i
if(selem> =e[i])break;
e[s]=e[i];
s=i;
}
e[s]=selem;
}

void HeapSort(Elem &e)
{//寚w��序表排序
for(i=e.length/2;i> 0;--i)
HeapAdjust(e,i,e.length);
for(i=e.length;i> 1;--i)
{
temp=e[1]; //��堆中的最后一个元素与�W�一个元素交�?span class="Apple-converted-space">
e[1]=e[i];
e[i]=temp;
HeapAdjust(H,1,i-1);//调整1..i-1的元素成为大��堆
}
}

/////////////////////////////////////////////////////////////
使用堆排序注意的问题�Q�：�Q?br />1、序列是�?开始的。，注意定义�Q�R[1..n]�Q�故要空出R[0]�?br />2、堆排序��法分�ؓ两部分：建立大顶堆和排序�?br />3、排序的最坏时间复杂度�?strong>O(nlogn)。堆序的�q�_��性能较接�q�于最坏性能�?br />4、由于徏初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件�?
5、　堆排序是��地排序�Q�辅助空间�ؓO(1)�Q?它是不稳�?/strong>的排序方法�?br />
问题�Q�当序列�I�间为R[0,1....n]�Q�时�Q�该怎么��M��用堆排序呢？元素后移一位，�q�明显不是一个好�Ҏ��?img src ="http://www.shnenglu.com/Cass/aggbug/157298.html" width = "1" height = "1" />

Yu_ 2011-10-01 16:55 发表评论

精品久久8x国产免费观看,久久精品人人做人人爽电影蜜月,久久久一本精品99久久精品88

归�ƈ排序

B-树及B�Q�树

1、B+树的查找

2、B+树的插入

3、B+树的删除

1、二叉排序树�Q�B树）的查找：

2、二叉排序树�Q�B树）的插入和删除�Q?/span>

�q����二叉�?�Q�AVL树）

哈夫曼树

优先队列

�q��二叉�?�Q�AVL树）