java链表实现

 import java.util.Scanner;

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

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

     // 追加结点
     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;
         }
     }

     // 添加头结点
     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;
         }
     }

     // 查找结点
     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; // 返回头指针
     }

     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; // 未删除
     }

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

     void CLAllNode(CLType head) // 遍历链表
     {
         CLType htemp;
         DATA2 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; // 处理下一结点
         }
     }

 }

 public class LinkedList {

     public static void main(String[] args) {
         CLType node, head = null;
         CLType CL = new CLType();
         String key, findkey;
         Scanner input = new Scanner(System.in);

         System.out.print("链表测试。先输入链表中的数据，格式为：关键字 姓名 年龄\n");
         do {
             DATA2 nodeData = new DATA2();
             nodeData.key = input.next();
             if (nodeData.key.equals("0")) {
                 break; // 若输入0，则退出
             } else {
                 nodeData.name = input.next();
                 nodeData.age = input.nextInt();
                 head = CL.CLAddEnd(head, nodeData);// 在链表尾部添加结点
             }
         } while (true);
         CL.CLAllNode(head); // 显示所有结点

         System.out.printf("\n演示插入结点，输入插入位置的关键字：");
         findkey = input.next(); // 输入插入位置关键字
         System.out.print("输入插入结点的数据(关键字 姓名 年龄):");
         DATA2 nodeData = new DATA2();
         nodeData.key = input.next();
         nodeData.name = input.next();
         nodeData.age = input.nextInt();// 输入插入结点数据
         head = CL.CLInsertNode(head, findkey, nodeData); // 调用插入函数
         CL.CLAllNode(head); // 显示所有结点

         System.out.print("\n演示删除结点，输入要删除的关键字:");

         key = input.next(); // 输入删除结点关键字
         CL.CLDeleteNode(head, key); // 调用删除结点函数
         CL.CLAllNode(head); // 显示所有结点

         System.out.printf("\n演示在链表中查找，输入查找关键字:");
         key = input.next(); // 输入查找关键字
         node = CL.CLFindNode(head, key); // 调用查找函数，返回结点指针
         if (node != null) // 若返回结点指针有效
         {
             nodeData = node.nodeData; // 获取结点的数据
             System.out.printf("关键字%s对应的结点为(%s,%s,%d)\n", key, nodeData.key,
                     nodeData.name, nodeData.age);
         } else // 若结点指针无效
         {
             System.out.printf("在链表中未找到关键字为%s的结点！\n", key);
         }
     }
 }