链式存储方式基于java

1 链表结构

顺序表有以下几种缺点：

• 在插入或者删除节点时，往往需要移动大量的数据
• 如果表比较大，有时候比较难分配足够的内存空间，这样可能导致内存分配失败，从而无法存储

为了克服线性表的缺点，出现了链表，链表是一种动态存储分配的结构形式，可以根据需要动态申请所需的内存单元。

链表的形式
每一个节点都应该含有：

• 数据部分，保存的是该节点的实际数据
• 地址部分，保存的是下一个节点的地址值

2链表的优缺点

2.1优点

链表结构带来的最大好处是节点之间不需要连续存储，用户可以使用new函数动态分配节点的存储空间，当删除某个节点时，给该节点赋值null,释放其占用的内存空间。

2.2缺点

1 浪费存储空间
2 对于链表的访问，只能从表头逐个查找，即通过head头引用找到第一个节点，再从第一个节点找到第二个节点。。。。,访问速度比较慢

2.3 总结优缺点

顺序表，类是数组，查询，修改快，增删慢
链式表，增删快，查询修改慢

使用时注意的事项

单节点插入时，首先将新节点next指向后继节点，然后让前驱节点指向新节点

3 功能实现

3.1 准备

• 1 创建一个类，用于存放信息

public class Data1 { //创建节点，用于存放数据信息
    String key;
    String name;
    int age;
}

• 2 创建链式表的数据结构

public class CLType {
    Data1 nodeData = new Data1(); //存放节点
    CLType nextNode;// 存放下一个节点的地址值
}

3.2 追加节点

//追加节点
    CLType CLAddEnd(CLType head,Data1 nodeData){

        /**
         * 头节点的数据域不存放数据，指针域指向下一个节点
         * 尾节点的指针域为null 不存放地址
         */

        CLType node,htemp;
        if ((node = new CLType()) == null){
            System.out.println("申请内存失败！\n");
            return null;
        }else {
            //代表内存申请成功
            node.nodeData = nodeData;
            node.nextNode = null;

            if (head == null){ //链表为空
                head = node;
                return head;
            }
            //查找链表的末尾
            htemp = head; // htemp 是指当前节点，head是指htemp的上一个节点
            while (htemp.nextNode != null){
                htemp = htemp.nextNode;
            }
            htemp.nextNode = node;
            return head;
        }
    }

3.3插入节点

/**插入头节点，即在链表首部添加节点的过程，步骤如下
 * 1 分配内存空间，保证新增的节点
 * 2 使新增节点指向头引用head所指向的节点
 * 3 使头引用head指向新增节点
 */

    CLType CLAddFirst(CLType head,Data1 nodeData){ //头节点和存储的数据
        CLType node;
        if ((node = new CLType()) == null){
            System.out.println("申请内存失败！\n");
            return null;
        }else {
            node.nodeData = nodeData;
            node.nextNode = head;
            head = node;
            return head;
        }
    }

3.4 查找节点

	//查找节点
    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;
    }

3.5 插入节点

    //插入节点
    CLType CLInsertNode(CLType head,String findKey,Data1 nodeData){

        CLType node,nodetemp;

        if ((node = new CLType()) == null){
            System.out.println("申请内存失败！\n");
            return null;
        }

        //保存节点中的数据
        node.nodeData = nodeData; // 保存节点中的数据

        nodetemp = CLFindNode(head,findKey); // 寻找插入的节点值

        if (nodetemp != null){
            node.nextNode = nodetemp.nextNode; // 插入节点时，先把新节点的指针域指向下一个节点的数据域

            nodetemp.nextNode = node; //设置关键节点指向新插入节点
        }else {
            System.out.println("未找到正确的插入位置！\n");
        }
        return head;
    }

3.6 删除节点

    //删除节点
    int CLDeleteNode(CLType head,String key){
        CLType node,htemp;

        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;
    }

3.7 计算链表的长度

    //计算链表的长度
    int CLLength(CLType head){

        CLType htemp;
        int len = 0;
        htemp = head;

        while (htemp != null){
            len ++;
            htemp = htemp.nextNode;
        }
        return len;
    }

3.8 显示所有节点

    //显示所有节点
    void CLAllNode(CLType head){
        CLType htemp;
        Data1 nodedata;
        htemp = head;
        System.out.println("当前节点共有"+CLLength(htemp)+"个节点，显示");
        while (htemp != null){

            nodedata = htemp.nodeData;
            System.out.println(nodedata.key+":"+nodedata.name+":"+nodedata.age);
            htemp = htemp.nextNode;
        }
    }

4 测试功能是否实现

public class MyTest {
    public static void main(String[] args) {
        CLType node = null;
        CLType head = null;
        CLType CL = new CLType();

        String key, findkey;
        Scanner sc = new Scanner(System.in);
        System.out.println("链表测试启动，先输入链表中的数据，格式为：关键字，姓名，年龄");

        do {
            Data1 nodeData = new Data1();
            nodeData.key = sc.next();
            if (nodeData.key.equals("0")) {
                break; //如果输入的关键字为 0 则代表退出程序
            } else {
                nodeData.name = sc.next();
                nodeData.age = sc.nextInt();
                head = CL.CLAddEnd(head, nodeData); // 在尾部添加节点
            }
        } while (true);

        //显示所有节点
        CL.CLAllNode(head);

        //插入节点
        System.out.println("请输入要插入节点的关键字");
        findkey = sc.next();

        System.out.println("请输入要插入节点的信息，关键字，姓名，年龄");
        Data1 nodeData = new Data1();

        nodeData.key = sc.next();
        nodeData.name = sc.next();
        nodeData.age = sc.nextInt();

        head = CL.CLInsertNode(head, findkey, nodeData);

        //显示所有节点
        CL.CLAllNode(head);

        //查找节点
        System.out.println("请输入要查找节点的关键字");
        key = sc.next();
        node = CL.CLFindNode(head, key);

        if (node != null) {
            nodeData = node.nodeData;
            System.out.println("关键字对应节点的信息" + nodeData.key + ":" + nodeData.name + ":" + nodeData.age);
        } else {
            System.out.println("未找到节点对应节点的信息");
        }
        //删除节点信息
        System.out.println("请输入要删除节点的关键字");
        key = sc.next();
        CL.CLDeleteNode(head,key);

        //显示所有节点信息
        CL.CLAllNode(head);
    }
}

插入

查找

删除