java数据结构（一）——线性链表

    与C++类似java数据结构的线性表中也有顺序表和线性表。但是顺序表有几个缺点：1.插入删除操作不方便。2.存储空间必须连续，当表较大时无法申请到足够大的连续存储空间。所以，本文介绍链表结构。

    链表具体结构如下：

    1.数据部分，保存需要存储的数据。

    2.地址部分，保存下一个节点的地址。

代码主要包括数据结构和数据操作。

数据结构部分：

class DATA
{
    String key;  				//结点的关键字 
    String name;
    int age;
} 

class CLType								//定义链表结构
{
    DATA nodeData=new DATA();
    CLType nextNode;
}

数据操作部分：

1.添加节点

 CLType CLAddEnd(CLType head,DATA2 nodeData)  	//追加结点 
    {
        CLType node,htemp;
        if((node=new CLType())==null)
        {
            System.out.print("申请内存失败！\n"); 
            return null;  							//分配内存失败 
        }
    	else
    	{
    		node.nodeData=nodeData; 				//保存数据 
    		node.nextNode=null;  				//设置结点指针为空，即为表尾 
    		if(head==null)  						//头指针 
    		{
    			head=node;
    			return head;
    		}
    		htemp=head;
    		while(htemp.nextNode!=null) 			//查找链表的末尾 
    		{
    			htemp=htemp.nextNode;
    		}
    		htemp.nextNode=node;
    		return head;
    	}
    }

2.插入头结点

CLType CLAddFirst(CLType head,DATA2 nodeData) 
    {
        CLType node;
        if((node=new CLType())==null)
        {
            System.out.print("申请内存失败！\n"); 
            return null;  							//分配内存失败 
        }
    	else
    	{
    		node.nodeData=nodeData; 				//保存数据 
    		node.nextNode=head;  					//指向头指针所指结点 
    		head=node;        						//头指针指向新增结点
    		return head; 
    	}
    }

3.查找结点

CLType CLFindNode(CLType head,String key) 		//查找结点
    {
        CLType htemp;
        htemp=head;       							//保存链表头指针 
        while(htemp!=null)      							//若结点有效，则进行查找 
        {
            if(htemp.nodeData.key.compareTo(key)==0) 		//若结点关键字与传入关键字相同 
    		{
                return htemp;  						//返回该结点指针 
    		}
            htemp=htemp.nextNode; 					//处理下一结点 
        }
        return null; 								//返回空指针 
    }

    CLType CLInsertNode(CLType head,String findkey,DATA2 nodeData)  	//插入结点 
    {
        CLType node,nodetemp;    
        if((node=new CLType())==null) 		//分配保存结点的内容 
        {
            System.out.print("申请内存失败！\n"); 
            return null;  								//分配内存失败 
        }
        node.nodeData=nodeData;  					//保存结点中的数据 
        nodetemp=CLFindNode(head,findkey);
        if(nodetemp!=null)  								//若找到要插入的结点 
        {
            node.nextNode=nodetemp.nextNode;  		//新插入结点指向关键结点的下一结点 
            nodetemp.nextNode=node;    			//设置关键结点指向新插入结点 
        }
    	else
    	{
            System.out.print("未找到正确的插入位置！\n"); 
//            free(node);								//释放内存
        }
        return head;								//返回头指针（java中没有指针实际上是头引用）
    }

4.删除结点

int CLDeleteNode(CLType head,String key)
    {
        CLType node,htemp; 						//node保存删除结点的前一结点 
        htemp=head; 
    	node=head;
        while(htemp!=null)
        {
            if(htemp.nodeData.key.compareTo(key)==0) 		//找到关键字，执行删除操作 
            {
                node.nextNode=htemp.nextNode;  		//使前一结点指向当前结点的下一结点
//                free(htemp);  						//释放内存 
                return 1;
            }
    		else
    		{
                node=htemp;  						//指向当前结点 
                htemp=htemp.nextNode; 				//指向下一结点 
            }
         }
         return 0;									//未删除 
    }

5.遍历所有节点

void CLAllNode(CLType head) 					//遍历链表 
    {
        CLType htemp;
        DATA nodeData;
        htemp=head;
        System.out.printf("当前链表共有%d个结点。链表所有数据如下：\n",CLLength(head)); 
        while(htemp!=null) 								//循环处理链表每个结点 
        {
            nodeData=htemp.nodeData;				//获取结点数据 
            System.out.printf("结点(%s,%s,%d)\n",nodeData.key,nodeData.name,nodeData.age); 
            htemp=htemp.nextNode;					//处理下一结点 
        }
    }
  
}

6.计算表长

int CLLength(CLType head)						//计算链表长度
    {
        CLType htemp;
        int Len=0;
        htemp=head;
        while(htemp!=null)      							//遍历整个链表 
        {
            Len++; 								//累加结点数量 
            htemp=htemp.nextNode;					//处理下一结点 
        }
        return Len;									//返回结点数量 
    }