单链表的实现（单向无头不循环链表）+增删改查等功能

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量160 收藏
点赞数
分类专栏： Java基础 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WJ20170921/article/details/109191545
版权 
注意：
* 如果想弄清楚单链表的原理，可以通过画图＋代码去理解。
* 我的单链表实现了11个功能，文章前面具体列出了每个方法的代码，以及详细的代码注释和个人解释。
* 如果只要整个源代码，可以直接到文章末尾。包含完整的单链表源代码和main函数测试代码，以及每个方法的测试结果。
* 
* 码字不易，也达不到深入理解，但都是经过测试可以运行的。如果有问题，欢迎提出，欢迎白嫖。
1. 实现链表中的单向无头不循环链表
  • 单向指的是每个节点只有后继节点的引用。
  • 无头指的是，不含有头节点，也就是头节点不固定。在本次单链表实现中，为了方便打印，查找等功能，我们将会定义一个可变头节点
  • 不循环指的是，尾结点指向空，整个链表不构成一个环。
2. 单链表数据结构
  1. 每个单链表由n个节点构成。一个节点有两个域，一个data值域，用来存放当前节点的值。另外一个域是引用域，用来存放后继节点的引用。因此，我们可以定义一个节点类，其中包含基本数据类型data，以及后继节点的引用的引用类型next。
/**
 * Node节点类
 */
class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
    }
}
  1. 单链表中包含许多方法，比如插入，删除，等等。我们为了方便方法，可以在单链表类开始，定义一个全局引用head。
//单链表的实现类
public class MySinglyLinkedList {
    //头节点
    public Node head;
    }
  1. 单链表类中还有许多方法，接下来，将一一实现。
3.单链表实现增删改查等功能
1. 头插法：每次插入数据，都在链表的第一个位置。
/**
     * 头插法
     * @param data
     */
    public void addFirst(int data) {
        //将data数据变成一个节点类型
        Node node = new Node(data);
        //欲要插入的节点的后继节点指向原来头节点
        node.next = this.head;
        //头节点置为新的节点
        this.head = node;
    }
2. 尾插法：每次插入的数据放在最后，即接在原来尾结点后面。
    /**
     * 尾插法
     * @param data
     */
    public void addLast(int data) {
        Node node = new Node(data);
        //判断头节点是否为空
        if (this.head == null) {
            this.head = node;
            return;
        }
        //初始化一个节点，并指向头节点
        Node cur = this.head;
        //循环，找到尾结点
        while (cur.next != null) {
            cur = cur.next;
        }
        //将尾结点的后继节点指向欲要插入节点
        cur.next = node;
        //新插入节点成为新的尾结点，所以next域置为空
        node.next =null;
    }
3. 打印链表：因为单链表有n个节点，所以用自己的打印方法，可以很方便的打印一个单链表。
/**
     * 打印单链表
     */
    public void display() {
        //初始化一个节点
        Node cur = this.head;
            //循环，打印每一个节点的data域，即每个节点的值
            while (cur != null) {
            System.out.print(cur.data+"  ");
            cur = cur.next;
        }
        System.out.println();
    }
4. 获取单链表长度：通过循环，从头节点移动到尾结点，每移动一个节点，计数变量count加一
/**
     * 获取单链表长度
     * @return
     */
    public int size() {
        //初始化一个int类，用来计数
        int count = 0;
        Node cur = this.head;
        //循环，每移动一个节点，count加一
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }
5. 查找index号位置节点的前驱节点。头节点从0开始计算，查找某一个位置的前一个节点。
/**
     * 查找index号位置节点的前驱节点
     * @param index
     * @return
     */
    public Node searchPrevIndex(int index) {
        //判断位置是否合法，size（）方法调用的前面第4个写的求链表长度方法
        if (index <= 0 || index >= size()) {
            return null;
        }
        Node prev = this.head;
        int count = 0;
        //循环，从0开始，小于index-1的位置，即index的前驱结点
        while (count < index - 1) {
            prev = prev.next;
            count++;
        }
        //返回index的前驱结点
        return prev;
    }
6. 任意位置插入：一个下标index，一个数据data。
/**
     * 任意位置插入，下标从0开始
     * @param index
     * @param data
     */
    public void addIndex(int index,int data) {
        //如果插入第一个，则直接调用前面写的头插法方法
        if (index == 0) {
            addFirst(data);
            //如果插入位置等于单链表长度，即是尾插法，直接调用前面写的尾插方法
        } else if (index == size()) {
            addLast(data);
        } else {
            //调用通过下标查找前驱节点的方法
            Node cur = searchPrevIndex(index);
            Node node = new Node(data);
            //将要插入的节点的next域指向前驱节点的next域
            node.next = cur.next;
            //前驱节点的next域指向新节点
            cur.next = node;
        }
    }
7. 查找是否包含某个关键字key。
/**
     * 查找是否包含某个关键字
     * @param key
     * @return
     */
    public boolean contains(int key) {
        //判断头节点是否为空
        if (this.head == null) {
            return false;
        } else {
            Node cur = this.head;
            //循环
            while (cur != null) {
                //判断当前节点的data域是否等于key
                if (cur.data == key) {
                    return true;
                }
                //cur节点后移一位
                cur = cur.next;
            }
            return false;
        }
    }
8. 查找关键字key的前驱节点：通过查找单链表中是否含有关键字key，没有返回null，有则返回key节点的前驱节点。
/**
     * 查找关键字key的前驱
     * @param key
     * @return
     */
    public Node searchPrevKey(int key) {
        Node prev = this.head;
        //循环
        while (prev.next != null) {
            //判断当前节点的下一个节点的data域是否等于关键字key
            if (prev.next.data == key) {
                return prev;
            }
            //当前节点后移一位
            prev = prev.next;
        }
        return null;
    }
9. 删除第一次出现的关键字：只删除一次，没有关键字则不删除。
/**
     * 删除第一个出现的关键字key
     * @param key
     */
    public void removeKey(int key) {
        //判断头节点是否为空
        if (this.head == null) {
            return;
        }
        //调用前面写的，通过关键字key查找前驱节点的方法
        Node del = searchPrevKey(key);
        //如果删除的节点的前驱节点为空，即删除单链表的头节点
        if (del == null) {
            //直接将头节点指向头节点的下一个节点
            this.head = this.head.next;
            //判断，如果删除节点的前驱节点，它的下一个的下一个节点为空，即删除尾结点
        } else if (del.next.next == null) {
            //直接将删除节点的前驱节点的next域置为空
            del.next = null;
        } else {
            //否则，删除节点的前驱节点，它的next指向前驱节点的下一个的下一个
            del.next = del.next.next;
        }
    }
10. 删除单链表中，所有关键字为key的节点。此方法不用循环调用前面删除一个关键字的方法，而是遍历单链表一次，删除所有关键字节点。
  • 首先定义一个无用节点，值随便给，让它指向头节点。
  • 然后从这个节点的下一个节点开始判断，这样可以方便的解决，需要删除头节点关键字而带来的麻烦。
/**
     * 删除所有关键字为key
     * @param key
     */
    public void removeKeyAll(int key) {
        //判断头节点
        if (this.head == null) {
            return;
        }
        //初始化一个无用的头节点
        Node myHead = new Node(-1);
        //再定义一个节点用来保存自己初始化的无用节点，后面会用到
        Node temp = myHead;
        //让这个无用节点的next域指向头节点
        myHead.next = this.head;

        //循环
        while (myHead.next != null) {
            //从无用节点的下一个节点的data域判断是否等于关键字
            if (myHead.next.data == key) {
                //判断，如果当前节点的下一个节点的下一个next指向null，即代表将要删除尾结点
                if (myHead.next.next == null) {
                    //直接将当前节点额next域置为空
                    myHead.next = null;
                    //并返回，因为最后一个节点都遍历完了，不再需要执行下面代码
                    return;
                } else {
                    //否则，即删除的不是尾结点且不等于关键字，那么后移
                    myHead.next = myHead.next.next;
                }
            }
            //无用节点后移
            myHead = myHead.next;
        }
        //因为无用节点和头节点都乱了，所以欲要重置head，指向刚刚保存无用节点的下一个节点
        this.head = temp.next;
    }
11. 清空链表。如果直接将头节点置为空，那么头节点后面的节点的next域还有指向关系，这些存在指向关系的节点，因为我们不知道他们的引用（因为我们已经把头节点的引用置为空了），而引用又不为空，所以JVM不会自动回收。就会造成内存泄露。为此，我们必须利用循环，将每一个节点的next域都置为空，这样才会被系统自动回收。
/**
     * 清空单链表，防止内存泄漏
     * 将单链表每个next都置为空
     */
    public void clear() {
        //循环，将每一个节点的next域都置为空
        while (this.head != null) {
            Node cur = this.head.next;
            this.head = null;
            this.head = cur;
        }
    }
4. 完整源代码
  • 单链表类（包含单链表的方法+节点Node类）
package day9_10_20;

/**
 * @author：fover
 * @version：1.0
 * @function：单链表的实现
 */
public class MySinglyLinkedList {
    //头节点
    public Node head;

    /**
     * 头插法
     * @param data
     */
    public void addFirst(int data) {
        //将data数据变成一个节点类型
        Node node = new Node(data);
        /*
        * 可以不判断头节点是否为空
        if (head == null) {
            head = node;
            return;
        }
         */
        //欲要插入的节点的后继节点指向原来头节点
        node.next = this.head;
        //头节点置为新的节点
        this.head = node;
    }

    /**
     * 尾插法
     * @param data
     */
    public void addLast(int data) {
        Node node = new Node(data);
        //判断头节点是否为空
        if (this.head == null) {
            this.head = node;
            return;
        }
        //初始化一个节点，并指向头节点
        Node cur = this.head;
        //循环，找到尾结点
        while (cur.next != null) {
            cur = cur.next;
        }
        //将尾结点的后继节点指向欲要插入节点
        cur.next = node;
        //新插入节点成为新的尾结点，所以next域置为空
        node.next =null;
    }

    /**
     * 任意位置插入，下标从0开始
     * @param index
     * @param data
     */
    public void addIndex(int index,int data) {
        //如果插入第一个，则直接调用前面写的头插法方法
        if (index == 0) {
            addFirst(data);
            //如果插入位置等于单链表长度，即是尾插法，直接调用前面写的尾插方法
        } else if (index == size()) {
            addLast(data);
        } else {
            //调用通过下标查找前驱节点的方法
            Node cur = searchPrevIndex(index);
            Node node = new Node(data);
            //将要插入的节点的next域指向前驱节点的next域
            node.next = cur.next;
            //前驱节点的next域指向新节点
            cur.next = node;
        }
    }

    /**
     * 打印单链表
     */
    public void display() {
        //初始化一个节点
        Node cur = this.head;
            //循环，打印每一个节点的data域，即每个节点的值
            while (cur != null) {
            System.out.print(cur.data+"  ");
            cur = cur.next;
        }
        System.out.println();
    }

    /**
     * 获取单链表长度
     * @return
     */
    public int size() {
        //初始化一个int类，用来计数
        int count = 0;
        Node cur = this.head;
        //循环，每移动一个节点，count加一
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

    /**
     * 查找index号位置节点的前驱节点
     * @param index
     * @return
     */
    public Node searchPrevIndex(int index) {
        //判断位置是否合法，size（）方法调用的前面第4个写的求链表长度方法
        if (index <= 0 || index >= size()) {
            return null;
        }
        Node prev = this.head;
        int count = 0;
        //循环，从0开始，小于index-1的位置，即index的前驱结点
        while (count < index - 1) {
            prev = prev.next;
            count++;
        }
        //返回index的前驱结点
        return prev;
    }

    /**
     * 查找关键字key的前驱
     * @param key
     * @return
     */
    public Node searchPrevKey(int key) {
        Node prev = this.head;
        //循环
        while (prev.next != null) {
            //判断当前节点的下一个节点的data域是否等于关键字key
            if (prev.next.data == key) {
                return prev;
            }
            //当前节点后移一位
            prev = prev.next;
        }
        return null;
    }

    /**
     * 查找是否包含某个关键字
     * @param key
     * @return
     */
    public boolean contains(int key) {
        //判断头节点是否为空
        if (this.head == null) {
            return false;
        } else {
            Node cur = this.head;
            //循环
            while (cur != null) {
                //判断当前节点的data域是否等于key
                if (cur.data == key) {
                    return true;
                }
                //cur节点后移一位
                cur = cur.next;
            }
            return false;
        }
    }

    /**
     * 删除第一个出现的关键字key
     * @param key
     */
    public void removeKey(int key) {
        //判断头节点是否为空
        if (this.head == null) {
            return;
        }
        //调用前面写的，通过关键字key查找前驱节点的方法
        Node del = searchPrevKey(key);
        //如果删除的节点的前驱节点为空，即删除单链表的头节点
        if (del == null) {
            //直接将头节点指向头节点的下一个节点
            this.head = this.head.next;
            //判断，如果删除节点的前驱节点，它的下一个的下一个节点为空，即删除尾结点
        } else if (del.next.next == null) {
            //直接将删除节点的前驱节点的next域置为空
            del.next = null;
        } else {
            //否则，删除节点的前驱节点，它的next指向前驱节点的下一个的下一个
            del.next = del.next.next;
        }
    }

    /**
     * 删除所有关键字为key
     * @param key
     */
    public void removeKeyAll(int key) {
        //判断头节点
        if (this.head == null) {
            return;
        }
        //初始化一个无用的头节点
        Node myHead = new Node(-1);
        //再定义一个节点用来保存自己初始化的无用节点，后面会用到
        Node temp = myHead;
        //让这个无用节点的next域指向头节点
        myHead.next = this.head;

        //循环
        while (myHead.next != null) {
            //从无用节点的下一个节点的data域判断是否等于关键字
            if (myHead.next.data == key) {
                //判断，如果当前节点的下一个节点的下一个next指向null，即代表将要删除尾结点
                if (myHead.next.next == null) {
                    //直接将当前节点额next域置为空
                    myHead.next = null;
                    //并返回，因为最后一个节点都遍历完了，不再需要执行下面代码
                    return;
                } else {
                    //否则，即删除的不是尾结点且不等于关键字，那么后移
                    myHead.next = myHead.next.next;
                }
            }
            //无用节点后移
            myHead = myHead.next;
        }
        //因为无用节点和头节点都乱了，所以欲要重置head，指向刚刚保存无用节点的下一个节点
        this.head = temp.next;
    }

    /**
     * 清空单链表，防止内存泄漏
     * 将单链表每个next都置为空
     */
    public void clear() {
        //循环，将每一个节点的next域都置为空
        while (this.head != null) {
            Node cur = this.head.next;
            this.head = null;
            this.head = cur;
        }
    }

}

/**
 * Node节点类
 */
class Node {
    public int data;
    public Node next;

    public Node(int data) {
        this.data = data;
    }
}
  • main方法测试类
package day9_10_20;

import org.w3c.dom.Node;

/**
 * @author：fover
 * @date：2020/10/20 10:31
 * @version：1.0
 * @function：单链表测试
 */
public class MySinglyLinkedListTest {
    public static void main(String[] args) {
        MySinglyLinkedList myList = new MySinglyLinkedList();

        System.out.println("1、头插法1,2,3,4,5测试：");
        myList.addFirst(1);
        myList.addFirst(2);
        myList.addFirst(3);
        myList.addFirst(4);
        myList.addFirst(5);
        myList.display();

        System.out.println("2、打印测试：");
        myList.display();

        System.out.println("3、尾插法6,7,8,9,10测试：");
        myList.addLast(6);
        myList.addLast(7);
        myList.addLast(8);
        myList.addLast(9);
        myList.addLast(10);
        myList.display();

        System.out.println("4、查找3号位置前驱节点测试：");
        System.out.println(myList.searchPrevIndex(3).data);

        System.out.println("5、获取单链表长度测试：");
        System.out.println(myList.size());

        System.out.println("6、在10号位置插入元素99测试：");
        myList.addIndex(10,99);
        myList.display();

        System.out.println("7、是否包含关键字99测试：");
        System.out.println(myList.contains(99));

        System.out.println("8、查找关键字99的前驱测试：");
        System.out.println(myList.searchPrevKey(99).data);

        System.out.println("9、删除第一个出现的关键字99测试：");
        myList.removeKey(99);
        myList.display();

        System.out.println("10、删除所有关键字8测试：");
        myList.addIndex(4,8);
        myList.addIndex(1,8);
        myList.addIndex(0,8);
        System.out.print("删除前：");
        myList.display();
        System.out.print("删除后：");
        myList.removeKeyAll(8);
        myList.display();

        System.out.println("11、清空单链表测试(防止内存泄露)：");
        myList.clear();
        myList.display();
        System.out.println("-----------结束------------");
    }
}
  • 测试结果展示
    在这里插入图片描述
欢迎白嫖，感谢提出问题^ - ^
codeOct
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
c++实现链表增删改查
07-17
c++实现链表增删改查
数据结构之无头单向不循环链表
qq_53822523的博客
07-02 293
数据结构之无头单向不循环链表详解
单向链表增删改查的实现
bairen7411的博客
08-18 117
/*实现单向链表的增删改查 */#include <malloc.h>#include <stdio.h>#include<stdlib.h>#define LEN sizeof(node) typedef struct node{ int num; struct node *next;}node,*pnode; /*在链表头进行插入，新节点成为头...
数据结构无头结点单向不循环链表（C语言版）
qq_45767476的博客
04-29 199
main.c(负责测试） #include <stdlib.h> #include <stdio.h> #include <time.h> #include "nohead.h" int main() { LNode *list = NULL; struct score_st data[10],mydata,data1; int i = 0; srand((unsigned)time(NULL)); //初始化数组 for (i = 0; i < 10;
链式存储（无头单向不循环链表）
zhang21722668的博客
08-28 511
1.链表的分类（8种） 单向 | 双向 有头 | 没有头 有循环 | 无循环 2.顺序表 和 链表优缺点 顺序表 随机下标访问 链表 便于增删（不是尾巴） 3.概念 一个个空间 空间中承载的数据 空间之间用链式结构串起来（next）next==NULL 表示结尾 4.链表 增删(改)查 Push Back | Front | Pos Pop Back | Front ...
数据结构入门：无头单向不循环链表的实现
Darling_sheeps的博客
03-15 194
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中指针的连接次序实现的。 在8中链表中，常用的有两种：无头单向不循环链表和带头循环双向链表。 首先，无头单项不循环链表的结构简单，但是一般不用来存储数据，实际中更多的是作为其他数据结构的子结构，比如：哈希桶、图的邻接表等； 下面是其增删查改等操作的代码实现： typedef int SLDataType; /结点（数...
数据结构 严薇敏 单链表（无头结点）的实现(增 删 改 查)及其使用方法详解
qq_50119037的博客
03-19 1317
1.与顺序表的对比 书接上回！我们修炼了顺序表的内功，但是在很多使用场景，他都很受限制！ 缺点： 插入删除的时候，还记得吗！我们都要搬运元素到指定位置，时间复杂度是O(N). 你的顺序表容量是提前给的，扩容的时候还要拷贝数据，开辟新空间，释放旧空间，会有很大的性能消耗。 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。若每次扩容扩少一点，则会导致频繁扩容，频繁扩容同样也会有性能消耗
Java描述数据结构学习之链表的增删改查详解
08-27
本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但在内存中它并不是顺序存储的，而是以...
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。下面我们将详细探讨这个系统的设计与实现。 首先，我们要理解双向循环链表的基本概念。双向循环...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
单链表操作(不带头 不循环) C语言
weixin_73062623的博客
08-31 107
包括 新增节点，头插，尾插，头删，尾删，打印链表，删除指定节点，替换数据。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 829
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 901
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1022
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 829
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Java 线程池详解
qq_41591215的博客
07-13 963
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 161
【JAVA】相关程序组件
用单向链表实现增删改查
05-17
下面是用单向链表实现增删改查的代码实现： ```python # 定义单向链表节点类 class ListNode: def __init__(self, val): self.val = val self.next = None # 定义单向链表类 class LinkedList: def __init__...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值