公司与客户签订的是一个长期的IT外包大合同，包括软件，硬件，服务等等。从另外一个角度来说，包括开发，维护，BI等等。这么大的合同客户与外包商是如何实施与执行的？如何保证客户的Business一如既往地运行，并且还更好地受益于IT的外包呢？我试着从我的team角度，以及从我所能得到的信息尽量来理解这个大的合同是如何实施与执行的。尽管这只是对这个IT外包大合同管中窥豹，但我希望我的文字也能让更多的人认识一个外包案例，也希望能和此案例有兴趣的做IT外包的方方面面的专家和公司探讨。

　　我的team为客户公司各种信息系统提供技术支持，是大IT外包合同下的一个维护项目，负责客户business中的Europe和Asia区。客户的US business不在我team的support scope内，但有时候需要与US的一些team打交道。这里US port就不予仔细考虑。

　　由于客户把IT外包给我们，客户方就不用招聘很多的IT人员，大部分的工作依照外包合同都由外包服务提供者来完成(我们公司并不是客户唯一的外包商，某些方面的服务还外包给了其他专业公司，如HelpDesk的工作和服务器维护就外包给了HP——HP的HelpDesk非常不错，而且服务器就是HP服务器^_^)。因此，绝大多数客户方的IT人员都是外包合同的执行参与者与项目管理者。客户对自己的IT部门人员所进行的培训除了必要的business培训，就是leadership的培训。

　　客户是一家全球500强企业，Business非常多，客户的IT工作量也非常大。那么客户如何与外包商合作、沟通、实施这么大的外包合同呢？这就有必要提到外包商的customer relationship management team。 这个team和客户的management team密切合作，交换意见，共同研究合同的实施与改进，并致力于与客户关系的建立。因为合同签订的出发点就是双方都能从合同中受益，双方都有责任和义务帮助对方提高Business和收益，要不然，这个长期的合同可能没多久就会被Close。

　　customer relationship management team经常会和客户一起评估当前的business以及IT的服务情况，做一些必要的变化。这不，去年Europe刚被merge into Asia的管理team，才一年的时间，由于这一年客户Business的变化，Europe的Business变的重要起来，今年就又要 seperate出去，成立独立的management team，方便更好地support Business。

　　客户和BRM(Business relationship manager)一起评估project的大小，需要多少resource，然后我们(外包商)就开始project team的招兵买马，作为客户的Contract员工组成客户的IT部门。所谓Contract员工就是人是我们招的，和客户签聘用合同，我们为客户工作，每个resource每小时多少钱客户付给我们公司，我们来进行人员管理，客户只关注项目上的事。(我们有时候叫自己公司为人贩子公司，从另一方面来公司做的是目前时髦的人力猎头工作，只不过人都先招过来了，推荐合适的供客户挑选。呵呵)

　　客户把整个IT部门分成很多team，各team负责不同的工作，彼此间又相互支持。除了与程序直接打交道的各种Business team外，其中IT部门的HelpDesk team、Database workgroup、CTO team、Common application team和Ops team与我们team联系最密切。前面几个team一看就知道他们做什么的，我稍微解释一下Common application team和Ops team做什么。

　　Common application team顾名思义就是负责一些Common applications的，比如客户要求所有程序都是SSO(Single Sign On) enable的，这就需要有个系统能实现SSO的需求，保证程序的访问安全，并统一利用公司的员工信息库，保证信息的一致，防止各系统“各自为政”，减少重复工作。客户是使用的Site Minder作为SSO服务器，那么SSO的配置与维护就是一个Common的工作，这就是Common application team要做的事。当然，还有很多这样的Common application。

　　Ops team一般负责系统的CCM(Change Control Management)中的deploy。如果系统做了改动，在客户同意执行change后，Ops team就会执行这次change。
 
除了以上这些team，IT部门还有Data Warehouse team，ERP team等其他team，虽然与他们也打交道，但由于不是经常性的，这里就不专门介绍。

　　好了，那么我们到底如何来support Business的呢？

　　所有的team如何执行自己的职责在project的小合同中都有说明。其中如何处理客户的issue与需求，哪些事情是哪个team的scope都在 escalation chart中明确定义了的，然后让HelpDesk拿着这些escalation chart来处理。HelpDesk是在做IT系统维护时各个IT support team与Business之间唯一的联系点(SPOC - Single point of Contact)。当然，这是理想状态，也有Business用户直接联系我们的。

　　HelpDesk接到用户escalate的issue后，先自己做初步的分析，如果HelpDesk能自己解决，问题就不会再往下传递了；如果是 Business方面的问题，用户把问题发到用户的队列中，并跟踪问题什么时候关闭；如果是我们系统技术方面的问题或Bug，HelpDesk就按照前面定义的escalation chart，把问题dispatch到我们team的队列中；如果是其他team的范围也同样的process。因为所有的程序在交给我们team(或其他team)之前就定义了程序的信息，专门有team来维护所有程序的信息。根据客户对所有Business的评估，把相应的程序分为不同的重要程度，这样所有的问题也都根据对Business的影响程度定义了几种不同的紧急程度，再定义了每种紧急程度的问题需要在规定的时间内解决。用户定义了一些 metrics用来度量我们服务的质量，并规定了可需要达到的值。这些都在project的合同中定义，双方签字同意。这就是传说中的SLA (Service Level Agreement)^_^。相应地，我们也在我们公司(外包商)的project Plan中阐述客户的metrics，让所有member都知道并执行，保证meet客户的SLA。

　　当问题被dispatch到我们的队列中后，我们就需要在SLA规定的时间内解决问题。每周，专门的Monitor team会从工具中run出各个team这周服务的report，查看是否meet SLA。甚至那些对Business非常重要的系统每天就有report，然后report给management team。这也是客户对我们考核的一个重要指标。

　　由于我们中国的team要support客户Europe和Asia的系统，欧洲客户与中国有6个小时时差，这要求我们的team有灵活的上班安排，来 meet客户的Business时间。我们把team分成2部分，一部分support欧洲程序，一部分support亚洲程序。由于我们公司在中国只是一个分公司，印度还有team，印度和中国也有2个小时时差，所以我们安排中国team上 下午班，这样下班不用太晚；印度team同样上 下午班，但他们和欧洲只有4个小时时差，这样就可以更好地meet客户的Business时间。

　　当然有US的程序，上班时间又有些不同。在其他时间team的member提供On Call support。所谓On Call Support就是说在这段时间内，如果我们support的系统有问题，用户或HelpDesk可以Call我们的工作Cell Phone，我们就可以马上登陆到内部工作环境，开始移动办公。

配置方法，不同的版本的配置可能有变化，如不成功，可以自行察看文档。

Pulto在Tomcat下的安装配置方法：
（1） 从http://portals.apache.org/pluto/mirrors.cgi下载最新的二进制版本安装文件
（2） 执行%pluto%/bin/install，将它安装到Tomcat目录下即可
（3） 在浏览器中输入：http://localhost:8080/pluto/portal，运行Pluto

Liferay Professional在Tomcat下的安装配置方法：
（1） 从http://www.liferay.com/downloads/index.jsp下载Liferay Professional安装文件；
（2） 解压ZIP包到某个目录下
（3） 若下载Tomcat版本的Liferay安装文件，则不需再装Tomcat，直接启动bin目录下的startup.bat文件。
（4） 在浏览器中输入http://localhost/运行Liferay Professional。

eXo Platform在Tomcat下的安装配置方法：
（1） 从http://www.exoplatform.com/portal/faces/public/exo 下载eXo Platform的安装包。
（2） 解压ZIP包到某个目录下
（3） 若下载Tomcat版本的eXo安装文件，则不需再装Tomcat，直接启动bin目录下的startup.bat文件。
（4）  在浏览器中输入http://localhost/ 运行eXo Platform.

Jetspeed2在Tomcat下的安装配置方法：
（1） 从http://www.apache.org/dist/portals/jetspeed-2/ 下载Jetspeed2 M1或M2版本安装包。
（2） 若是安装包中已经捆绑Tomcat，解压即可。若安装包不含Tomcat，先安装Tomcat，然后将安装包解压到Tomcat目录，并覆盖相关文件即可。
（3） 安装要注意的问题有：Jetspeed2M1版本由于Bug无法安装Tomcat5.5上（此BUG见http://issues.apache.org/jira/browse/JS2-187）；Jetspeed2必须安装在Tomcat5.0.28以上版本上，否则低版本由于JAAS问题无法登陆；
（4） 启动jetspeed-database目录下的start-database.bat，启动数据库；
（5） 启动Tomcat；
（6） 在浏览器中输入http://localhost:8080/jetspeed/portal 运行Jetspeed；

emoticontext [id=atom(buddyname)]
    {
        layoutpos: left;
        fontweight: normal;
        contentalign: bottomleft | endellipsis;
        padding: rect( 0, 0, 0, 0 );
        richeditstyle: PlainText | HideSelection | DisableDrag | ReadOnly;
    }

此文来自雨吁

　　根据进程名查杀

　　这种方法是通过WinXP系统下的taskkill命令来实现的，在使用该方法之前，首先需要打开系统的进程列表界面，找到病毒进程所对应的具体进程名。

　　接着依次单击“开始→运行”命令，在弹出的系统运行框中，运行“cmd”命令；再在DOS命令行中输入“taskkill /im aaa”格式的字符串命令，单击回车键后，顽固的病毒进程“aaa”就被强行杀死了。比方说，要强行杀死“conime.exe”病毒进程，只要在命令提示符下执行“taskkill /im conime.exe”命令，要不了多久，系统就会自动返回如图所示的结果。

　　根据进程号查杀

　　上面的方法，只对部分病毒进程有效，遇到一些更“顽固”的病毒进程，可能就无济于事了。此时你可以通过Win2000以上系统的内置命令——ntsd，来强行杀死一切病毒进程，因为该命令除System进程、SMSS.EXE进程、CSRSS.EXE进程不能“对付”外，基本可以对付其它一切进程。但是在使用该命令杀死病毒进程之前，需要先查找到对应病毒进程的具体进程号。

　　考虑到系统进程列表界面在默认状态下，是不显示具体进程号的，因此你可以首先打开系统任务管理器窗口，再单击“查看”菜单项下面的“选择列”命令，在弹出的设置框中，将“PID（进程标志符）”选项选中，单击“确定”按钮。返回到系统进程列表页面中后，你就能查看到对应病毒进程的具体PID了。

　　接着打开系统运行对话框，在其中运行“cmd”命令，在命令提示符状态下输入“ntsd -c q -p PID”命令，就可以强行将指定PID的病毒进程杀死了。例如，发现某个病毒进程的PID为“444”，那么可以执行“ntsd -c q -p 444”命令，来杀死这个病毒进程。

ç

2005年５月

è

日

一

二

三

四

五

六

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

    javascript对于做过Web程序的人不应该是陌生，初期是用来做一些简单的FORM验证，基本上是在玩弄一些技巧性的东西。IE 4.0引入了DHTML，同时为了对抗Netscape的javascript,提出了自己的脚本语言JScript，除了遵循EMAC的标准之外，同时增加了许多扩展，如下要提到的OOP编程就是其中的一个，为了命且概念，我以下提到的javascript都是Microsoft Internet Explorer 4.0以上实现的JScript,对于Netscape，我没有做过太多的程序，所以一些的区别也就看出来。

    javascript不是一个支持面向对象的语言，更加算不上一个开发平台，但是javascript提供了一个非常强大的基于prototype的面向对象调用功能，你可以在你自己需要的地方使用他们。因此,如何使用对象？本文尽可能从javascript面向对象实现原理出发，解析清楚它的工作模型。在了解这些模型之后，你可以在自己的脚本库中编写一些实现代码，然后在其他地方调用。

    javascript的语法和C++很接近，不过在类实现中没有使用关键字Class,实现继承的时候也没有采用传统的Public或者Implement等等所谓的关键字来标示类的实现。这样的情况下，可能有就有人会问，如何编写javascript的Class，如何实现继承。我开始也是百思不得其解，后来看了MSDN,才知道采用了prototype来实现，包括继承和重载，也可以通过这个关键字来实现。

    javascript的函数很奇怪，每个都是默认实现了Optional的，即参数都可以可选的，function a(var1,var2,var3),在调用的过程中a(),a(value1),a(value1,value2)等等的调用都是正确的，至少在即使编译部分可以完整通过，至于其它，只是和函数的实现逻辑比较相关了。

    以下就JS对于类的实现、继承、重载详细介绍其实现方式。

    1。实现

    Js类的实现就通过函数直接实现的，每个函数可以直接看成class，如下代码

    function ClassTest1(){

        ...//implement code

    }

    var a=new ClassTest1

    function ClassTest2(var1){

        ...//implement code

    }

    var b=new ClassTest("value")

    对于类的属性，可以通过两种方式实现

    1）this."<Property or Method"的方式实现，在类声明函数中直接给出函数的实现，如 this.Add=new function(strUserName,strPassword)这样的方式调用，编写的方式在Class Function中调用。

    2）通过ClassFunction.prototype.[FunctionName]=function(var1,var2...){//todo}这样的方式完成调用。

    这两种方式从目标来看是一致的，按照我个人的观点来看，区别的只是在于实现方式，通过this.propertyName的方式来创建，Jscript自动创建了property或者method的入口，不过从程序的角度而言，还是使用prototype的关键字实现比较灵活。

    另外javascript也可以和我们C++中那种嵌套声明的方法来声明,C++实现的方法如下

    Public Class ClassName:ParentClass{

        Public DataType FunctionName(){

        }

        Public Class ClassName{

            Public DataType FunctionName(){

            }

        }

    }

    在javascript当中，当然不存在class这样的关键字了,所以实现起来有点戏剧性，不过仍然为一个非常巧妙的实现。

    function className(){

        //Property Implement

        this.UserName="blue";

        //Method Implement

        this.Add=new function(){

        }

        //Sub Class Implement

        function SubClassName(){

            this.PropertyName="hi"            

        }

        //sub class method implement

        SubClassName.prototype.Change=function{

        }

    }

    //Main Class Method Implement

    className.prototype.Delete=function(){

    }

    如上的代码大致演示了javascript类中属性和方法的实现，另外有一点比较困惑，整个class中都是public的，没有关键字private之类的可以控制某些方法是否隐藏，那么在我们编写代码实现的规范中，我看国外一些程序员都是使用_functionName这样子为函数命的方法来区分，但是在调用过程中实际还可以调用的。

    实现了属性和方法，剩下的就是Event的实现了，我查找了许多资料，包括整个MSDN关于JScript的参考，都没有看到一个很好的模型关于事件实现的，后来参考了一些站点编写HTA(HTML Component,有空我会写一些相关的文章）的实现，借助于比较扭曲（我个人认为）的方法可以大致的实现基于事件驱动的功能。大致的思路是这样子的：

    1）.将所有的事件定义成属性，只要简单的声明就可以

    2）.在需要触发事件的代码中判断事件属性是否是一个函数，如果是函数，直接执行函数代码，如果是字符串，那么执行字符串函数，通过eval(str)来执行。

    3) .在类的实例当中注册事件函数。

    为了简单说明如上的思路，采用timer这样简单的例子来表述如上的所提到的内容，如果只是为了简单的实现timer的功能，javascript中setInterval函数就可以满足全部的要求，如下的代码只是用来说明Timer的工作原理。

//Class For Timer
function Timer(iInterval){
 //if not set the timer interval ,then defalut set to 500ms
 this.Interval=iInterval || 500;
 this._handleInterval;
 this.TimerEvent=null
 function Start(){
  if(this.Interval!=0){
   this._handleInterval=setInterval("TimerCallBack()",this.Interval);
  }
 }
 function Start(){
  clearInterval(this._handleInterval);
 }
 function TimerCallBack(){
  if (typeof this.TimerEvent=="function"){
   this.TimerEvent();
  }
  else if(this.TimerEvent!=null && this.TimerEvent.length>0){
   eval(this.TimerEvent);
  }
 }
} 
//Code for Instance
var t=new Timer(3);

//------------------------------------//

//1.
t.TimerEvent=function(){
//todo
}

//2.
t.TimerEvent="alert(\"hello\")";

//3.

t.TimerEvent=tTimerCall;

//----------------------------------//
t.Start();
t.Stop();

function tTimerCall(){

}

    实际工作代码是在TimerCallBack()上面实现，事件触发作为属性的方式来实现，在应用实例中，代码提供了三种方法去调用事件，不过在事件的回调当中，我还没有想到如何可以带参数，只有才各自的实现当中访问各自需要的属性才能够实现全部的要求。

    2。继承。

    刚采用了大篇幅的文字去介绍如何实现javascript的各种实现，也就是从逻辑上完成了一个封装class的实现，从某种意义上来说，class的实现是真正脚本编程中使用最多的部分，不过如果只是要完成如上的功能，使用VBScript来编写更能更加清晰，毕竟VBscript提供了class关键字，同时提供了public 和private这两个关键字，可以清晰的将公共和私有对象分离，至于事件的实现，也可以采用类似javascript实现的思路，只是对于函数的引用需要采用GetRef这个函数，具体的用法可以参考scripting reference,MSDN里头也有详细的介绍，而javascript强大至于在于如下要说的了，虽然具体的东西可能不多。

    如上所言，我们已经完成了一个基本的类实现Timer，现在要做的是重新编写这个类，我们简单的只是想在这个类之中加入一个方法，提供当前的系统时间，方法的名称为getSystemDate,显然如果全部重新编写，那就失去了我这里说的意义了。先看看如下的实现。

    function NewTimer(iInterval){

        //call super

        this.base=Timer;

        this.base（iInterval);        

    }

    NewTimer.prototype=new Timer;

    NewTimer.prototype.getSystemDate=function(){

        var dt=new Date();

        return dt.getYear()+"-"+dt.getMonth()+"-"+dt.getDay()；

    }

    上述代码实现了NewTimer类，从Timer继承，javascript没有使用“：”或者java的public那样类似的关键字，只是通过newclassname.prototype=new baseclass这样的方法来完成，同时NewTimer实现了getSystemDate的方法，在NewTimer的初始化函数中，我使用了this.base=Timer，是为了引用父类的实现，不过在对于父类其他实现函数的调用，到现在我没有找到一个确定的方法，是否通过this.base.start()那样来调用还是其他的，如果有谁比较清楚的，麻烦告诉我，另外在netscape的站点上，我查到有一个特殊的"__proto__"的属性好像是对于父类的直接引用，不过具体的我也没有尝试过，在msdn中也没有看到对于__proto__的支持。

    3。重载

    或许这个是OOP编程中比较复杂的地方了，在javascript的实现中有点无奈，也就是通过prototype的方式来完成的，不过因为我不清楚如何调用父类的实现函数，那么在重载中只能够重新编写所有的实现了，另外就是在实现中实例化一个父类，然后通过调用它来返回需要的东西。

    javascript中所有的对象都是从Object继承下来的，object提供了toString()的方法，也就是说如果调用alert(objInstance)这样的过程，实际上是调用了alert(objInstance.toString())的方法，如果没有编写实现，object默认的toString()都是"object object"这样子的，在许多地方需要重载这个函数的，比如Timer,如果我们希望var ins=new Timer(5);alert(ins)调用得到的是interval的值5，那么就需要重新编写toString()方法了

    Timer.prototype.toString=function(){ return this.Interval};

    以上代码实现之后alert(ins)得到的就是5了。

　　其实做一个程序员要学很多专业知识，有些知识既枯燥又繁杂,让人头疼，所以我们就用大家喜爱的小游戏来串起我们的课程。愿你学的愉快。

　　这一篇我们将用大家熟知的一种游戏——麻将，来给大家示范一下数据结构这门课的用处。由于笔者的水平有限，文章不可能太深入，旨在抛砖引玉。同时有不正确的地方也恳请各位大虾给于指正。

　　书归正传，我们先来分析一下麻将游戏的整个流程。

　　首先，当玩家开局时要在内存中分出136个整型数组空间，来存放136张麻将牌。然后，用136个整型数来代表136张牌，并将个张牌随机分配到前面分出的136个整型数组空间。这样，整个麻将牌就洗好了。

　　接着，我们可以用1到6的随机数代表榖子,并随着数的变化而显示不同点数的图片。以时间或次数来决定停止的时刻，最后得到的数字就是玩家所掷出的点数，之后就可以用这个数来确定发牌的位置。

　　然后，就是发牌了。在这里我们可以在建立两个长度为13的整型数组空间，以分别存储两个玩家手中的牌。

　　接下来就是最有意思的地方了，也就是玩牌的过程了。先比较对家打出的牌是否可以吃、碰、杠、胡，都没有，就从剩下的牌中一张张的分到每个该摸牌的玩家手中，并计算是否为胡牌，如果是，就提示玩家并让玩家决定是否胡牌；如果不是，就等玩家出牌后，根据是否是同一种牌并按大小顺序排列好。重复这一过程，直到有人胡牌，游戏结束。

　　游戏的流程我们分析完了，怎么实现呢？这也是我们这篇教程的重点。一定好打起精神呀！

　　我们先来看看游戏的第一个流程是怎样实现的。在文章的开始，我谈到了数组（就是具有同一数据类型的，并且位置连续的数据存储空间），用c语言我们可以这样实现。

int pai[136]；// 注意c语言中数组是从0~135

　　那么怎么洗牌呢？通常的思路是用rand（）来产生1~136之间的整型数，并按顺序放入我们刚才分配的用来存放麻将牌的数组空间中。为了不出现重复的数值，可以用产生的新数和前面已放入数组的数比较，如果重复就在从新分配，不重复就放入数组中。

　　下面是实现这一过程的代码。

Void xipai()
{
　int temp;
　temp=(int ) 135*rand()/32565+1;
　for （int i=o；i<136;i++）//按顺序比较136个数组空间
　{
　　if(i=o)
　　　pai[i]=temp; //第一个数直接放入数组
　　else
　　　for(int j=o ;j<i;j++) //和前面放入数组的数比较
　　　{
　　　　if( pai[j]==temp) //有重复的
　　　　　xipai(); //从新取数比较
　　　　else
　　　　　pai[i]=temp; //没重复的,放入数组
　　　}//end for
　}//end for
}//end xipai 

　　在上面的代码中,我们使用了递归的方法,可以说它的效率是比较低的。一方面适应为递归本身对空间的要求,另一方面,就在于这个算法中,要进行多次的比较。举个较极端的例子，如果我们每次取得一个随机整型数都是在前面已经存放过的，那么就要一直从新取数并比较。当然这种可能性极少，但当数组存放有一半以上的数后，这种事情发生的可能性就会成指数的增长。

　　这里我再介绍一种新的方法。前一种算法的弊处在于可能会有重复的数，而进行多次的取数和比较。我们换个思路，就是随机产生0到135的数组位置，按顺序把1~136的数按得到的数存放到相应的数组位置。有人可能会说，难道位置就不会有重复吗？别急，我们继续往下看。

　　我们知道，c语言中对于一个int（整型）数，默认的初始化值是0，所以，我们只要在按顺序比较0到135个数组空间，那些值为0，就可以将数放入其中。这样就保证了不会出现重复的数，而且效率也比前一种方法要高。（大家可以思考一下为什么？我也会在后面给以解答）

　　下面是这种算法的源代码：

void xipai（）
{
　for (int i=1 ; i<=136; i++) //这是要放入的136个整型数
　{
　　int a= (int)135 * rand()/32767+1; //随机产生位置
　　if(pai[a]==0) //判断此位置是否为空
　　{
　　　pai[a]=i; //空，放入其中
　　}
　　else //不空
　　{
　　　for(int j=0;j<=135;j++) //比较所有数组空间
　　　{
　　　　if(pai[j]==0) //找到空闲的位置
　　　　　pai[j]=i; //放入其中
　　　 }//end for
　　}// end if
　} //end for
}//end xipai

　　这种算法之所以比前一种效率高，原因就在于他即使每次得到的位置都不为空，也顶多搜索136遍，而前一种算法是最坏的可能是想不出的糟糕的。

　　第一篇我们用数组实现了洗牌的步骤。当然还有其他的方法。这也就是编程的带给我们的乐趣——灵活，自由。只要你想不得到，没有你做不到的。

　　今天我们就来实现第二步。掷色子，发牌。

　　掷色子的问题，其实很简单，但涉及到动画制作的原理。所以我们先来补充些这方面的知识。

　　我们知道，人的视觉都有一种现象，比如当你在黑暗中看灯泡时，突然灯泡熄灭了，但灯泡发光的影像还会在我们眼前停几秒钟，这就是我们熟知的“视觉暂留效果”。我们所看到的电视、电影，包括我们说熟知的flash，director等动画制作软件，都是依赖这个效果才实现的。当我们在高速状态下（一般是每秒24帧），按一定的顺序切换内容相近和连贯的一组图片时，我们看到的不是一张张单独的图片影像，而是一段连贯的动画。

　　根据这个原理。我们掷色子的动画也就很容易实现了。只要我们快速的变换不同点数的色子6个面，就会让人觉得好象是真实的转动着的色子了。你不用担心，运行速度的问题，只要你的机子能看vcd，一般都没问题。先看看下面的代码框架：

void zhisaizi（）
{
　int i；
　i= （int）5*rand（）+1；
　switch（i）
　　case 1：
　　　//载入第一张图片
　　case 2：
　　　//载入第二张图片
　　case 3：
　　。。。。。。//省略中间过程
　　case 6：
　　　//载入第六张图片
}

　　至于怎样载入和现实图像不是我们本篇的主要内容，大家可以学习《windows程序设计》这本书。

　　对于发牌的问题，我想大家应该不会在有问题了。这里我只给出代码，其中有详细的注释，就不解释了。下面是代码：

int apai[13]，bpai[13]；
//apai，bpai分别代表两玩家手中的牌，如果你做的是四个人
//的麻将，可你在自由扩展

void fapai（）
{
　int a，b；
　int i；//i代表发牌的起始位置
　if（（i/2）= =0）//是否为偶数
　　apai[a++]=pai[i++]； //双数牌发给a玩家
　else
　　bpai[b++]=pai[i++]；//单数牌发给b玩家
}

　　下面是我们本篇要讲的重点：就是在玩家都拿到牌之后，我们需要按顺序摆放好牌。这里我们会更加深入的谈到数据结构方面的一些知识，希望大家用心。

　　对于这个问题实质上也就是排序的问题。我们前面用136个整型数来代表136张牌，可以用1~136分别表示1~9万，1~9条，1~9饼，以及东南西北红中发财，也可以用1~39中的个位数分别对应着和他相等的1~9万，如3、13、23、33分别代表四张3万。其他以此类推。剩余的数字来表示东南西北红中发财。这个就可以由自己决定了。在此我们选择第一种方法来描述问题。

　　那么就请怎样排序呢?最容易想到的方法是：取得一个数，和他前面的所有数比较，直到找到一个前面的数比它小，后面的数比他大的位置，并将其放入其中。再取得下一个数，继续上面的步骤。

　　示例如下：

8 7 4 3 6 1 //是要排序的数值
7 8 4 3 6 1 //第一次，取得7，小于前面的8，交换位置
7 4 8 3 6 1 //第二次，取得4，小于前面的8，交换位置
4 7 8 3 6 1 //第三次，小于再前面的7，交换位置
4 7 3 8 6 1 //第四次，取得3，小于前面的8，交换位置
4 3 7 8 6 1 //第五次，小于再前面的7，交换位置
3 4 7 8 6 1 //第六次，小于再前面的4，交换位置
3 4 7 6 8 1 //第七次，取得6，小于前面的8，交换位置
3 4 6 7 8 1 //第八次，小于再前面的7，交换位置
3 4 6 7 1 8 //第九次，取得1，小于前面的8，交换位置
3 4 6 1 7 8 //第十次，小于再前面的7，交换位置
3 4 1 6 7 8 //第十一次，小于再前面的6，交换位置
3 1 4 6 7 8 //第十二次，小于在前面的4，交换位置
1 3 4 6 7 8 //第十三次，小于再前面的3，交换位置

　　我们把这种方法叫做“插入排序法”。下面是源代码。

void paixu （）// 用插入排序法
{
　for (int i = 1; i <=13; i++)
　{
　　int temp = apai[i];//取得一个数
　　int j；
　　for ( j = i; j > 0 && temp < apai[j - 1]; j--) //和他前面的每一个数进行比较，
　　　apai[j] = apai[j - 1]; //如果这个数小于她前面的数就交换
　　　apai[j] = temp;//插入到正确位置
　}//end for
}//end 

　　我们先来分析一下这种算法。可以看到，为了找到合适的插入位置，我们要用取得的数值与他前面的所有数值进行比较，并将进行多次的交换位置。尤其是当较小的数值放得越靠后时，交换到合适的位置所需的时间越长，如示例中的6和1，位置都靠后且相邻，但6放置到合适的位置只用了两步，而1放置到合适的位置却用了五步。

　　有没有其他的方法呢？针对比较次数和交换次数较多，我们可以用另一种“折半插入排序法”。基本思路是：为了减少比较的次数，我们不用每个数都比较，而是先找到所取得的数值在数组中的位置，并找到它前面已排好顺序的数组的中间的一个数值，比较两数，如果取得的数值大，就与後面的数值的中间数值比较，一直下去，直到找到合适的位置；同理如果所取得的数值小，就与前面的数值的中间数值比较，一直下去，直到找到合适的位置。

　　下面是示例：

8 7 4 3 6 1 //是要排序的数值
7 8 4 3 6 1 //第一次，取得7，小于前面的8，交换位置
7 4 8 3 6 1 //第二次，取得4，小于前面的8，交换位置
4 7 8 3 6 1 //第三次，小于再前面的7，交换位置
3 4 7 8 6 1 //第四次，取得3，小于前面的数组（4 7 8）中的中间数值7比较，小于7，所以比较数组（4 7）中间数值4，大于4，并交换到合适位置
3 4 6 7 8 1 //第五次，取得6，小于前面的数组（3 4 7 8）中的7，再与再靠前的数组（3 4 7）中间值4比较，大于4，交换位置
1 3 4 7 8 6 //第六次，取得1，小于再前面的数组（3 4 6 7 8）中间值6，再与数组
（3 4 6）中间值4比较，小于4，最后与数组（3 4）中间值3 比较，
小于3，交换位置
 

　　很明显这种方法的减少了比较的次数，但交换次数仍没减少。下面是其代码：

void paixu（）//用折半排序法
{
　for (int i = 1; i < =13; i++)
　{
　　int temp = apai[i]; //取得数值
　　int low = 0, high = i - 1;//low，high，分别表示比较范围的上下限
　　 while (low <= high)//折半查找
　　{
　　　int mid = (low + high) / 2; //取得中间位置
　　　if ( temp < apai[mid]) //如果小于中间位置的值
　　　　high = mid - 1; //从新确定下限
　　　else //如果大于中间位置的值
　　　　low = mid + 1; //从新确定上限
　　}//end while
　　for (int j = i - 1; j >= low; j--)
　　　apai[j + 1] = apai[j]; //记录后移
　　　apai[low] = temp; //插入到合适位置
　}//end for
}//end

　　前面我们学习了两种插入排序法,但当要排序的数组长度越长并且数值越不成顺序,比较和交换的次数就越多,效率越低。因此D.L.Shell在1959年提出了缩小增量排序法（又叫希尔排序法），基本思想是：取一个间隔，将长序列分成若干短的子序列，对每个子序列进行直插排序；然后逐渐缩小间隔，重复以上过程，直到间隔为1。可以看到这种算法，较好的克服了直接插入排序法的不足。

　　下面是示例：

8 7 4 3 6 1 //是要排序的数值，我们以一半的长度为间隔3
3 7 4 8 6 1 //第一次，取得3，小于前面的8，交换位置
3 6 4 8 7 1 //第二次，取得6，小于前面的7，交换位置
3 6 1 8 7 4 //第三次，取得1，小于前面的4，交换位置
1 6 3 4 7 8 //第四次，再缩小间隔，为2，取得1小于3，交换位置，取得7，大于前面的3，不变；取得8大于6，不变，取得4小于8，交换位置
1 3 4 6 7 8 //第五次，再缩小间隔，为1，取得6，大于1，不变；取得3小于6，交换位置；取得4，小于6，交换位置；取得7，大于前面的6，不变；取得8 ，大于7，不变

　　以下是代码：

void paixu( ) //用希尔排序法,
{
　int N=13;// N为前后纪录位置的增量
　for (int Z= N/2; Z; Z = Z/2)//每次缩小增量
　　for (int i = Z; i < N; i++)//从增两大小开始比较
　　{
　　　int temp = apai[i]; //将后一个备份
　　　for (int j = i; j >= Z && temp < a[j - Z]; j -= Z) //与他在同一个子序列的数一个个的较
　　　{
　　　　a[j] = a[j -Z]; //如果小于,就交换
　　　 }//end for
　　　a[j] = temp; //找到合适的插入点,放入其中
　　}//end for
}//end

　　我们再来看最后一种关于数组的排序方法,就是快速排序法,它是目前最快的一种排序的方法.它的基本思想是:通过一趟排序将待排序的记录分割为独立的两部分,其中一部分记录的数值均比另一部分记录的数值小,然后继续分别对这两部分进行排序,直到整个序列有序为止.

　　具体做法: 任取待排序列的某个记录(我们可以取第一个数)作为基准，按照该数值大小，将整个序列分成两个序列——左侧的所有记录的数值都比基准小（或者相等），右侧的都比基准大，基准则放在两个子序列之间，显然这时基准放在了最后应该放置的位置。分别对左右子序列重复上面的过程，直到最后所有的记录都放在相应的位置。

　　示例如下:

7 8 4 3 6 1 //是要排序的数值
1 8 4 3 6 //第一次，取得7，作为基准，1为right值,7>1,交换位置
1 4 3 6 8 //第二次, 8为left值，7<8,放到最后;
1 4 3 6 8 //第三次，left取得4，小于7，放到前面,
1 4 6 3 8 //第四次,right取6,小于7,放到前面
1 4 6 3 8 //第五次，left=right=3,小于7，放到前面,
1 4 6 3 7 8 //7放入合适位置,第一趟排序完成
//后面,在以1为基准排序
……
//直到成功

　　代码如下:

void paixu(int a[],int low,int high;)//用快速排序法
{
　// low, high表示扫描的范围

　int pivot;//存放中心索引及其值的局部变量
　int scanup,scandown,mid;//用于扫描的索引
　if (high-low<=0) //如果数组中的元素少于两个,则返回
　　return;
　else
　　if(high-low==1) //如果有两个元素,对其进行比较
　　{
　　　if(apai[high]<apai[low]) //如果后一个比前一个小,
　　　　Swap(apai[low],apai[high]);//那么交换位置
　　　　return;
　　}//end if
　mid=(low+high)/2;//取得中心索引
　pivot=apai[mid];//将中间索引的值,赋给pivot
　Swap(apai[mid],apai[low]);//交换pivot及低端元素的值
　Scanup=low+1;
　Scandown=high;//初始化扫描索引scanup和scandown
　do{
　　//从低端子表向上扫描,当scanup进入高端子表或遇到大于pivot的元素时结束.
　　while(scanup<=scandown && apai[scanup]<=pivot)
　　　scanup++;
　　　//从高端子表向下扫描,当scandown遇到小于或等于pivot的元素时结束
　　while(piovt<apai[scandown])
　　　scandown--;
　　　//如果两个索引还在各自的子表中,则表示两个元素错位,将两个元素换位
　　　if(scanup<scandown)
　　　　Swap(apai[scanup],apai[scandown]);
　}while(scanup<scandown);
　//将pivot拷贝到scandown位置,分开两个子表
　 apai[low]=apai[scandown];
　　apai[scandown]=pivot;
　//如果低端子表(low至scandown-1)有2个或更多个元素,则进行递归调用
　if(low<scandown-1)
　　paixu(apai,low,scandown-1);
　　//如果高端子表(scandown+1至high) 有2个或更多个元素,则进行递归调用
　if(scandown+1<high)
　　paixu(apai, scandown+1, high);
}

　　关于排序的问题已经够多了,就到这里吧,如果大家有兴趣,可以看已看这方面的书.下一节我们继续我们的游戏开发.

　　对于麻将牌的玩法来说,重要的就是要有吃、碰、杠、胡等四种功能.那么在游戏中怎样编码实现呢?

　　吃牌,就是比较对方打出的牌,和自家的牌是否可以连成一串.而碰牌就是比较对方打出的牌和自家的牌是否有2张相同的.如果有三张牌和对方打出的牌相同,就可以杠.胡牌则是至少要有一对相同的牌,除此之外,也可以有三张三张的相同的牌或连成串的牌.

　　所以对于吃、碰、杠、胡，我们可以分解为，查找两张连续的牌，查找两张相同的牌，查找三张相同的牌，对于胡牌，还要确定有且只能有一对相同的牌，其他的可以是三种相同的牌，或三张连续的牌。可见在此查找是算法的关键。

　　我们先来看一下有关查找的知识。

　　第一种查找的方法叫“线性查找法”，是从数据中的第一个数值开始查找比较，如果找到就返回该值或该值所在的位置。

　　示例如下：

　　13 25 16 23 57 66 为一个整型数组。

　　如果要在这样一个数组中找到57，

　　步骤1：得到第一个数13，不相等，取得下一个数

　　步骤2：得到第二个数25，不相等，取得下一个数

　　步骤3：得到第三个数16，不相等，取得下一个数

　　步骤4：得到第三个数23，不相等，取得下一个数

　　步骤5：得到第三个数57，相等，返回所在位置5

　　代码如下：

int chazhao(int key)//用线性查找法 ,key表示要查找的数值

{

int i=0; //指示在数组中的位置

while(i<14) // 直到结尾

{

if (key==apai[i]) //如果找到，

return i; //返回所在位置

i++; //没找到，继续向后搜索

}

return -1; //没找，返回失败

}

　　可以看到这种方法，不管数据是否有顺序，也不管数据的多少，都是按顺序挨个的搜索，直到找到或搜索完成，当数据很多时,尤其是要查找的数据排的比较靠后,就会很费时间。所以，对于已经排好顺序的数据，如果还用线性查找法来查找的话，一定是很浪费时间的。有什么好的方法呢？

　　大家一定都查过英语词典吧，当你要查一个以S开头的单词时，谁都不会从头一页一页的向后翻,而是跳跃式的向后翻,假如我们先翻到了P开头的一页，我们一定会继续向后翻，而不必再查前面的页码。再翻一次,到达T开头的一页,我们就会又先前翻,找P和T之间的页.我们可以把这种查找的方法叫“折半查找法”。

　　它的原理是：先用欲查找的数值和该组数据的中间位置上的数值比较，当小于中间值时，再向前查询，大于中间值时向后查询，继续取前面（或后面）一半数据的中间值进行比较，如果小于再向前查询，大于就向后查询，一直到找到或查询完毕为止。

　　示例如下：

5 7 12 25 34 37 43 46 58 //是要查找的数据段，其中要查找46，

　　步骤一：中间值34<46,向后查找

　　步骤二：得到后半部分的中间值43<46,再向后查找

　　步骤三: 得到剩余部分的中间值46,返回

　　可见,这种方法明显的减少了比较的次数.

　　下面是源代码:

void chaxun(int key)//用折半查询法,key表示要查询的数值

{

int left=o; //待查询数据段的左边界

int right=12; //待查询数据段的右边界

int mid; //待查询数据段的中间值

while(left<=right) //只要没查询完

{

mid=(right+left)/2; //取得待查询数据段的中间值

if(key<apai[mid]) //中间值大于待查询的数值

right=mid-1; //再查找前半段

else if (key>apai[mid]) //中间值小于待查询的数值

left=mid+1; //再查找后半段

else if(key= = apai[mid]) //中间值等于待查询的数值

return mid; //返回位置

}//end while

return –1;

}//end
 

　　查询数据是数据结构中的又一重要知识,在实际应用中也很重要,如果有兴趣可再深入的研究.我们只能到此为止.

　　回过头来,我们再来看一看,这样判断吃,碰,杠,胡.在此我们只以万牌为例.

　　下面是数和牌对应关系:

1 2 3 4 5 6 7 8 9 10

11 12 13 14 15 16 17 18 19 20

21 22 23 24 25 26 27 28 29 30

31 32 33 34 35 36 37 38 39 40

一 二 三 四 五 六 七 八 九 （万） 东

　　很明显同一张牌是在小于40的数据段中,并且个位相同的数.并且它还对应着牌上的数.

　　所以判断是否为同一张牌的方法,我们可以这样写:

tempa=apai[i]%10;
tempb=apai[i+1]%10;
if(tempa==tempb)
　shi tong yi zhang pai
(注意这种牌和数得对应关系,在排序时,一定要以个位为准,而不是以实际的数值大小)

　　判断是否可碰,则可以这样:

tempa=apai[i]%10;
tempb=apai[i+1]%10;
tempc=apai[i+2]%10;
if(tempa==tempb && tempb==tempc)
 

　　判断是否可杠,可以这样:

tempa=apai[i]%10;
tempb=apai[i+1]%10;
tempc=apai[i+2]%10;
tempd=apai[i+3]%10;
if(tempa==tempb && tempb==tempc && tempc==tempd)

　　是否为顺,则可以这样判断:

tempa=apai[i]%10;
tempb=apai[i+1]%10;
tempc=apai[i+2]%10;
if(tempa==tempb+1 && tempb==tempc+1)

　　很简单吧,相信你应该也会判断对方出的牌,自己是否可以碰,杠,吃了吧.在此我们就不多罗嗦了.

　　胡牌稍麻烦些,要判断各种副牌的方式,这里我们一起看看一条龙的胡法.

　　下面是源程序:

void yitiaolong ()
{ int wan,bing,tiao;//wan,bing,tiao 分别代表三种牌
　int temp;
　for(int I=0;I<13;I++)
　{
　　temp=apai[I];
　　if(0<temp<40)
　　　wan++;
　　if(40<temp<80)
　　　bing++;
　　if(80<temp<120)
　　　tiao++;
　　if(wan=8)//万牌一条龙
　　for(int I=1;I<9;I++) //比较这8张牌
　　　 if(apai[I]%10=api[I+1]%10)
　　　　 //是否後一张等于前一张,相等,说明已经有将牌了
　　　　for(int a=1;a<40;a++)
　　　　　if (chaxun(a)!==-1) //找到所缺的牌
　　　　　　if (I=duifangchupai)比较是否和对家大的牌相等
　　　　　　　 ……..//胡了
　　　　　　 else
　　　　　　　//表示8张牌没有相同的,也就是又8个串
　　　　　　　//查找所缺的牌,
　　　　　　　//与对方出的牌比较,
　　　　　　　//相等 胡牌
　　　　　　　 ……….
　　　　　　 if(wan=9)
　　　　　　　　……….
　}
　if(bing>=8)
　　…..//饼牌一条龙
　if(tiao>=8)
　　…… //条牌的一条龙
　}
}

　　由于篇幅所限而且文章的重点不在于此,这仅给出一个框架,聪明的读者,可以发挥自己的才智,将他补充完整.

　　下面我们简单谈一下人工智能,毕竟我们在游戏中还需要一个对手.

　　作为程序员,我们不可能做出一个具有高超智慧的对手,而且我们也不可能将游戏中种种可能的打牌方法都写入程序.那么就需要一种可操作的方法,使你的对手不至于太傻.

　　对于给策略性的游戏添加人工智能主要有这么几步:

　　(1) 要找出所有获胜的可能性

　　(2) 建立获胜表,

　　(3) 每一步的玩法给出一个恰当的评价分值,其中包括给对手制造的麻烦所得的分,和给自己带来的获胜机会所带来的分

　　(4) 根据所给的分值,确定其中所有可能的玩法中,分值最高的一种玩法,也就是最好的一步走法.

　　具体到麻将游戏下面是具体的分析:

　　假设a1,a2,... an 是手上当前牌序列,其中包括吃 碰 杠后的牌,

　　步骤1: 计算 玩家 离胡牌还有几步. 如果 玩家 已经听牌, 它离胡牌的步数是 1, 如果是一上一听, 步数是 2, 以此类推;

　　步骤2: 如果步数是 m , 计算所有能使 玩家 到达胡牌的序列也就是所有胡牌的可能玩法 {b11,b12,....b1m}, {b21,b22,...b2m}, ....,{bt1,bt2,....,btm}

　　步骤3: 对于每个一个 {bt1,bt2,...,btm}, 计算胡牌的点数, 以及到达胡牌时要打出去的牌: {ci1,ci2,....,cim}

　　步骤4: 对于每一个 {bt1,bt2,...,btm} 计算胡牌的点数;

　　步骤5: 选取收益最大的方案 {bji,bj2,....bjm}

　　步骤6: 从{cj1,cj2,....cjm} 中按照跟熟原则打一张

　　动动脑筋相信你会做出更智能化的得对手。

　　游戏的细节部分快谈完了，我们的这篇文章也即将结束。但这部分所谈到得内容依然是数据结构方面的很主要的一部分内容。闲话少叙，回到我们的教程中。

　　细心的读者可能发现了，这里我的所有例子都是基于数组这种结构来谈的。所以我们先来看一看数组的一些特点。从前面的例子中,我们可以看到,数组是一种不仅在存储地址上连续而且其中前后数据在逻辑上也连续的存储数据的结构。它的优点是,读取和修改其中的每一个数值都很方便。只要直接找到它的索引值就可以读取和修改它的数值。即使要想读取或修改数组中所有的数值,我们也只需要一个从头到尾的循环.但是对于数组的插入,删除,和排序却是一件很繁琐的事,比如我们在数组中间插入一个数值,就要将它所在的位置之后的所有数值后移一位,如果其后的数值很多,效率是极低的.示例如下:
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│２│３│４│５│６│７│８│９│　│　│　│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

 
　　上面是待插入数值的数组.如果想在5的后面插入一个1,可以想到首先要找到5所在的位置,然后,从最后的9开始,向后移动一个位置,直到空出5后面的位置,最后将1插入其中.在这里我们只需移动四个数,但当数值越多,那么移动的数值也就会越多.

　　除此之外,数组还有一个不足之处.那就是我们在不知到数据多少时,为存储下所有数据,必须建立很多空的数组,势必造成存储空间的浪费.

　　这里我们再介绍一种数据结构——链表。我们先来看个例子。

┌─┬─┬─┬─┬─┬───┬─┬─┬─┬─┐
│１│　│２│　│３│　　４│　│５│　│　│
└─┴─┴─┴─┴─┴───┴─┴─┴─┴─┘

　　上面是存在内存中的数据，在存储位置上，它们都是不连续的，但我们可以不考虑他们的实际位置，而在逻辑上让他们形成一种前后相联的关系。怎么做呢？

　　正如下图所示：我们只要加一个“链”就可以将内存中不连续的单元连接起来。用c语言我们可以这样做：
Struct jiegouming //结构名称
{
　int shu； //用来存储数据
　Struct list *next； //用来连接下一个
}
typedef struct jiegouming node；
typedef Node *link；

┌─┬─┐
│１│　│──┐
└─┴─┘　　│
┌─┬─┐　　│
│　│　│　　│
└─┴─┘　　│
　┌─────┘
　↓
┌─┬─┐
│２│　│──┐
└─┴─┘　　│
┌─┬─┐　　│
│　│　│　　│
└─┴─┘　　│
　┌─────┘
　↓
┌─┬─┐
│３│　│──┐
└─┴─┘　　│
┌─┬─┐　　│
│　│　│　　│
└─┴─┘　　│
　┌─────┘
　↓
┌─┬─┐
│４│　│
└─┴─┘

　　这样我们就可以用next这样的一个指针，将多个这样的结构联系起来了。而且还可以在需要的时候 ，动态的建立，不需要的时候，再释放掉，从而节省了，内存空间。

　　我们来看一看链表的建立和释放。下面是源程序：

link creatlist（link head）//建立一个有10个节点的链表,并初始化为0
{
　link point;//声明两个接点
　link new;
　int num=10;//计数值设为10
　head = （link）malloc （sizeof（node））；
　if（head==NULL）
　　printf（” 内存建立失败”）;
　else
　{
　　head->next=NULL;
　　printf(“建立成功”)
　}
　point = head;//将point 设为首节点
　while(num>0)
　{
　　new = (link) malloc (sizeof(node));
　　if(new==NULL)
　　　printf(“内存建立失败”);
　　else
　　　new->shu=o;//将新建的节点中的数值设为0
　　　new->next=NULL;// 将新建的节点中的下一个节点设为NULL
　　　point->next=new;//将新建的节点连接到前一个节点上
　　　point=new;// 将新建节点设为当前节点
　　　num--; //计数值减一
　}//end while
}//end

void freelist(link head)//释放链表
{
　link point; //声明一个节点
　while(head !=NULL)//当节点为空,说明已到链表最后
　{
　　point=head;//保存节点头
　　head=hesd->next; //向后移动倒下一个节点
　　free(point); //删除头一个节点
　}//end while
}//end

　　对于链表如果不能实现查询,插入,删除等功能,那么它也就没有价值了,所以我们再来看看在链表中怎样实现这些功能.

　　先来看看链表的查询.因为链表在逻辑上也是有序排列的,所以,要找一个数值,我们同样可以采用线性查找法挨个往下查找下去,直到找到所要查找的数值或者查找结束.

　　下面是例程:

int searchlist(int key,link head) //在链表head中查找key值
{
　link point;//声明一个节点,指示当前位置
　int num=1;//记录节点所在位置的数值
　point = head; // 指向头一个节点
　while(point !=NULL)
　{
　　if(point->shu==key) //如果节点中的数值和要查找的数值相等
　　　return num;// 返回这个数值在链表中的位置
　　point = point->next; //如果节点中的数值和要查找的数值不相等,节点后移
　　num++;//计数值加一
　 }//end while
}//end

　　对于链表的插入方法,很灵活,不用象数组一样插入后,还要向后移动其后面的数值.下面是一个示例图:

┌─┬─┐
│１│　│──┐──┐
└─┴─┘　　┆　　↓　　要插入的新节点
┌─┬─┐　　┆　┌─┬─┐　　　　
│　│　│　　┆　│５│　│──┐　
└─┴─┘　　┆　└─┴─┘　　│　
　┌─────┘────────┘　
　↓
┌─┬─┐
│２│　│──┐
└─┴─┘　　│
┌─┬─┐　　│
│　│　│　　│
└─┴─┘　　│
　┌─────┘
　↓
┌─┬─┐
│３│　│──┐
└─┴─┘　　│
┌─┬─┐　　│
│　│　│　　│
└─┴─┘　　│
　┌─────┘
　↓
┌─┬─┐
│４│　│
└─┴─┘

　　可见,链表的插入,只要修改节点的指向就可以了.

　　下面是源代码 :

Link insertlist(link head,link new,int key)
//在链表head中插入数值为key的节点new
{
　link point;// 声明一个节点,来指示当前节点
　point = head; //当前节点指向头节点
　while(1)
　{
　　if(point==NULL)//如果链表head中只有一个节点
　　{ //插入到首节点的前面
　　　new->next=head;
　　　head=new;//新节点作为首节点
　　　break;
　　} //end if
　　if(point->shu==key)//如果在链表head中找到key值
　　{ //插入到这个数值的后面
　　　new->next=point->next;
　　　point->next=new;
　　　break;
　　} //end if
　　point=point->next;//当前节点后移
　}//end while
　return head;
}//end

　　最后是怎样删除一个节点.方法和插入类似.请看示例图:

Link deletelist(link head,int key)
/在链表head中删除数值key
{
　link point;//指示当前节点
　link back;//指示后一个节点
　point =head;//将头节点设为当前节点
　while(1)
　{
　　if(point->next==NULL)//如果,没有节点
　　{
　　　printf(“没有节点可供删除”);
　　　break;
　　}
　　if(head->shu ==key)//如果找到数值key所在的节点
　　{
　　　head=point->next;//将当前节点的下一个
　　　free(point);//释放节点
　　　break;
　　}
　　back=point;//保存当前节点
　　point=point->next;//当前节点后移
　　if(point->shu==key)// 如果找到数值key所在的节点
　　{
　　　back->next=point->next;
　　　//将当前节点所连接的节点连接到当前节点的前一个节点上
　　　free(point);//释放当前节点
　　　break;
　　}//end if
　}end while
　return head;
}//end 

　　好了,就到这吧,相信大家已经体会到了数据结构着门课的重要性,我们的目的也就达到了.毕竟只是一篇基础教程.所以我们只讲到了数据结构中的一些基础性的知识.把它当作一篇入门的教程吧,有兴趣的读者可以学习一下相关的课程.一定会有所收获的.

当层遇到下拉框时总是挡不了select框?其实这是IE的BUG,其它的浏览器没有这个问题,对于这个问题论坛里不少提出,在这里提供我的几种方法,各有各的好处,有错,有好的意见者提出,谢谢.

1.最直接的方法:隐藏下拉框.

下面提供的是一个比较通用的一组函数:

test.htm

------------

<script>
var HideElementTemp = new Array();
//点击菜单时，调用此的函数,菜单对象
function cal_hideElementAll(obj){
        cal_HideElement("IMG",obj);
        cal_HideElement("SELECT",obj);
        cal_HideElement("OBJECT",obj);
        cal_HideElement("IFRAME",obj);
}
function cal_HideElement(strElementTagName,obj){
try{
    var showDivElement = obj;
    var calendarDiv = obj;
    var intDivLeft = cal_GetOffsetLeft(showDivElement);
    var intDivTop = cal_GetOffsetTop(showDivElement);//+showDivElement.offsetHeight;
    //HideElementTemp=new Array()
    for(i=0;i<window.document.all.tags(strElementTagName).length; i++){
 var objTemp = window.document.all.tags(strElementTagName)[i];
 if(!objTemp||!objTemp.offsetParent)
     continue;
 var intObjLeft=cal_GetOffsetLeft(objTemp);
 var intObjTop=cal_GetOffsetTop(objTemp);
 if(((intObjLeft+objTemp.clientWidth)>intDivLeft)&&
    (intObjLeft<intDivLeft+calendarDiv.style.posWidth)&&
    (intObjTop+objTemp.clientHeight>intDivTop)&&
    (intObjTop<intDivTop+calendarDiv.style.posHeight)){
     //var intTempIndex=HideElementTemp.length;//已经有的长度
  //save elementTagName is stutas
     //HideElementTemp[intTempIndex]=new Array(objTemp,objTemp.style.visibility);
     HideElementTemp[HideElementTemp.length]=objTemp
     objTemp.style.visibility="hidden";
        }
    }
}catch(e){alert(e.message)
}
}

function cal_ShowElement(){
    var i;
    for(i=0;i<HideElementTemp.length; i++){
 var objTemp = HideElementTemp[i]
 if(!objTemp||!objTemp.offsetParent)
     continue;
 objTemp.style.visibility=''
    }
    HideElementTemp=new Array();
}
function cal_GetOffsetLeft(src){
    var set=0;
    if(src && src.name!="divMain"){
        if (src.offsetParent){
           set+=src.offsetLeft+cal_GetOffsetLeft(src.offsetParent);
 }
 if(src.tagName.toUpperCase()!="BODY"){
     var x=parseInt(src.scrollLeft,10);
     if(!isNaN(x))
            set-=x;
 }
    }
    return set;
}

function cal_GetOffsetTop(src){
    var set=0;
    if(src && src.name!="divMain"){
        if (src.offsetParent){
            set+=src.offsetTop+cal_GetOffsetTop(src.offsetParent);
   }
 if(src.tagName.toUpperCase()!="BODY"){
     var y=parseInt(src.scrollTop,10);
     if(!isNaN(y))
  set-=y;
 }
    }
    return set;
}

</script>
<select></select>
<select></select>
<div style="position:absolute;left:0;top:0;width:100;height:100;background-color:red" onclick="cal_hideElementAll(this)">
点击让select隐藏
</div>
<br/><br/><br/><br/><br/><br/>
<input type="button" value="点击让select显示" onclick="cal_ShowElement()">

以上这种方法,如果对于select框数目少,相对固定的话,直接用obj.style.visibility="hidden"这样进行隐藏是更直接的.

2.Object对象的优先度较高,可以挡住select框

<OBJECT id=aa style="display:none;z-index:1000; position:absolute; top:0; left:0; width:152; height: 200;" type="text/x-scriptlet" data="about:<body><div style='position:absolute;left:0;top:0;width:152;height:200;font:14;color:white;background:black;border:1 solid black'>test</div>"></OBJECT>
<select><option>hellohellohellohello</select><button onclick=aa.style.display=aa.style.display=="none"?"":"none">test</button>

这种方法虽然也简单,但对复杂的层是来说还不是好的解决方法

3.用iframe作载体

以下是一简单的例子:

-----------

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<title>简单菜单</title>
<!--
提供定位函数，用iframe作载体，不会被select挡住
By Fason(2003-5-21)
-->
<style id=s>
#div1{
position:absolute;
z-index:100;
width:100;
height:130;
background-color:#d2e8ff;
border:1 solid black;
}
div{cursor:hand;font-size:12px;}
a{text-decoration:none;color:red;font-size:12px}
</style>
</head>
<body>
<script>
function window.onload(){
var shtml=div1.innerHTML;
var ifm=document.createElement("<iframe frameborder=0 marginheight=0 marginwidth=0 hspace=0 vspace=0 scrolling=no></iframe>")
ifm.style.width=div1.offsetWidth
ifm.style.height=div1.offsetHeight
ifm.name=ifm.uniqueID
div1.innerHTML=""
div1.appendChild(ifm)
window.frames[ifm.name].document.write(s.outerHTML+"<body leftmargin=0 topmargin=0>"+shtml+"</body>")
}

function show(){
with(document.all.img1){
x=offsetLeft;
y=offsetTop;
objParent=offsetParent;
while(objParent.tagName.toUpperCase()!= "BODY"){
x+=objParent.offsetLeft;
y+=objParent.offsetTop;
objParent = objParent.offsetParent;
}
y+=offsetHeight-1
}
with(document.all.div1.style){
pixelLeft=x
pixelTop=y
visibility=''
}
}
function hide(){
document.all.div1.style.visibility='hidden'
}
</script>
<img id=img1 onmouseover="show()" onmouseout="hide()" src="ie.gif"><br/><select></select>
<div id=div1 onmouseover="style.visibility=''" onmouseout="style.visibility='hidden'" style="visibility:hidden;">
<div href="http://www.csdn.net" onmouseover="style.backgroundColor='highlight'" onmouseout="style.backgroundColor=''" onclick="window.open(href)">中国程序员</div>
<div href="http://www.sohu.com" onmouseover="style.backgroundColor='highlight'" onmouseout="style.backgroundColor=''" onclick="window.open(href)">sohu</div>
</div>
</body>
</html>

取得TABLE元素的个数 

<base href="http://www.flash8.net">
  <div id=demo style=overflow:hidden;height:100;width:90;background:#214984;color:#ffffff><div id=demo1>
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  <img src="http://guoblog.com/images/guoblog_logo.gif">
  </div>
  <div id=demo2></div>
  </div>
    <script>
    var speed=30
    demo2.innerHTML=demo1.innerHTML
    demo.scrollTop=demo.scrollHeight
    function Marquee(){
    if(demo1.offsetTop-demo.scrollTop>=0)
    demo.scrollTop+=demo2.offsetHeight
    else{
    demo.scrollTop--
    }
    }
    var MyMar=setInterval(Marquee,speed)
    demo.onmouseover=function() {clearInterval(MyMar)}
    demo.onmouseout=function() {MyMar=setInterval(Marquee,speed)}
    </script>

本人屏蔽Alt键的方法(仅供参考，欢迎大家一起讨论，我的QQ：30836570)
<script language="javascript">
<!--
function document.onkeydown(){
  if ((window.event.altKey)&&
      ((window.event.keyCode==37)||   //屏蔽 Alt+ 方向键 ←
       (window.event.keyCode==39))){  //屏蔽 Alt+ 方向键 →
    window.location.reload();
        window.open();
     }
}
-->
</script>

<SCRIPT LANGUAGE=javascript>
function click() {
alert('这是禁止选择') }
function click1() {
if (event.button==2) {alert('这是禁止右键') }}
function CtrlKeyDown(){
if (event.ctrlKey) {alert('这是禁止CTRL键') }}
document.onkeydown=CtrlKeyDown;
document.onselectstart=click;
document.onmousedown=click1;
</SCRIPT>

<body onkeydown="if (event.altKey) {alert('禁用ALT键');return false;}">
这样就OK了!：P

隐藏网页中的“关闭、最大化、最小化”按钮，也可这样：
<body onload="window.moveTo(0, -24)">

可以用TDC实现数据绑定

databind.htm

<OBJECT id="baobao" CLASSID="clsid:333C7BC4-460F-11D0-BC04-0080C7055A83">
 <PARAM NAME="DataURL" VALUE="data.txt">
 <PARAM NAME="UseHeader" VALUE="True">
</OBJECT>
<TABLE datasrc="#baobao">
<TBODY>
<TR><TD style="color:red"><DIV datafld="TxtData"></DIV></TD></TR>
</TBODY>
</TABLE>

data.txt
TxtData
这是要在网页显示的内容.