BlogJava-我的漫漫程序之旅-文章分类-数据结构与算法

关于蚂蚁问题（Ants）

々上善若水々 — Mon, 12 May 2008 01:07:00 GMT

原文地址:
http://www.blogjava.net/dreamingnest/archive/2008/05/10/199672.html

之前看有的朋友谈百度的一道面试试题－蚂蚁问题（有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间）。关于这道题目，网上给出了很多的解释，但从整体来看，基本都是用到了等价置换（等量代换）的思想。要求最小时间，即为“最不容易”先到达两端的蚂蚁以最短的时间到达，所以我们只需找到所有蚂蚁中间的一只（共奇数只蚂蚁）或两只（共偶数只蚂蚁）到达一端的最短时间。比较麻烦的是求最长时间，有人会觉得当有很多只蚂蚁时，中间的蚂蚁们相互碰撞的次数多些会增加时间，感觉上比较复杂，可如果我们用等量代换的思想来解释就比较容易。假设中间的任意两只相邻蚂蚁即将发生碰撞，如：A －> <－B，当A，B发生碰撞后，便有<－A B－>。A，B反向相当于<－B A －> ，即二者继续向着原来的方向前进，对于任意相邻的发生碰撞的蚂蚁都适用，所以只需求最两端的两只蚂蚁距离两端的最远距离。由以上分析可知，如果出这样的问题，我们可以不用通过程序便能说出结果：5个点，中间蚂蚁的位置为11，即0－11－27，显然最小为11，最两端蚂蚁，0－3－27，最大为24，0－23－27，最大为23，所以最大为24。对于这个题，给出如下Java代码（随便写了几句，不符合面向对象思想）。

public class Ant {
    public static void main(String[] args){
        int length=27,points=5,min=0,max=0,temp_min=0,temp_max=0;
        int[] pos={3,7,11,17,23};
        for(int i: pos){
            temp_min=i>length-i?length-i:i;
            temp_max=i<length-i?length-i:i;
            if(temp_min>min)
                min=temp_min;
            if(temp_max>max)
                max=temp_max;
        }
        System.out.println("最短时间:"+min+"  最长时间:"+max);
    }
}

有了如上的想法，我们能做出判断，为什么还要写代码呢？其实这个问题出自Waterloo Local Contest Sep.19,2004 准确描述如下：

An army of ants walk on a horizontal pole of length l cm, each with a constant speed of 1 cm/s. When a walking ant reaches an end of the pole, it immediatelly falls off it. When two ants meet they turn back and start walking in opposite directions. We know the original positions of ants on the pole, unfortunately, we do not know the directions in which the ants are walking. Your task is to compute the earliest and the latest possible times needed for all ants to fall off the pole.
The first line of input contains one integer giving the number of cases that follow. The data for each case start with two integer numbers: the length of the pole (in cm) and n, the number of ants residing on the pole. These two numbers are followed by n integers giving the position of each ant on the pole as the distance measured from the left end of the pole, in no particular order. All input integers are not bigger than 1000000 and they are separated by whitespace.

For each case of input, output two numbers separated by a single space. The first number is the earliest possible time when all ants fall off the pole (if the directions of their walks are chosen appropriately) and the second number is the latest possible such time.

Sample Input
2
10 3
2 6 7
214 7
11 12 7 13 176 23 191

Sample Output
4 8
38 207

在这里给出相应的c++代码：

#include<iostream>
using namespace std;
int main()
{
    int cases,l,n,min,max,temp_min,temp_max,pos;
    cin>>cases;
    while(cases--)
    {
        cin>>l>>n;
        min=0;
        max=0;
        while(n--)
        {
            cin>>pos;
            temp_min=pos>l-pos?l-pos:pos;
            temp_max=pos<l-pos?l-pos:pos;
            if(temp_min>min)
                min=temp_min;
            if(temp_max>max)
                max=temp_max;
        }
        cout<<min<<' '<<max<<endl;
    }
    return 0;
}

々上善若水々 2008-05-12 09:07 发表评论

B树、B-树、B+树、B*树详解

々上善若水々 — Mon, 10 Mar 2008 10:29:00 GMT

B树

即二叉搜索树：

1.所有非叶子结点至多拥有两个儿子（Left和Right）；

2.所有结点存储一个关键字；

3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树；

如：

B树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中；否则，如果查询关键字比结点关键字小，就进入左儿子；如果比结点关键字大，就进入右儿子；如果左儿子或右儿子的指针为空，则报告找不到相应的关键字；

如果B树的所有非叶子结点的左右子树的结点数目均保持差不多（平衡），那么B树的搜索性能逼近二分查找；但它比连续内存空间的二分查找的优点是，改变B树结构（插入与删除结点）不需要移动大段的内存数据，甚至通常是常数开销；

如：

但B树在经过多次插入与删除后，有可能导致不同的结构：

右边也是一个B树，但它的搜索性能已经是线性的了；同样的关键字集合有可能导致不同的树结构索引；所以，使用B树还要考虑尽可能让B树保持左图的结构，和避免右图的结构，也就是所谓的“平衡”问题；

实际使用的B树都是在原B树的基础上加上平衡算法，即“平衡二叉树”；如何保持B树结点分布均匀的平衡算法是平衡二叉树的关键；平衡算法是一种在B树中插入和删除结点的策略；

B-树

是一种多路搜索树（并不是二叉的）：

1.定义任意非叶子结点最多只有M个儿子；且M>2；

2.根结点的儿子数为[2, M]；

3.除根结点以外的非叶子结点的儿子数为[M/2, M]；

4.每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）

5.非叶子结点的关键字个数=指向儿子的指针个数-1；

6.非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；

7.非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；

8.所有叶子结点位于同一层；

如：（M=3）

B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点；

B-树的特性：

1.关键字集合分布在整颗树中；

2.任何一个关键字出现且只出现在一个结点中；

3.搜索有可能在非叶子结点结束；

4.其搜索性能等价于在关键字全集内做一次二分查找；

5.自动层次控制；

由于限制了除根结点以外的非叶子结点，至少含有M/2个儿子，确保了结点的至少利用率，其最底搜索性能为：

其中，M为设定的非叶子结点最多子树个数，N为关键字总数；

所以B-树的性能总是等价于二分查找（与M值无关），也就没有B树平衡的问题；

由于M/2的限制，在插入结点时，如果结点已满，需要将结点分裂为两个各占M/2的结点；删除结点时，需将两个不足M/2的兄弟结点合并；

B+树

B+树是B-树的变体，也是一种多路搜索树：

1.其定义基本与B-树同，除了：

2.非叶子结点的子树指针与关键字个数相同；

3.非叶子结点的子树指针P[i]，指向关键字值属于[K[i], K[i+1])的子树（B-树是开区间）；

5.为所有叶子结点增加一个链指针；

6.所有关键字都在叶子结点出现；

如：（M=3）

B+的搜索与B-树也基本相同，区别是B+树只有达到叶子结点才命中（B-树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找；

B+的特性：

1.所有关键字都出现在叶子结点的链表中（稠密索引），且链表中的关键字恰好是有序的；

2.不可能在非叶子结点命中；

3.非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层；

4.更适合文件索引系统；

B*树

是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针；

B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3（代替B+树的1/2）；

B+树的分裂：当一个结点满时，分配一个新的结点，并将原结点中1/2的数据复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针；

B*树的分裂：当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字（因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针；

所以，B*树分配新结点的概率比B+树要低，空间使用率更高；

小结

B树：二叉树，每个结点只存储一个关键字，等于则命中，小于走左结点，大于走右结点；

B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点；

所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；

B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中；

B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；

々上善若水々 2008-03-10 18:29 发表评论

策略模式及实现

々上善若水々 — Fri, 07 Mar 2008 01:39:00 GMT

策略模式，又叫算法簇模式，就是定义了不同的算法族，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

策略模式的好处在于你可以动态的改变对象的行为。设计原则是把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口（c++z中可以用虚类），然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。下面是一个例子。

/*
这是一个表现僧人和道士的程序，僧人光头，使用棍子做武器，道士长小胡子，使用拂尘作武器
*/

//处理长相接口
interface LooksBehavier
{
  public void display();
}

//处理所使用的武器接口
interface WeaponBehavier
{
public void useWeapon();
}

//角色基类
class Role {
  public int heght; //身高
  public int sex; //性别
  public WeaponBehavier weapon; //处理武器接口的实例
  public LooksBehavier looks; //处理长相的接口的实例
  public void display() //显示长相
  {
    looks.display();
  }

public void weapon() //设置所使用的武器
{
  weapon.useWeapon();
}

}

//道士长相类，实现了长相接口
class TaoistBehavier implements LooksBehavier
{
  public void display() //实现接口函数
{
  System.out.println("I'm a taolist with long white goatee");
}

}

//和尚长相类，实现了长相接口
class BonzeBehavier implements LooksBehavier
{
  public void display() //实现接口函数
  {
    System.out.println("I'm a Bonze with no hair");
  }

}

//道士武器类，实现了处理武器接口
class TaoistWeapon implements WeaponBehavier
{
  public void useWeapon() //实现了处理武器接口函数
  {
    System.out.println("My weapon is horsetail whisk");;
  }
}

//和尚武器类，实现了处理武器接口
class BonzeWeapon implements WeaponBehavier
{
  public void useWeapon() //实现了处理武器接口函数
{
  System.out.println("My weapon is truncheon");;
}
}

//道士
class Taoist extends Role
{
  public Taoist()
{
  looks = new TaoistBehavier();
  weapon = new TaoistWeapon();
}
}

//和尚
class Bonze extends Role
{
  public Bonze()
  {
   looks = new BonzeBehavier();
   weapon = new BonzeWeapon();
  }
public void changeWeapon()
{
  weapon = new TaoistWeapon();
  System.out.println("change weapon");
}
}

public class RoleBase{
  public static void main(String [] arg)
  {
    Taoist taoistObj = new Taoist();
    Bonze bonzeObj = new Bonze();
    taoistObj.display();
    taoistObj.weapon();
    bonzeObj.display();
    bonzeObj.weapon();
    bonzeObj.changeWeapon(); //改变和尚使用的武器
    bonzeObj.weapon();
  }
}

输出结果为:

I'm a taolist with long white goatee
My weapon is horsetail whisk
I'm a Bonze with no hair
My weapon is truncheon
change weapon
My weapon is horsetail whisk

々上善若水々 2008-03-07 09:39 发表评论

以单向循环链表求解约瑟夫环问题Java版

々上善若水々 — Mon, 31 Dec 2007 01:59:00 GMT

摘要: 约瑟夫环（Josephus）问题：古代某法官要判决n个犯人的死刑，他有一条荒唐的法律，将犯人站成一个圆圈，从第s个人开始数起，每数到第d个犯人，就拉出来处决，然后再数d个，数到的人再处决……直到剩下的最后一个可赦免. 结点类:OneLinkNode: package com; /** *//** * 结点类 *... 阅读全文

々上善若水々 2007-12-31 09:59 发表评论

单向链表的简单实现

々上善若水々 — Sat, 29 Dec 2007 04:08:00 GMT

摘要: 要求:写一个示例程序,显示一个单链表.这个链表的功能: 1.在链表头插入一个数据项 2.在链表头删除一个数据项 3.遍历链表显示它的内容实现代码如下: package com; /** *//** * 结点类 * @author zdw * */ class Link... 阅读全文

々上善若水々 2007-12-29 12:08 发表评论

以顺序表求解约瑟夫环问题的Java实现

々上善若水々 — Fri, 28 Dec 2007 12:35:00 GMT

摘要: 约瑟夫环（Josephus）问题：古代某法官要判决n个犯人的死刑，他有一条荒唐的法律，将犯人站成一个圆圈，从第s个人开始数起，每数到第d个犯人，就拉出来处决，然后再数d个，数到的人再处决……直到剩下的最后一个可赦免。 LinearList: package com; /** *//** * 线性表的存储结构 ... 阅读全文

々上善若水々 2007-12-28 20:35 发表评论

辗转相除法原理及Java实现

々上善若水々 — Fri, 28 Dec 2007 04:41:00 GMT

package com;

public class GcdTest
{
    //循环实现
    int gcd1(int a, int b)
    {
        int k = 0;
        do
        {
            //得到余数
            k = a % b;
            //根据辗转相除法,把被除数赋给除数
            a = b;
            //余数赋给被除数
            b = k;
        } while (k != 0);
        //返回被除数
        return a;
    }
    //逆归实现
    int gcd2(int a,int b)
    {
        //直到满足此条件逆归退出
        if(b == 0)
        {
            return a;
        }
        if(a < 0)
        {
            return gcd2(-a,b);
        }
        if(b < 0)
        {
            return gcd2(a,-b);
        }
        return gcd2(b,a % b);
    }

    public static void main(String[] args)
    {
        GcdTest gt = new GcdTest();
        System.out.println(gt.gcd1(888,458));
        System.out.println(gt.gcd2(888, 458));
    }

}

々上善若水々 2007-12-28 12:41 发表评论