【书籍】Java常用算法手册-链表结构

最新推荐文章于 2024-05-19 21:02:36 发布

原创最新推荐文章于 2024-05-19 21:02:36 发布 · 255 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #链表

Java算法专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一个使用Java实现的简单链表操作示例，包括添加、查找、插入和删除结点等功能，并通过具体示例展示了如何使用这些功能。

问题：input为什么会被跳转？

解决方案：重新new 一个Scanner。

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");
        }
        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;       //使前一结点指向当前结点的下一结点
                htemp = null;                           //释放内存
                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;           //处理下一结点
        }
    }

}

/**
 * P2_2 class
 *
 * @author wcy
 * @date 2017/10/19.
 */
public class P2_2 {

    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);         //显示所有结点

        input = new Scanner(System.in);
        System.out.print("\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.print("\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);
        }
    }
}

Intellij工具，JDK1.8 运行结果如下：

链表测试。先输入链表中的数据，格式为：关键字姓名年龄
1 张三 33
2 五五 55
0 0 0
当前链表共有2个结点。链表所有数据如下：
结点(1,张三,33)
结点(2,五五,55)

演示插入结点，输入插入位置的关键字：1
输入插入结点的数据（关键字姓名年龄）：3 李四 44
当前链表共有3个结点。链表所有数据如下：
结点(1,张三,33)
结点(3,李四,44)
结点(2,五五,55)

演示删除结点，输入要删除的关键字：3
当前链表共有2个结点。链表所有数据如下：
结点(1,张三,33)
结点(2,五五,55)

演示在链表中查找，输入查找关键字：2
关键字2对应的结点为(2,五五,55)