单链表 - SingleLinkedList

已于 2024-01-20 19:12:11 修改
阅读量466 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 链表
于 2021-11-28 22:01:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ykmeory/article/details/121569484
版权

文章目录

1 链表

链表是有序的列表，它在内存中的存储如下：
链表
上图小结：
<1>链表是以节点的方式存储的，是链式存储
<2>每个节点包含data域，next域（指向下一个节点）
<3>链表的各个节点不一定是连续存储
<4>链表分为带头节点的链表和和不带头节点的链表

2 单链表

单链表（带头节点）逻辑结构如下图所示
单链表

3 单链表的应用

本文列举单链表的以下应用：
(1)乱序添加节点
(2)乱序添加，根据规则排序（即操作完成后是有序的）
(3)删除节点
(4)修改节点
(5)遍历单链表
(6)获取单链表中节点的个数
(7)查询单链表的倒数第k个节点
(8)单链表反转
(9)从尾到头逆序打印单链表，类似于反转
完整代码贴于文末。

首先定义一个节点MyNode

package com.company.linkedlist;

/**
 * 每个MyNode对象就是一个节点
 */
public class MyNode {
    public int no;
    public String name;
    public String nickName;
    /**
     * 指向下一个节点
     */
    public MyNode next;

    public MyNode(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "MyNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

接下来定义单链表：

package com.company.linkedlist;

import java.util.Stack;

/**
 * 单链表
 * <p>
 * 思路：
 * 给定链表一个虚拟的头节点，便于操作
 */
public class SingleLinkedList {
    /**
     * 先初始化一个虚拟头节点，虚拟头节点不动，不存放具体的数据
     */
    private MyNode mVirtualHeadNode = new MyNode(0, "", "");

    /**
     * 返回虚拟头节点
     */
    public MyNode getVirtualHeadNode() {
        return mVirtualHeadNode;
    }

}

3.1 乱序添加节点

    /**
     * 添加节点
     * <p>
     * 思路：当不考虑链表的最后节点
     * 1、找到当前链表的最后节点
     * 2、将最后这个节点的next指向新的节点
     */
    public void addNode(MyNode myNode) {
        // 因为mVirtualHeadNode节点不能动，因此需要一个辅助变量tempNode
        MyNode tempNode = mVirtualHeadNode;

        // 遍历链表，找到最后
        while (true) {
            // 找到链表的最后
            if (tempNode.next == null) {
                break;
            }
            // 如果没有找到最后，将tempNode后移
            tempNode = tempNode.next;
        }

        /*
        当退出while循环时，tempNode就指向了链表的最后，
        再将最后这个节点的next指向新的节点
         */
        tempNode.next = myNode;
    }

测试代码：

package com.company.linkedlist;

public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        MyNode myNode1 = new MyNode(1, "宋江", "及时雨");
        MyNode myNode2 = new MyNode(2, "卢俊义", "玉麒麟");
        MyNode myNode3 = new MyNode(3, "吴用", "智多星");
        MyNode myNode4 = new MyNode(4, "林冲", "豹子头");
        // 创建单链表
        SingleLinkedList mSingleLinkedList = new SingleLinkedList();

        // 乱序添加节点
        mSingleLinkedList.addNode(myNode4);
        mSingleLinkedList.addNode(myNode1);
        mSingleLinkedList.addNode(myNode3);
        mSingleLinkedList.addNode(myNode2);
        
        // 遍历链表
        mSingleLinkedList.showList();
    }

}

测试效果：
添加节点

3.2 乱序添加，根据规则排序（即操作完成后是有序的）

    /**
     * 根据顺序添加节点（乱序添加,操作完成后是有序的）
     */
    public void addNodeByOrder(MyNode myNode) {
        /*
        因为虚拟头节点不能动，所以需要一个辅助指针（变量）来帮助找到添加的位置。
        因为单链表，我们找的tempNode是位于添加位置的前一个节点，否则插入不了
         */
        MyNode tempNode = mVirtualHeadNode;
        // 表示添加的序号是否存在，默认为false
        boolean flag = false;

        while (true) {
            // 已到链表的最后
            if (tempNode.next == null) {
                break;
            }
            // 找到位置，就在tempNode的后面插入
            if (tempNode.next.no > myNode.no) {
                break;
            }
            // 希望添加的节点序号已存在
            if (tempNode.next.no == myNode.no) {
                flag = true;
                break;
            }
            // 后移，遍历当前链表
            tempNode = tempNode.next;
        }

        if (flag) {
            System.out.printf("该序号已存在，不可插入~~\n", myNode.no);
        } else {
            // 插入到链表中，tempNode的后面
            myNode.next = tempNode.next;
            tempNode.next = myNode;
        }
    }

测试代码：

        // 乱序添加，顺序显示节点
        mSingleLinkedList.addNodeByOrder(myNode4);
        mSingleLinkedList.addNodeByOrder(myNode1);
        mSingleLinkedList.addNodeByOrder(myNode3);
        mSingleLinkedList.addNodeByOrder(myNode2);

        // 遍历链表
        mSingleLinkedList.showList();

测试效果：
顺序添加节点

3.3 删除节点

    /**
     * 删除节点
     * <p>
     * 1、虚拟头节点不动，仍需要一个辅助变量tempNode用来找到待删除节点的前一个节点
     * 2、比较时，用tempNode.next.no与待删除节点的no比较
     *
     * @param myNode 此处可传入节点，也可传入节点序号
     */
    public void deleteNode(MyNode myNode) {
        MyNode tempNode = mVirtualHeadNode;
        // 表示是否找到待删除节点
        boolean flag = false;

        while (true) {
            // 已找到链表最后
            if (tempNode.next == null) {
                break;
            }
            // 找到待删除节点的前一个节点，即tempNode
            if (tempNode.next.no == myNode.no) {
                flag = true;
                break;
            }
            // tempNode后移，遍历
            tempNode = tempNode.next;
        }

        if (flag) {
            tempNode.next = tempNode.next.next;
        } else {
            System.out.printf("待删除节点不存在，请核实~~\n", myNode.no);
        }
    }

测试代码：

mSingleLinkedList.deleteNode(myNode2);

删除效果：
删除节点

3.4 修改节点

    /**
     * 修改节点
     * <p>
     * 根据序号来修改，因此序号不能动
     */
    public void updateNode(MyNode myNode) {
        // 是否为空表
        if (mVirtualHeadNode.next == null) {
            System.out.println("链表为空，无法修改~~");
            return;
        }

        // 根据序号找到要修改的节点，此处也需要一个辅助变量
        MyNode tempNode = mVirtualHeadNode.next;
        // 是否找到该节点
        boolean flag = false;

        while (true) {
            // 已遍历完链表
            if (tempNode == null) {
                break;
            }
            // 找到该节点
            if (tempNode.no == myNode.no) {
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }

        if (flag) {
            tempNode.name = myNode.name;
            tempNode.nickName = myNode.nickName;
        } else {
            System.out.printf("未找到序号为%d的节点，请核实~~\n", myNode.no);
        }
    }

检测修改效果：

        MyNode myNode = new MyNode(2, "小卢", "麒麟哥~");
        mSingleLinkedList.updateNode(myNode);

效果图：
修改节点

3.5 遍历单链表

    /**
     * 遍历（显示）单链表
     */
    public void showList() {
        // 判断链表是否为空
        if (mVirtualHeadNode.next == null) {
            System.out.println("链表为空");
            return;
        }

        // 虚拟头节点不动，此处仍需要一个辅助变量tempNode来帮助遍历
        MyNode tempNode = mVirtualHeadNode.next;

        while (true) {
            // 到链表最后
            if (tempNode == null) {
                break;
            }

            System.out.println(tempNode);

            // 将tempNode后移，此处需注意
            tempNode = tempNode.next;
        }
    }

检测遍历效果：

       mSingleLinkedList.showList();

遍历链表的效果图就是前面看到的各种效果哦。

3.6 获取单链表中节点的个数

    /**
     * 获取单链表的节点个数（若是带虚拟节点的链表，则不统计虚拟节点）
     *
     * @param virtualHeadNode 链表的虚拟头节点
     * @return 有效节点的个数
     */
    public static int getLength(MyNode virtualHeadNode) {
        // 空链表
        if (virtualHeadNode.next == null) {
            return 0;
        }

        int length = 0;
        // 定义一个辅助变量（不统计虚拟头、尾节点）
        MyNode curNode = virtualHeadNode.next;

        while (curNode != null) {
            length++;
            // 遍历
            curNode = curNode.next;
        }

        return length;
    }

检测代码：

        System.out.println("有效节点个数：" + SingleLinkedList.getLength(mSingleLinkedList.getVirtualHeadNode()));

效果：
获取节点个数

3.7 查询单链表的倒数第k个节点

    /**
     * 查找单链表中的倒数第k个节点
     * <p>
     * 思路：
     * 1、编写一个方法，接收head节点，同时接收一个index
     * 2、index表示倒数第index个节点
     * 3、先把链表从头到尾遍历，得到链表的总长度size，见getLength()
     * 4、得到size后，从链表的第一个节点开始遍历（size-index）个就可以得到
     * 5、若找到了就返回该节点，否则返回null
     *
     * @param virtualHeadNode 虚拟头节点
     * @param index           倒数第index个节点
     * @return 返回查找到的节点
     */
    public static MyNode findIndexNode(MyNode virtualHeadNode, int index) {
        // 如果链表为空，返回null
        if (virtualHeadNode.next == null) {
            return null;
        }
        // 第一次 遍历得到链表的长度（节点个数）
        int size = getLength(virtualHeadNode);
        // 第二次遍历size-index位置，就是倒数第k个节点
        if (index <= 0 || index > size) {
            return null;
        }

        // 定义辅助变量，for循环定位到倒数的index
        MyNode curNode = virtualHeadNode.next;
        for (int i = 0; i < size - index; i++) {
            curNode = curNode.next;
        }

        return curNode;
    }

测试代码：

        MyNode findNode = SingleLinkedList.findIndexNode(mSingleLinkedList.getVirtualHeadNode(), 2);
        System.out.println("倒数第2节点是：" + findNode.toString());

效果：
倒数第k个节点

3.8 单链表反转

    /**
     * 单链表反转
     */
    public static void reverseList(MyNode virtualHeadNode) {
        // 如果当前链表为空，或只有一个节点，则无需反转
        if (virtualHeadNode.next == null || virtualHeadNode.next.next == null) {
            return;
        }

        // 定义一个辅助指针（变量），帮助遍历原来的链表
        MyNode curNode = virtualHeadNode.next;
        // 指向当前节点curNode的下一个节点
        MyNode nextNode = null;
        MyNode reverseHeadNode = new MyNode(0, "", "");

        // 遍历原来的链表，每遍历一个节点就将其取出，并放在新的链表reverseHeadNode的最前端
        while (curNode != null) {
            // 先暂时保存当前节点的下一个节点，备用
            nextNode = curNode.next;
            // 将curNode的下一个节点指向新的链表的最前端
            curNode.next = reverseHeadNode.next;
            // 将curNode连接到新的链表上
            reverseHeadNode.next = curNode;
            // 让curNode后移
            curNode = nextNode;
        }

        // 将virtualHeadNode.next指向reverseHeadNode.next，实现单链表反转
        virtualHeadNode.next = reverseHeadNode.next;
    }

测试代码：

        SingleLinkedList.reverseList(mSingleLinkedList.getVirtualHeadNode());

效果：
反转单链表

3.9 从尾到头逆序打印单链表，类似于反转

该例需要用到栈结构Stack，这里先给一个Stack的示例。

package com.company.linkedlist;

import java.util.Stack;

/**
 * 演示栈Stack的基本使用
 */
public class TestStack {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        // 入栈
        stack.add("jack");
        stack.add("tom");
        stack.add("smith");

        // 出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }
}

调用出栈方法后，就已经实现逆序效果了：
栈的示例
以上就是栈Stack的示例，接下来看逆序打印链表。

逆序打印单链表代码：

    /**
     * 从尾到头逆序打印单链表，类似于反转
     * <p>
     * 思路：
     * 将各个节点压入栈中，利用栈的先进后出的特性实现逆序打印
     */
    public static void reversePrint(MyNode virtualHeadNode) {
        // 空链表不能打印
        if (virtualHeadNode.next == null) {
            return;
        }

        // 创建一个栈，将各个节点压入栈
        Stack<MyNode> stack = new Stack<>();
        MyNode curNode = virtualHeadNode.next;

        // 将链表的所有节点压入栈
        while (curNode != null) {
            stack.push(curNode);
            // curNode后移，这样可以压入下一个节点
            curNode = curNode.next;
        }

        // 出栈即为逆序
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

测试代码：

       SingleLinkedList.reversePrint(mSingleLinkedList.getVirtualHeadNode());

效果：
逆序单链表

4 完整代码

4.1 SingleLinkedList.java:

package com.company.linkedlist;

import java.util.Stack;

/**
 * 单链表
 * <p>
 * 思路：
 * 给定链表一个虚拟的头节点，便于操作
 */
public class SingleLinkedList {
    /**
     * 先初始化一个虚拟头节点，虚拟头节点不动，不存放具体的数据
     */
    private MyNode mVirtualHeadNode = new MyNode(0, "", "");

    /**
     * 返回虚拟头节点
     */
    public MyNode getVirtualHeadNode() {
        return mVirtualHeadNode;
    }

    /**
     * 添加节点
     * <p>
     * 思路：当不考虑链表的最后节点
     * 1、找到当前链表的最后节点
     * 2、将最后这个节点的next指向新的节点
     */
    public void addNode(MyNode myNode) {
        // 因为mVirtualHeadNode节点不能动，因此需要一个辅助变量tempNode
        MyNode tempNode = mVirtualHeadNode;

        // 遍历链表，找到最后
        while (true) {
            // 找到链表的最后
            if (tempNode.next == null) {
                break;
            }
            // 如果没有找到最后，将tempNode后移
            tempNode = tempNode.next;
        }

        /*
        当退出while循环时，tempNode就指向了链表的最后，
        再将最后这个节点的next指向新的节点
         */
        tempNode.next = myNode;
    }

    /**
     * 根据顺序添加节点（乱序添加,操作完成后是有序的）
     */
    public void addNodeByOrder(MyNode myNode) {
        /*
        因为虚拟头节点不能动，所以需要一个辅助指针（变量）来帮助找到添加的位置。
        因为单链表，我们找的tempNode是位于添加位置的前一个节点，否则插入不了
         */
        MyNode tempNode = mVirtualHeadNode;
        // 表示添加的序号是否存在，默认为false
        boolean flag = false;

        while (true) {
            // 已到链表的最后
            if (tempNode.next == null) {
                break;
            }
            // 找到位置，就在tempNode的后面插入
            if (tempNode.next.no > myNode.no) {
                break;
            }
            // 希望添加的节点序号已存在
            if (tempNode.next.no == myNode.no) {
                flag = true;
                break;
            }
            // 后移，遍历当前链表
            tempNode = tempNode.next;
        }

        if (flag) {
            System.out.printf("该序号已存在，不可插入~~\n", myNode.no);
        } else {
            // 插入到链表中，tempNode的后面
            myNode.next = tempNode.next;
            tempNode.next = myNode;
        }
    }

    /**
     * 删除节点
     * <p>
     * 1、虚拟头节点不动，仍需要一个辅助变量tempNode用来找到待删除节点的前一个节点
     * 2、比较时，用tempNode.next.no与待删除节点的no比较
     *
     * @param myNode 此处可传入节点，也可传入节点序号
     */
    public void deleteNode(MyNode myNode) {
        MyNode tempNode = mVirtualHeadNode;
        // 表示是否找到待删除节点
        boolean flag = false;

        while (true) {
            // 已找到链表最后
            if (tempNode.next == null) {
                break;
            }
            // 找到待删除节点的前一个节点，即tempNode
            if (tempNode.next.no == myNode.no) {
                flag = true;
                break;
            }
            // tempNode后移，遍历
            tempNode = tempNode.next;
        }

        if (flag) {
            tempNode.next = tempNode.next.next;
        } else {
            System.out.printf("待删除节点不存在，请核实~~\n", myNode.no);
        }
    }

    /**
     * 修改节点
     * <p>
     * 根据序号来修改，因此序号不能动
     */
    public void updateNode(MyNode myNode) {
        // 是否为空表
        if (mVirtualHeadNode.next == null) {
            System.out.println("链表为空，无法修改~~");
            return;
        }

        // 根据序号找到要修改的节点，此处也需要一个辅助变量
        MyNode tempNode = mVirtualHeadNode.next;
        // 是否找到该节点
        boolean flag = false;

        while (true) {
            // 已遍历完链表
            if (tempNode == null) {
                break;
            }
            // 找到该节点
            if (tempNode.no == myNode.no) {
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }

        if (flag) {
            tempNode.name = myNode.name;
            tempNode.nickName = myNode.nickName;
        } else {
            System.out.printf("未找到序号为%d的节点，请核实~~\n", myNode.no);
        }
    }

    /**
     * 遍历（显示）单链表
     */
    public void showList() {
        // 判断链表是否为空
        if (mVirtualHeadNode.next == null) {
            System.out.println("链表为空");
            return;
        }

        // 虚拟头节点不动，此处仍需要一个辅助变量tempNode来帮助遍历
        MyNode tempNode = mVirtualHeadNode.next;

        while (true) {
            // 到链表最后
            if (tempNode == null) {
                break;
            }

            System.out.println(tempNode);

            // 将tempNode后移，此处需注意
            tempNode = tempNode.next;
        }
    }

    /**
     * 获取单链表的节点个数（若是带虚拟节点的链表，则不统计虚拟节点）
     *
     * @param virtualHeadNode 链表的虚拟头节点
     * @return 有效节点的个数
     */
    public static int getLength(MyNode virtualHeadNode) {
        // 空链表
        if (virtualHeadNode.next == null) {
            return 0;
        }

        int length = 0;
        // 定义一个辅助变量（不统计虚拟头、尾节点）
        MyNode curNode = virtualHeadNode.next;

        while (curNode != null) {
            length++;
            // 遍历
            curNode = curNode.next;
        }

        return length;
    }

    /**
     * 查找单链表中的倒数第k个节点
     * <p>
     * 思路：
     * 1、编写一个方法，接收head节点，同时接收一个index
     * 2、index表示倒数第index个节点
     * 3、先把链表从头到尾遍历，得到链表的总长度size，见getLength()
     * 4、得到size后，从链表的第一个节点开始遍历（size-index）个就可以得到
     * 5、若找到了就返回该节点，否则返回null
     *
     * @param virtualHeadNode 虚拟头节点
     * @param index           倒数第index个节点
     * @return 返回查找到的节点
     */
    public static MyNode findIndexNode(MyNode virtualHeadNode, int index) {
        // 如果链表为空，返回null
        if (virtualHeadNode.next == null) {
            return null;
        }
        // 第一次 遍历得到链表的长度（节点个数）
        int size = getLength(virtualHeadNode);
        // 第二次遍历size-index位置，就是倒数第k个节点
        if (index <= 0 || index > size) {
            return null;
        }

        // 定义辅助变量，for循环定位到倒数的index
        MyNode curNode = virtualHeadNode.next;
        for (int i = 0; i < size - index; i++) {
            curNode = curNode.next;
        }

        return curNode;
    }

    /**
     * 单链表反转
     */
    public static void reverseList(MyNode virtualHeadNode) {
        // 如果当前链表为空，或只有一个节点，则无需反转
        if (virtualHeadNode.next == null || virtualHeadNode.next.next == null) {
            return;
        }

        // 定义一个辅助指针（变量），帮助遍历原来的链表
        MyNode curNode = virtualHeadNode.next;
        // 指向当前节点curNode的下一个节点
        MyNode nextNode = null;
        MyNode reverseHeadNode = new MyNode(0, "", "");

        // 遍历原来的链表，每遍历一个节点就将其取出，并放在新的链表reverseHeadNode的最前端
        while (curNode != null) {
            // 先暂时保存当前节点的下一个节点，备用
            nextNode = curNode.next;
            // 将curNode的下一个节点指向新的链表的最前端
            curNode.next = reverseHeadNode.next;
            // 将curNode连接到新的链表上
            reverseHeadNode.next = curNode;
            // 让curNode后移
            curNode = nextNode;
        }

        // 将virtualHeadNode.next指向reverseHeadNode.next，实现单链表反转
        virtualHeadNode.next = reverseHeadNode.next;
    }

    /**
     * 从尾到头逆序打印单链表，类似于反转
     * <p>
     * 思路：
     * 将各个节点压入栈中，利用栈的先进后出的特性实现逆序打印
     */
    public static void reversePrint(MyNode virtualHeadNode) {
        // 空链表不能打印
        if (virtualHeadNode.next == null) {
            return;
        }

        // 创建一个栈，将各个节点压入栈
        Stack<MyNode> stack = new Stack<>();
        MyNode curNode = virtualHeadNode.next;

        // 将链表的所有节点压入栈
        while (curNode != null) {
            stack.push(curNode);
            // curNode后移，这样可以压入下一个节点
            curNode = curNode.next;
        }

        // 出栈即为逆序
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

    /**
     * 合并两个有序的单链表，合并后的链表仍然有序（请读者思考完成）
     */

}

4.2 SingleLinkedListDemo.java:

package com.company.linkedlist;


public class SingleLinkedListDemo {

    public static void main(String[] args) {
        // 创建节点
        MyNode myNode1 = new MyNode(1, "宋江", "及时雨");
        MyNode myNode2 = new MyNode(2, "卢俊义", "玉麒麟");
        MyNode myNode3 = new MyNode(3, "吴用", "智多星");
        MyNode myNode4 = new MyNode(4, "林冲", "豹子头");
        // 创建单链表
        SingleLinkedList mSingleLinkedList = new SingleLinkedList();

        // 乱序添加节点
        mSingleLinkedList.addNode(myNode4);
        mSingleLinkedList.addNode(myNode1);
        mSingleLinkedList.addNode(myNode3);
        mSingleLinkedList.addNode(myNode2);

        // 乱序添加，顺序显示节点
        mSingleLinkedList.addNodeByOrder(myNode4);
        mSingleLinkedList.addNodeByOrder(myNode1);
        mSingleLinkedList.addNodeByOrder(myNode3);
        mSingleLinkedList.addNodeByOrder(myNode2);

        // 遍历链表
        mSingleLinkedList.showList();
        System.out.println("----");

        // 删除节点
        mSingleLinkedList.deleteNode(myNode2);

        // 修改节点
        MyNode myNode = new MyNode(2, "小卢", "麒麟哥~");
        mSingleLinkedList.updateNode(myNode);

        // 求单链表中有效节点个数
        System.out.println("有效节点个数：" + SingleLinkedList.getLength(mSingleLinkedList.getVirtualHeadNode()));

        // 查找倒数第k个节点
        MyNode findNode = SingleLinkedList.findIndexNode(mSingleLinkedList.getVirtualHeadNode(), 2);
        System.out.println("倒数第2节点是：" + findNode.toString());

        // 反转单链表
        SingleLinkedList.reverseList(mSingleLinkedList.getVirtualHeadNode());

        /*mSingleLinkedList.showList();*/

        // 逆序打印单链表
        SingleLinkedList.reversePrint(mSingleLinkedList.getVirtualHeadNode());
    }

}

说明：
本文整理自韩顺平老师的课程，强烈推荐韩老师的课。

去公众号阅读：
微信公众号

kayyoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
05_单链表简介及其java代码实现
jrrhjww的博客
09-02 248
05_单链表 1.逻辑结构 ​ 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ​ 单链表(带头结点) 逻辑结构示意图如下： 2.单链表的创建与遍历 2.1 思路分析 2.2 代码实现 ​ 首先定义一个节点类 //定义一个HeroNode类，每个HeroNode对象就是单链表中的一个节点 class He
单链表--实现顺序插入、修改、删除
Yeung_ZY的博客
02-20 474
单链表实现顺序插入
SingleLinkedList
05-01
这是我对抽象数据类型SingleLinkedList的实验。 在我的代码中，我创建了任何方法。 有 ： isEmpty（）->检查SLL是否为空 getSize（）->大小属性的评估器 addFirst（int newElement）->在第一个SLL中创建节点 addLast（int newElement）->在最后一个SLL中创建节点 add（int Element，int newElement）->在节点元素之后创建节点 removeFisrt（）->删除第一个节点 removeLast（）->删除最后一个节点 remove（int Element）->删除节点元素 print（String comm）->打印带有注释的SLL中的所有元素节点 纠正我，如果我错了：微笑 感谢您访问我的仓库。 :-)
【数据结构与算法】单链表（SingleLinkedList）
懂得一千零一种,赋予你失败的方法！
02-03 291
文章目录链表一、链表内存存储结构介绍二、链表逻辑结构介绍三、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理♑ 添加英雄时，直接添加到链表的尾部♑ 添加英雄时，根据排名将英雄插入到指定位置 链表 一、链表内存存储结构介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域：当前节点的值， next 域：指向下一个节点 链表的各个节点不一定是连续存储 ---- 靠next域进行节点间的连接指向，最后链表的以NULL值结束 链表分带头节点的链表和没有..
【数据结构】—— 单链表(single linked list)
最新发布
mist的博客
07-08 1346
单链表的功能介绍及实现
单向链表SingleLinkedList
weixin_66598341的博客
09-09 1411
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
使用SingleLinkedList扩展类，允许Add,Remove,Contains
javatoyou
10-28 149
创建两个类 SingleLinkedList&lt;T&gt; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace DevGuideToCollections { /// &lt;summary&...
单链表-数据结构
xiaowanziddd的博客
11-14 399
链表 1.单链表介绍 链表是有序的列表，但是它在内存中是如下 总结：①链表是以节点的方式来存储，是链式存储    ②每个节点包含data域，next域：指向下一个节点    ③如上图所示链表中的各个节点不一定是连续存储    ④链表分带头结点的链表和没有头结点的链表，根据实际的需求来确定 单链表的实际应用举例：水浒传排行榜管理 ①完成对英雄人物的增删改查操作 ②第一种方式在添加英雄时，直接添加到链表的尾部 ③第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名则添加失败并为给出提示） 方式一
单链表SingleLinkedList.zip_data structure
09-21
单链表是计算机科学中一种基础且重要的数据结构，它属于线性表的一种。线性表是由n（n>=0）个相同类型元素组成的有限序列，而单链表则是线性表在内存中的动态表示形式。在单链表中，每个元素称为节点，每个节点包含...
1.2 单链表SingleLinkedList实现
m0_56841352的博客
05-11 138
import java.util.List; //链式存储，引用方式来实现树，用链条维系关系 public class TreeNode<E> {//定义一个TreeNode,泛型最后要替换成具体的类型：字符串、巴拉巴拉 public E key;//自身节点中的数据 public TreeNode<E> parent;//他有一个引用parent，指向父节点 public List<TreeNode<E>> children;/...
《算法》---- 单链表和双链表基础(SingleLinkedList & DoubleLinkedList)
相扑小猫的博客
01-13 227
目录Single Linked List构造链表在表头插入结点从表头删除结点在表尾插入结点在表尾删除结点其他位置的插入和删除操作遍历Double Linked List构造链表在表头插入结点从表头删除结点在表尾插入结点在表尾删除结点插入特定位置结点删除特定位置结点获取特定位置结点的值比较两个链表 Single Linked List 构造链表 在表头插入结点 从表头删除结点 在表尾插入结点 在表尾删除结点 其他位置的插入和删除操作 遍历 Double Linked List 构造链表 在表头插入结点 从表头
SingleLinkedList.zip
07-19
单链表算法实现增删改查，就地逆置、倒数第k个节点。不使用java任何工具方法，纯原生单链表，前插，修改，尾插，逆置等
singly_linked_list:单链列表，使用命令获取输入文件并输出结果列表
03-15
singly_linked_list:单链列表，使用命令获取输入文件并输出结果列表
Ch3-SingleLinkedList
gaoxiangnumber1——Gao Xiang's Blog
09-26 337
Please indicate the source if you want to reprint: http://blog.csdn.net/gaoxiangnumber1 SingleLinkedList.h#ifndef SINGLELINKEDLIST_H_INCLUDED #define SINGLELINKEDLIST_H_INCLUDED using std::cout; using
单链表Single Linked List
你好，时光的博客
09-14 170
链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表介绍 单链表(带头结点) 逻辑结构示意图如下 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作， 注: 删除和修改,查找 第一种方法在添加英雄时，直接添加到链
（新手学数据结构的小白必备！！）Python学习笔记之链表！！！
Kinght_123的博客
11-19 429
文章目录一、单向链表1.节点的实现2.创建单链表3.链表的基本操作①判断链表是否为空②返回链表的长度③遍历整个链表④链表头部添加元素，头插法⑤链表尾部添加元素,尾插法⑥指定位置添加元素,pos从0开始⑦删除节点⑧查找节点是否存在 一、单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域的elem用来存放具体的数据 链接域next用来存放下一个节点的位置（pytho
单链表singleLinkedList
wdg0809的博客
11-28 101
package com.shizhong.linkedlist; import java.util.Stack; public class SingleLinkedListDemo { public static void main(String[] args) { //创建节点 HeroNode hero1 = new HeroNode(1,"songjiang","jishiyu"); HeroNode hero2 = new...
Java数据结构与算法之单链表SingleLinkedList
mos1896的博客
03-18 286
这里写目录标题一级标题二级标题三级标题四级标题五级标题六级标题1.顺序插入的单链表1.1 HeroNode.java(单链表中的节点类)1.2 SingleLinkedList.java(单链表类，每个对象对应一个单链表)1.2.1 代码分析1.3 Main1.java(测试类)1.3.1 结果分析1.3.2 原始代码（对象不可以作为左值，引用可以）2.添加额外功能（学会1，则2就水到渠成）2.1 修改指定no的节点和删除指定no的节点2.2 此时的Main1.java2.3 结果展示3.单链表常见面试题3
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值