C++博客-程序大本营-随笔分类-Data Structure & Algorithm

数的整除特征【转载】

远风 — Tue, 25 Aug 2009 13:53:00 GMT

原文地址：http://blog.sina.com.cn/s/blog_4effee7d0100bg35.html

什么数能被2，3，4，5，8，9整除，我想大家基本上都知道的。如果是7，11，13的话，可能知道的人就不多了。找到这个资料，发上来希望能帮助到大家。　

数的整除特征

　　①能被2整除的数的特征：个位数字是0、2、4、6、8的整数.“特征”包含两方面的意义：一方面，个位数字是偶数（包括0）的整数，必能被2整除；另一方面，能被2整除的数，其个位数字只能是偶数（包括0）.下面“特征”含义相似。

　　②能被5整除的数的特征：个位是0或5。

　　③能被3（或9）整除的数的特征：各个数位数字之和能被3（或9）整除。

　　④能被4（或25）整除的数的特征：末两位数能被4（或25）整除。

　　例如：1864=1800＋64，因为100是4与25的倍数，所以1800是4与25的倍数.又因为4｜64，所以1864能被4整除.但因为2564，所以1864不能被25整除.

　　⑤能被8（或125）整除的数的特征：末三位数能被8（或125）整除。

　　例如：29375＝29000＋375，因为1000是8与125的倍数，所以29000是8与125的倍数.又因为125｜375，所以29375能被125整除.但因为8375，所以829375。

　　⑥能被11整除的数的特征：这个整数的奇数位上的数字之和与偶数位上的数字之和的差（大减小）是11的倍数。

　　例如：判断123456789这九位数能否被11整除？

　　解：这个数奇数位上的数字之和是9＋7＋5＋3＋1=25，偶数位上的数字之和是8＋6＋4＋2＝20.因为25—20＝5，又因为11｜5，所以11｜123456789不能。

　　再例如：判断13574是否是11的倍数？

　　解：这个数的奇数位上数字之和与偶数位上数字和的差是：（4＋5＋1）-（7＋3）＝0.因为0是任何整数的倍数，所以11｜0.因此13574是11的倍数。

　　⑦能被7（11或13）整除的数的特征：一个整数的末三位数与末三位以前的数字所组成的数之差（以大减小）能被7（11或13）整除。

　　例如：判断1059282是否是7的倍数？

　　解：把1059282分为1059和282两个数.因为1059-282＝777，又7｜777，所以7｜1059282.因此1059282是7的倍数。

　　再例如：判断3546725能否被13整除？

解：把3546725分为3546和725两个数.因为3546-725=2821.再把2821分为2和821两个数，因为821—2＝819，又13｜819，所以13｜2821，进而13｜3546725.

数的整除性质主要有：

（1）如果甲数能被乙数整除，乙数能被丙数整除，那么甲数能被丙数整除。

（2）如果两个数都能被一个自然数整除，那么这两个数的和与差都能被这个自然数整除。

（3）如果一个数能分别被几个两两互质的自然数整除，那么这个数能被这几个两两互质的自然数的乘积整除。

（4）如果一个质数能整除两个自然数的乘积，那么这个质数至少能整除这两个自然数中的一个。

（5）几个数相乘，如果其中一个因数能被某数整除，那么乘积也能被这个数整除。

灵活运用以上整除性质，能解决许多有关整除的问题。

【例1】在□里填上适当的数字，使得七位数□7358□□能分别被9，25和8整除。

分析与解：分别由能被9，25和8整除的数的特征，很难推断出这个七位数。因为9，25，8两两互质，由整除的性质（3）知，七位数能被 9×25×8=1800整除，所以七位数的个位，十位都是0；再由能被9整除的数的特征，推知首位数应填4。这个七位数是4735800。

【例2】由2000个1组成的数111…11能否被41和271这两个质数整除？

分析与解：因为41×271=11111，所以由每5个1组成的数11111能被41和271整除。按“11111”把2000个1每五位分成一节， 2000÷5=400，就有400节，

因为2000个1组成的数11…11能被11111整除，而11111能被41和271整除，所以根据整除的性质（1）可知，由2000个1组成的数111…11能被41和271整除。

【例3】现有四个数：76550，76551，76552，76554。能不能从中找出两个数，使它们的乘积能被12整除？

分析与解：根据有关整除的性质，先把12分成两数之积：12=12×1=6×2=3×4。

要从已知的四个数中找出两个，使其积能被12整除，有以下三种情况：

（1）找出一个数能被12整除，这个数与其它三个数中的任何一个的乘积都能被12整除；

（2）找出一个数能被6整除，另一个数能被2整除，那么它们的积就能被12整除；

（3）找出一个数能被4整除，另一个数能被3整除，那么它们的积能被12整除。

容易判断，这四个数都不能被12整除，所以第（1）种情况不存在。

对于第（2）种情况，四个数中能被6整除的只有76554，而76550，76552是偶数，所以可以选76554和76550，76554和76552。

对于第（3）种情况，四个数中只有76552能被4整除，76551和76554都能被3整除，所以可以选76552和76551，76552和76554。

综合以上分析，去掉相同的，可知两个数的乘积能被12整除的有以下三组数：76550和76554， 76552和76554， 76551和 7655

【例4】在所有五位数中，各位数字之和等于43且能够被11整除的数有哪些？

分析与解：从题设的条件分析，对所求五位数有两个要求：

①各数位上的数字之和等于43；

②能被11整除。

因为能被11整除的五位数很多，而各数位上的数字之和等于43的五位数较少，所以应选择①为突破口。有两种情况：

（1）五位数由一个7和四个9组成；

（2）五位数由两个8和三个9组成。

上面两种情况中的五位数能不能被11整除？9，8，7如何摆放呢？根据被11整除的数的特征，如果奇数位数字之和是27，偶数位数字之和是16，那么差是11，就能被11整除。满足这些要求的五位数是： 97999，99979， 98989。

【例5】能不能将从1到10的各数排成一行，使得任意相邻的两个数之和都能被3整除？

分析与解：10个数排成一行的方法很多，逐一试验显然行不通。我们采用反证法。

假设题目的要求能实现。那么由题意，从前到后每两个数一组共有5组，每组的两数之和都能被3整除，推知1～10的和也应能被3整除。实际上，1～10的和等于55，不能被3整除。这个矛盾说明假设不成立，所以题目的要求不能实现。

练习

1.已知4205和2813都是29的倍数，1392和7018是不是29的倍数？

2.如果两个数的和是64，这两个数的积可以整除4875，那么这两个数的差是多少？

3.173□是个四位数。数学老师说：“我在这个□中先后填入3个数字，所得到的 3个四位数，依次可以被9，11，6整除。”问：数学老师先后填入的3个数字之和是多少？班有多少名学生？6.能不能将从1到9的各数排成一行，使得任意相邻的两个数之和都能被3整除？

远风 2009-08-25 21:53 发表评论

判断图连通&求割点的算法

远风 — Mon, 17 Aug 2009 11:24:00 GMT

之所以把判断图连通的算法以及求图中割点的算法放在一起写，是因为这两者之间有一定的关系。注意：只有连通图中才可能有割点，不连通的图是没有割点的。总的来说，这两类算法都离不开并查集结构和BFS先深搜索，具体如下：

1.判断图连通的算法
第一种方法基于BFS，首先利用邻接表（链表形式或者数组形式都可以）存储图的信息，然后取标号值最小的顶点u作为根节点进行先深搜索，最终搜索到的节点将形成一棵树，判断图是否连通，只要判断是否所有节点都在树上即可。
代码如下：

//graph[][]存储图信息，num[]存储每个顶点的邻接点数目
memset(flag, 0, sizeof(flag));
DFS(1);
for(i = 1; i <= nodeNum; i++)
{
        if(flag[i] == false)
    {
        printf("不连通\n");
        }
}

//DFS算法
void DFS(int x)
{
    int i;

    flag[x] = true;
    for(i = 0; i < num[x]; i++)
    {
        if(flag[graph[x][i]] == false)
        {
            DFS(graph[x][i]);
        }
    }
}

然而这种算法存在弊端，就是需要存储所有的边信息，当边信息足够多时，存储数组graph[][]、num[]和flag[]的开销是很大的。第二种基于并查集的方法则解决了这个弊端，关于并查集的内容具体可见：http://www.cppblog.com/amazon/archive/2009/08/15/93457.html。对所有的边信息进行并查集处理后，如果该图是连通图，那么所有节点的根节点指针都指向同一个点。
代码如下：

a = Find(record[0]);
for(j = 1; j < num_record; j++)
{
    if(a != Find(record[j]))
    {
        printf("The door cannot be opened.\n");
        break;
    }
}

2.求割点的算法
首先必须保证，所求的图是连通图，不连通的图没有割点。
该算法依然基于BFS，按照标号值大小依次将图中的顶点隐去，对剩下的所有节点进行先深搜索，根据搜索子树的数目即可知道隐去的节点是否割点（数目为1，非割点；数目为2以上，割点），并可根据子树的数目知道删除该割点后连通子图的数目。
代码如下：

jump = false;
for(i = 1; i <= nodeNum; i++)
{
    subnetNum = 0;
    HowMuch(i, subnetNum);

    if(subnetNum != 1)
    {
        printf("%d是割点，删除后有%d个连通子图\n", i, subnetNum);
        jump = true;
    }
}
if(jump == false)
{
    printf("不是割点\n");
}

//DFS算法
void DFS(int x)
{
    int i;

    flag[x] = true;
    for(i = 0; i < num[x]; i++)
    {
        if(flag[graph[x][i]] == false)
        {
            DFS(graph[x][i]);
        }
    }
}

//判断是否割点
void HowMuch(int x, int &subnetNum)
{
    int i;

    memset(flag, 0, sizeof(flag));
    flag[x] = true;
    for(i = 1; i <= nodeNum; i++)
    {
        if(flag[i] == false)
        {
            subnetNum++;
            DFS(i);
        }
    }
}

远风 2009-08-17 19:24 发表评论

并查集学习小结

远风 — Sat, 15 Aug 2009 14:01:00 GMT

并查集，顾名思义是一种用来处理集合间合并与查询的数据结构，主要包括如下操作：
（1）查询：查找元素所在的集合即根节点。
（2）合并：将两个元素所在的集合合并为一个集合。
并查集主要用于图论问题，例如判断一个图是否连通图、某两个点是否在图中的同一连通子图中等。算法需要以下几个子过程：
（1）对每一个节点u建立一个集合MakeSet(u)，集合的元素只有u自己，表示最开始时u与其他节点没有路径。
（2）给出一个代表路径的二元关系R（u，v），首先通过查询功能Find()分别找到u和v所在集合的根节点，利用Find(a)==Find(b)判断u和v是否在同一集合中，如果不是就使用合并功能Merge(a, b)将u所在的集合和v所在的集合合并。重复执行该步。
（3）处理完所有二元关系后，每个集合便代表一个连通子图。
接下来考虑选择何种数据结构实现并查集，使算法的效率更高。

（1）单链表形式
同一集合中的节点串成一条链表，该链表的第一个节点所谓集合的根节点，具体的节点结构如下：

typedef struct
{
    int length;           //节点自身的值
    node* head;         //指向表首的指针
    node* tail;           //指向表尾的指针，只有表头节点对其赋值
    node* next;        //指向下一节点的指针
}node;
//对每个节点建立一个集合，需要O(1)时间
void MakeSet(node* u)
{
    u->head = u;
    u->tail = u;
    u->next = NULL;
    length = 1;
}
//查询节点u所在集合的根节点，需要O(1)时间
node* Find(node* u)
{
    return u->head;
}
//将u和v所在的集合合并，需要O(N2)时间，N2是b所在集合链表长度
void Merge(node* a, node* b)
{
    node* p;

    a->head->tail->next = b->head;
    a->head->tail = b->head->tail;
    //将较短的表合并到较长表上
    if(a->head->length >= b->head->length)
    {
        p = b->head;
        while(p != NULL)
        {
            p->head = a->head;
            p = p->next;
        {
        a->head->length += b->head->length;
    }
    else
    {
        p = a->head;
        while(p != NULL)
        {
            p->head = b->head;
            p = p->next;
        {
        b->head->length += a->head->length;
    }
}

（2）树形结构
利用有根树来表示集合，每棵树表示一个集合，树根即集合的根节点。

typedef struct
{
    Node* father;     //父节点指针
    int rank;          //树深，用于启发式合并
}node;
//对每个节点建立一个集合，需要O(1)时间
void MakeSet(node* u)
{
    u->father = u;
    rank = 1;
}
//查询节点u所在集合的根节点，平均需要O(logN)时间，线性时最坏需要O(N)
node* Find(node* u)
{
    node* p;

    p = u;
    while(p->father != p)
    {
        p = p->father;
    }

    return p;
}
//将u和v所在的集合合并，需要O(1)时间
void Merge(node* a, node* b)
{
    node* p1, p2;

    p1 = Find(a);
    p2 = Find(b);
    if(p1->length >= p2->length)
    {
        b->father = a;
        if(p1->length == p2->length)
            a->length += 1;
    }
    else if(p1->length < p2->length)
    {
        a->father = b;
    }
}

注意：
（1）上述树形结构的并查集也可以使用数组+索引的形式实现，在这里不再重复。
（2）树结构下算法的耗时主要体现在Find函数上，可以通过路径压缩进行优化。例如，在对节点1执行Finds函数时，可以顺便将节点1、2、3的父节点改为节点4，以后再对节点1、2、3调用Find函数时就只需要O(1)的时间。

//查询节点u所在集合的根节点，时间复杂性******
node* Find(node* u)
{
    node* p, q;

    p = u;
    while(p->father != p)
    {
        p = p->father;
    }
    while(u != p)
    {
        q = u->father;
        u->father = p;
        u = q;
    }

    return p;
}

远风 2009-08-15 22:01 发表评论

判断回文素数的方法

远风 — Thu, 13 Aug 2009 06:11:00 GMT

给定一组连续的整数（例如2到100000），要求输出所有回文素数，大致思路有以下两种：

第一，先判断是否素数，再判断是否回文（不推荐）。如果是指定列举从2到某个数范围内的回文素数，可以考虑先用筛选法（http://www.cppblog.com/amazon/archive/2009/06/20/88107.html）挑选出所有素数，然后利用翻转法逐个判断是否回文，翻转法如下：

bool check(long a)
{
long b=0,temp=a;   //用b保存逆转后的数,temp保存输入的值,最后用来和b比较
while(a>0)
    {                  //把a的值自右向左逐位取出,自左至右地加到b上
        b*=10;
        b+=a%10;
      a/=10;
    }
    return b==temp;    //若相等则返回true.
}

第二，先构造回文，再判断是否素数（推荐）。可以先构造所有回文素数，然后根据判断是否素数（http://www.cppblog.com/amazon/archive/2009/06/20/88107.html）。构造回文素数的方法又有两种：
（1）
三位回文数公式如下：
for(a[0]=1;a[0]<10;a[0]+=2)
               for(a[1]=0;a[1]<10;a[1]++)
                          n=101*a[0]+10*a[1];
五位回文数公式如下：
for(a[0]=1;a[0]<10;a[0]+=2)
            for(a[1]=0;a[1]<10;a[1]++)
                      for(a[2]=0;a[2]<10;a[2]++)
                             n=a[0]*10001+a[1]*1010+a[2]*100;
注意，偶数个位的回文素数必然是合数，因为可以被11整除（11除外），且各位是偶数的回文素数也必然是合数，因为可以被2整除。
（2）
使用枚举+翻转的方法，例如12翻转后变成121，123翻转后变成12321，务必保持奇数个位，且最高位是偶数的话不必翻转即可判断为合数。

int Make(int data)
{
    int result;

    result = data;
    while((data /= 10) != 0)
    {
        result = result * 10 + data % 10;
    }

    return result;
}

远风 2009-08-13 14:11 发表评论

判断素数的算法

远风 — Sat, 20 Jun 2009 13:04:00 GMT

这是一个基本的算法编程问题，即给定一个整数x，判断x是否为素数。算法基本思路如下：让x被2到sqrt(x)除,如果x能被2至sqrt(x)之中任何一个整数整除，那么说明x不是质数，否则是质数。原因不再说明，具体代码如下：

#include <cmath>

bool IsPrime(int x)
{
    for(int i = 2; i <= (int)sqrt(x); i++)
    {
        if((x % i) == 0)
            return false;
    }

    return true;
}

继续引申，从1开始的连续整数中哪些为素数？可以使用“筛选法”。所谓“筛选法”指的是“埃拉托色尼(Eratosthenes)筛法”。他是古希腊的著名数学家。他采取的方法是，在一张纸上写上1到100全部整数，然后逐个判断它们是否是素数，找出一个非素数，就把它挖掉，最后剩下的就是素数。具体做法如下：

<1> 先将1挖掉(因为1不是素数)。
<2> 用2去除它后面的各个数，把能被2整除的数挖掉，即把2的倍数挖掉。
<3> 用3去除它后面的各数，把3的倍数挖掉。
<4> 分别用4、5…各数作为除数去除这些数以后的各数。这个过程一直进行到在除数后面的数已全被挖掉为止。例如找1～50的素数，要一直进行到除数为47为止（事实上，可以简化，如果需要找1～n范围内素数表，只需进行到除数为n^2(根号n)，取其整数即可。例如对1～50，只需进行到将50^2作为除数即可。）

如上算法可表示为：

#include <iostream>
#include <cmath>
//#include "Prime.h"

int main()
{
    int array[101];
        int i, j;

    for(i = 2; i <= 100; i++)
        array[i] = i;

    for(i = 2; i < (int)sqrt(100); i++)
    {
        if(array[i] != 0)
        {
            for(j = i + 1; j <= 100; j++)
            {
                if((array[j] != 0) && (array[j] % array[i] == 0))
                {
                    array[j] = 0;
                }
            }
        }
    }

    for(i = 2; i <= 100; i++)
    {
        if(array[i] != 0)
            std::cout << array[i] << std::endl;
    }

    return 0;
}

远风 2009-06-20 21:04 发表评论

Dijkstra算法

远风 — Fri, 12 Dec 2008 07:53:00 GMT

Dijkstra算法是比较典型的最短路径算法，主要用来计算无向图中单源到其他所有节点的最短路径，且图中权值必须是非负权值。Dijkstra的主要特点是以源点为中心向外层层扩展，直到扩展到终点为止。

然而，虽然Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。

其算法描述如下：

(1)设S为最短距离已确定的顶点集（看作红点集），V-S是最短距离尚未确定的顶点集（看作蓝点集）。从源点s到终点v的最短路径简称为v的最短路径；s到v的最短路径长度简称为v的最短距离，并记为SD(v)。

(2)初始化。初始化时，只有源点s的最短距离是已知的(SD(s)=0)，故红点集S={s}，蓝点集为其他节点。源点到个节点的最短距离为连接源点和各节点的边值，若从源点到节点的路径不存在，则可假设该节点的最短路径是一条长度为无穷大的虚拟路径。

(3)在当前蓝点集中选择一个最短距离最小的蓝点来扩充红点集，以保证算法按路径长度递增的次序产生各顶点的最短路径。
PS：
        根据按长度递增序产生最短路径的思想，当前最短距离最小的蓝点k的最短路径是：
    　源点，红点1，红点2，…，红点n，蓝点k
        距离为：源点到红点n最短距离 + <红点n，蓝点k>边长
    　为求解方便，设置一个向量D[0．．n-1]，对于每个蓝点v∈ V-S，用D[v]记录从源点s到达v且除v外中间不经过任何蓝点(若有中间点，则必为红点)的“最短”路径长度（简称估计距离）。
    　若k是蓝点集中估计距离最小的顶点，则k的估计距离就是最短距离，即若D[k] = min{D[i] i∈V-S}，则D[k] = SD(k)。
    　初始时，每个蓝点v的D[c]值应为权w，且从s到v的路径上没有中间点，因为该路径仅含一条边。

(4)k扩充红点集s后，蓝点集估计距离的修改。
PS：
        将k扩充到红点后，剩余蓝点集的估计距离可能由于增加了新红点k而减小，此时必须调整相应蓝点的估计距离。
    　对于任意的蓝点j，若k由蓝变红后使D[j]变小，则必定是由于存在一条从s到j且包含新红点k的更短路径：P=。且D[j]减小的新路径P只可能是由于路径和边组成。
    　所以，当length(P)=D[k]+w小于D[j]时，应该用P的长度来修改D[j]的值。

(5)当蓝点集中仅剩下最短距离为∞的蓝点，或者所有蓝点已扩充到红点集时，s到所有顶点的最短路径就求出来了。

以下是Dijkstra算法的伪代码：

Dijkstra(G，D，s)
{
    //以下是初始化操作
    S={s};
    D[s]=0;       //设置初始的红点集及最短距离
    for(all i 属于 V-S )do //对蓝点集中每个顶点i，设置i初始的估计距离为w
        D[i]=G[s][i];

    //以下是扩充红点集
    for (i=0;i<n-1;i++) do
    {
        //最多扩充n-1个蓝点到红点集
        D[k]=min{D[i]：all i V-S}； //在当前蓝点集中选估计距离最小的顶点k

        if(D[k]等于∞)
            return； //蓝点集中所有蓝点的估计距离均为∞时，表示这些顶点的最短路径不存在。

        S=S∪{k}； //将蓝点k涂红后扩充到红点集

        for(all j∈V-S)do   //调整剩余蓝点的估计距离
        {
            if(D[j]>D[k]+G[k][j])
            {
                //新红点k使原D[j]值变小时，用新路径的长度修改D[j]，使j离s更近。
                D[j]=D[k]+G[k][j]；
            }
        }
    }
}

远风 2008-12-12 15:53 发表评论

AVL树总结

远风 — Wed, 10 Dec 2008 07:04:00 GMT

首先给AVL树下个定义：
一棵AVL树或者是空树，或者是具有下列性质的二叉搜索树：它的任意节点的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。

下面做简要分析：
(1)AVL树首先是个二叉搜索树，对任意节点a，比a数值小的节点在左子树上，比a数值大的节点在右子树上。
(2)AVL树高度平衡。每个结点附加一个数字，给出该结点右子树的高度减去左子树的高度所得的高度差。这个数字即为结点的平衡因子balance。根据AVL树的定义，任一结点的平衡因子只能取 -1，0、1。假设有N个节点，那么其高度可保持在O(log2n)，平均搜索长度也可保持在O(log2n)。
(3)添加节点导致不平衡时，需进行平衡化旋转。

平衡化旋转：

平衡化旋转有两类：
(1)单旋转 (左旋和右旋)
(2)双旋转 (左平衡和右平衡)

每插入一个新结点时，AVL树中相关结点的平衡状态可能会发生改变。因此，在插入一个新结点后，需要从插入位置沿通向根的路径回溯，检查各结点的平衡因子(左、右子树的高度差)。如果在某一结点发现高度不平衡，停止回溯。

从发生不平衡的结点起，沿刚才回溯的路径取直接下两层的结点。此时分为两种情况：
(1)如果这三个结点处于一条直线上，则采用单旋转进行平衡化。单旋转可按其方向分为左单旋转和右单旋转，其中一个是另一个的镜像，其方向与不平衡的形状相关。
(2)如果这三个结点处于一条折线上，则采用双旋转进行平衡化。双旋转分为先左后右和先右后左两类。

假设以上三个节点从上至下分别为A、B、C，则有：
(1)右单旋转：
以节点B为轴，节点A顺时针旋转，成为节点B的右儿子，节点B原右子树成为节点A的左子树。
(2)左单旋转：
以节点B为轴，节点A逆时针旋转，成为节点B的左儿子，节点B原左子树成为节点A的右子树。
(3)左右双旋转：
节点C和节点B逆时针转动，C成为节点A的左儿子，B成为C的左儿子，且C的左子树成为B的右子树；然后再进行右单旋转。
(4)右左双旋转：
节点C和节点B顺时针转动，C成为节点A的右儿子，B成为C的右儿子，且C的右子树成为B的左子树；然后再进行左单旋转。

AVL树的插入

从一个空树开始，给定输入序列，要求建立AVL树，此时涉及到AVL树的插入问题。在插入时需要判断每个节点的平衡因子，并在失去平衡时用到之前所说的旋转平衡。

插入函数执行将值为x的新节点插入到AVL树的恰当位置，并做平衡处理的功能。
(1)先判断是否为空树，若是则为新节点动态分配存储空间，然后置success为1，再将taller置为1。如果不是，根据新节点与根节点的大小判断，分成左右子树两种情况讨论，做下述操作。
(2)算法从树的根结点开始，递归向下找插入位置。在找到插入位置(空指针)后，为新结点动态分配存储空间，将它作为叶结点插入，并置success为1，再将taller置为1，以表明插入成功。在退出递归沿插入路径向上返回时做必要的调整，即判断是否需要旋转平衡。

AVL树的删除

如果被删结点x最多只有一个子女，那么问题比较简单。如果被删结点x有两个子女，首先搜索x 在中序次序下的直接前驱 y (同样可以找直接后继)。再把结点y 的内容传送给结点x，现在问题转移到删除结点y。

将结点y从树中删去。因为结点y最多有一个子女，我们可以简单地把y的父亲结点中原来指向y的指针改指到这个子女结点；如果结点y没有子女，y父亲结点的相应指针置为NULL。然后将原来以结点y为根的子树的高度减1，必须沿x 通向根的路径反向追踪高度的变化对路径上各个结点的影响。

详细内容和源代码可以参看以下链接：
http://spec.cumtcs.net/%CA%FD%BE%DD%BD%E1%B9%B9(%D0%C2)/%CA%FD%BE%DD%BD%E1%B9%B9/lesson/ch07/0706.html

远风 2008-12-10 15:04 发表评论