JAVA 代码实现链表

最新推荐文章于 2024-08-17 08:59:42 发布
最新推荐文章于 2024-08-17 08:59:42 发布
阅读量6.7k 收藏 2
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构
记录平时的问题，完全是给自己看的，垃圾博客，浪费各位大佬时间...
本文链接：https://blog.csdn.net/qq_40794973/article/details/101555091
版权

1. 有虚拟头节点

设置虚拟头节点统一逻辑处理

 

public class LinkedList<E> {
    private class Node {
        public E e;
        public Node next;
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
        public Node(E e) {
            this(e, null);
        }
        public Node() {
            this(null, null);
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node dummyHead;
    private int size;
    public LinkedList() {
        dummyHead = new Node();
        size = 0;
    }
// 获取链表中的元素个数
public int getSize() {
    return size;
}
// 返回链表是否为空
public boolean isEmpty() {
    return size == 0;
}
// 在链表的index(0-based)位置添加新的元素e
// 在链表中不是一个常用的操作，练习用
public void add(int index, E e) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Add failed. Illegal index.");
    }
    Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }
    prev.next = new Node(e, prev.next);
    size++;
}
// 在链表头添加新的元素e
public void addFirst(E e) {
    add(0, e);
}
// 在链表末尾添加新的元素e
public void addLast(E e) {
    add(size, e);
}
// 获得链表的第index(0-based)个位置的元素
// 在链表中不是一个常用的操作，练习用：
public E get(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Get failed. Illegal index.");
    }
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    return cur.e;
}
// 获得链表的第一个元素
public E getFirst() {
    return get(0);
}
// 获得链表的最后一个元素
public E getLast() {
    return get(size - 1);
}
// 修改链表的第index(0-based)个位置的元素为e
// 在链表中不是一个常用的操作，练习用：
public void set(int index, E e) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Set failed. Illegal index.");
    }
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    cur.e = e;
}
// 查找链表中是否有元素e
public boolean contains(E e) {
    Node cur = dummyHead.next;
    while (cur != null) {
        if (cur.e.equals(e)) {
            return true;
        }
        cur = cur.next;
    }
    return false;
}
// 从链表中删除index(0-based)位置的元素, 返回删除的元素
// 在链表中不是一个常用的操作，练习用
public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Remove failed. Index is illegal.");
    }
    Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }
    Node retNode = prev.next;
    prev.next = retNode.next;
    retNode.next = null;
    size--;
    return retNode.e;
}
// 从链表中删除第一个元素, 返回删除的元素
public E removeFirst() {
    return remove(0);
}
// 从链表中删除最后一个元素, 返回删除的元素
public E removeLast() {
    return remove(size - 1);
}
// 从链表中删除元素e
public void removeElement(E e) {
    Node prev = dummyHead;
    while (prev.next != null) {
        if (prev.next.e.equals(e)) {
            break;
        }
        prev = prev.next;
    }
    if (prev.next != null) {
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size--;
    }
}
@Override
public String toString(){
    StringBuilder res = new StringBuilder();
    //Node cur = dummyHead.next;
    //while(cur != null){
    //    res.append(cur + "->");
    //    cur = cur.next;
    //}
    for(Node cur = dummyHead.next ; cur != null ; cur = cur.next) {
        res.append(cur + "->");
    }
    res.append("NULL");
    return res.toString();
}
//LinkedList<Integer> linkedList = new LinkedList<>();
//for (int i = 0; i < 5; i++) {
//    linkedList.addFirst(i);
//    System.out.println(linkedList);
//}
//
//linkedList.add(2, 666);
//System.out.println(linkedList);
//
//linkedList.remove(2);
//System.out.println(linkedList);
//
//linkedList.removeFirst();
//System.out.println(linkedList);
//
//linkedList.removeLast();
//System.out.println(linkedList);

0->NULL
1->0->NULL
2->1->0->NULL
3->2->1->0->NULL
4->3->2->1->0->NULL
4->3->666->2->1->0->NULL
4->3->2->1->0->NULL
3->2->1->0->NULL
3->2->1->NULL

2. 递归实现链表

/**
 * Recursion
 */
public class LinkedListR<E> {
    private class Node {
        public E e;
        public Node next;
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
        public Node(E e) {
            this(e, null);
        }
        public Node() {
            this(null, null);
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }

    // 在链表的递归实现中，我们不使用虚拟头结点，也能无差异的处理位置0的问题：
    private Node head;
    private int size;
    public LinkedListR() {
        head = null;
        size = 0;
    }
// 获取链表中的元素个数
public int getSize() {
    return size;
}
// 返回链表是否为空
public boolean isEmpty() {
    return size == 0;
}
// 在链表的index(0-based)位置添加新的元素e
public void add(int index, E e) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("Add failed. Illegal index.");
    }
    head = add(head, index, e);
    size++;
}
// 在以node为头结点的链表的index位置插入元素e，递归算法
private Node add(Node node, int index, E e) {
    if (index == 0) {
        return new Node(e, node);
    }
    node.next = add(node.next, index - 1, e);
    return node;
}
// 在链表头添加新的元素e
public void addFirst(E e) {
    add(0, e);
}
// 在链表末尾添加新的元素e
public void addLast(E e) {
    add(size, e);
}
// 获得链表的第index(0-based)个位置的元素
public E get(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Get failed. Illegal index.");
    }
    return get(head, index);
}
// 在以node为头结点的链表中，找到第index个元素，递归算法
private E get(Node node, int index) {
    if (index == 0) {
        return node.e;
    }
    return get(node.next, index - 1);
}
// 获得链表的第一个元素
public E getFirst() {
    return get(0);
}
// 获得链表的最后一个元素
public E getLast() {
    return get(size - 1);
}
// 修改链表的第index(0-based)个位置的元素为e
public void set(int index, E e) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Update failed. Illegal index.");
    }
    set(head, index, e);
}
// 修改以node为头结点的链表中，第index(0-based)个位置的元素为e，递归算法
private void set(Node node, int index, E e) {
    if (index == 0) {
        node.e = e;
        return;
    }
    set(node.next, index - 1, e);
}
// 查找链表中是否有元素e
public boolean contains(E e) {
    return contains(head, e);
}
// 在以node为头结点的链表中，查找是否存在元素e，递归算法
private boolean contains(Node node, E e) {
    if (node == null) {
        return false;
    }
    if (node.e.equals(e)) {
        return true;
    }
    return contains(node.next, e);
}
// 从链表中删除index(0-based)位置的元素, 返回删除的元素
public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Remove failed. Index is illegal.");
    }
    Pair<Node, E> res = remove(head, index);
    size--;
    head = res.getKey();
    return res.getValue();
}
// 从以node为头结点的链表中，删除第index位置的元素，递归算法
// 返回值包含两个元素，删除后的链表头结点和删除的值：）
private Pair<Node, E> remove(Node node, int index) {
    if (index == 0) {
        return new Pair<>(node.next, node.e);
    }
    Pair<Node, E> res = remove(node.next, index - 1);
    node.next = res.getKey();
    return new Pair<>(node, res.getValue());
}
// 从链表中删除第一个元素, 返回删除的元素
public E removeFirst() {
    return remove(0);
}
// 从链表中删除最后一个元素, 返回删除的元素
public E removeLast() {
    return remove(size - 1);
}
// 从链表中删除元素e
public void removeElement(E e) {
    head = removeElement(head, e);
}
// 从以node为头结点的链表中，删除元素e，递归算法
private Node removeElement(Node node, E e) {
    if (node == null) {
        return null;
    }
    if (node.e.equals(e)) {
        size--;
        return node.next;
    }
    node.next = removeElement(node.next, e);
    return node;
}
@Override
public String toString() {
    StringBuilder res = new StringBuilder();
    Node cur = head;
    while (cur != null) {
        res.append(cur + "->");
        cur = cur.next;
    }
    res.append("NULL");
    return res.toString();
}

 

//LinkedListR<Integer> list = new LinkedListR<>();
//for (int i = 0; i < 10; i++) {
//    list.addFirst(i);
//    System.out.println(list);
//}
//while (!list.isEmpty()) {
//    System.out.println("removed " + list.removeLast());
//    System.out.println(list);
//}

3. 实现链表栈

public interface Stack<E> {
    int getSize();
    boolean isEmpty();
    // 入栈
    void push(E e);
    // 出栈
    E pop();
    // 返回栈顶元素
    E peek();
}
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> list;
    public LinkedListStack(){
        list = new LinkedList<>();
    }
    @Override
    public int getSize(){
        return list.getSize();
    }
    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }
    @Override
    public void push(E e){
        list.addFirst(e);
    }
    @Override
    public E pop(){
        return list.removeFirst();
    }
    @Override
    public E peek(){
        return list.getFirst();
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(list);
        return res.toString();
    }
}
//LinkedListStack<Integer> stack = new LinkedListStack<>();
//for(int i = 0 ; i < 5 ; i ++){
//    stack.push(i);
//    System.out.println(stack);
//}
//stack.pop();
//System.out.println(stack);

Stack: top 0->NULL
Stack: top 1->0->NULL
Stack: top 2->1->0->NULL
Stack: top 3->2->1->0->NULL
Stack: top 4->3->2->1->0->NULL
Stack: top 3->2->1->0->NULL

4. 链表栈和数组栈对比

动态数组实现栈：ttps://blog.csdn.net/qq_40794973/article/details/101471730

//public class Main {
//    // 测试使用stack运行opCount个push和pop操作所需要的时间，单位：秒
//    private static double testStack(Stack<Integer> stack, int opCount) {
//        long startTime = System.nanoTime();
//        Random random = new Random();
//        for (int i = 0; i < opCount; i++) {
//            stack.push(random.nextInt(Integer.MAX_VALUE));
//        }
//        for (int i = 0; i < opCount; i++) {
//            stack.pop();
//        }
//        long endTime = System.nanoTime();
//        return (endTime - startTime) / 1000000000.0;
//    }
//    public static void main(String[] args) {
//        int opCount = 100000;
//
//        ArrayStack<Integer> arrayStack = new ArrayStack<>();
//        double time1 = testStack(arrayStack, opCount);
//        System.out.println("ArrayStack, time: " + time1 + " s");
//
//        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
//        double time2 = testStack(linkedListStack, opCount);
//        System.out.println("LinkedListStack, time: " + time2 + " s");
//        // 其实这个时间比较很复杂，因为LinkedListStack中包含更多的new操作
//    }
//}

整体差别不大，当数据很大的时候数组栈稍微有优势，应为链表每次都需要new对象

爪 哇
关注
专栏目录
java实现单链表完整代码
weixin_46305401的博客
02-25 946
java实现单链表完整代码 创建一个Node类，为了方便，我把main方法也写在这个类里。 class Node { Object data;//数据域 Node next;//指针域 //构造方法 public Node() { } public Node(Object data) { this.data = data; } public static void main(String[] args) {
链表的原理及java实现代码示例
08-28
"链表的原理及Java实现代码示例" 链表是一种基本的数据结构，它的实现原理不同于数组。链表的优点是插入和删除操作效率高，而缺点是循环遍历时效率不高。Java中使用的LinkedList的实现原理就是链表。 单向链表的...
java实现链表结构详细代码
weixin_30375247的博客
03-31 160
一、数据准备 　1.　定义节点 2. 定义链表 1.数据部分 2.节点部分 class DATA //数据节点类型 { String key; String name; int age; } class CLType ...
Java“链表“——数据结构（这一篇就够了）
最新发布
m0_73158088的博客
08-17 1191
本篇对数据结构中的"链表"进行详细的讲解 本期会分成一下五部分进行讲解： 1.链表的概念 2.链表的种类 3.链表的实现方法 4.代码实现链表 5.链表的常见使用场景
java链表源码_JAVA之链表源码
weixin_36178269的博客
02-27 177
class TLinkNode>{int size = 0;TNode root = null;TNode reverseRoot = null;TNode reverseRootStack = null;//查找链表中的结点public TNode findNode(T data){TNode p = root;while(p != null){if (p.getData() == dat...
java 实现节点链表
系统运维
01-12 237
链结点 在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做 LINK。因为一个链表中有许多类似的链结点，所以有必要用一个不同于链表的类来表达 链结点。每个LINK对象中都包含一个对下一个点引用的字段（通常叫做next）但是 本身的对象中有一个字段指向对第一个链结点的引用 单链表是一种顺序存取的结构，为找第i个数据元素，必须先找到第i-1个数 ...
Java实现代码-链表
hotpots--火锅技术栈
03-15 2226
如下代码:package 数据结构; class node { node next; int data; public node(node next, int data) { super(); this.next = next; this.data = data; } public String toString() { return "next:" + next +...
Java语言实现反转链表代码示例
08-29
Java语言实现反转链表代码示例 Java是一种广泛应用于软件开发的编程语言，而链表是编程中的一种重要数据结构。反转链表是链表操作中的一种基本操作，它可以应用于各种实际场景中。下面我们将详细介绍Java语言实现...
java单向链表代码实现
12-25
以上代码实现了一个简单的单向链表，包括插入、删除、遍历和获取链表长度的功能。在实际的软件开发中，链表常被用作基础数据结构，特别是在需要频繁进行插入和删除操作而对顺序访问性能要求不高的场景。例如，解析...
Java 数据结构链表操作实现代码
09-01
在Java中，我们可以使用对象来实现链表。链表分为单链表、循环链表和双向链表。 单链表是每个节点包含数据部分和指向下一个节点的引用。在Java中，我们可以创建一个类来表示链表节点，如`SNode`，它有一个`data`...
java双向循环链表的实现代码
09-05
据传入的增量修改长度，可以加减）* @param delta 长度增量，正数表示增加，负数表示减少*/private void changeSize(int delta){if (linkedId == null) throw new RuntimeException("该节点未绑定到任何链表");...
java实现链表
09-24
链表是一种物理存储单元上非连续、非顺序的存储结构。 java代码实现单链表，插入，删除和遍历等功能。 链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。
单向链表实现(java代码)
qq_22993855的博客
09-11 495
单向链表实现以及常见的面试题收录(java代码) Java代码 package com.bingym.linkedlist; import java.util.Stack; public class SingleLinkedListByOrder { //实现单向链表功能:链表的添加add(可以按照编号index进行插入),链表内容的打印 //内部需要包含一个节点类:内部类/外部类都可以 //定义单向链表的属性 private Node head =new Node(
java中链表的底层实现_Java 链表的底层实现
weixin_31861055的博客
02-25 137
package com.soto.collection;/*** add 和 get方法** @author 王**/public class SxtLinkedList /*implements List*/ { //双向链表，private Node first; //(第一个结点)链，获得第一个，就能继续往下找了private Node last; //(最后一个结点)链表由结点...
JAVA中用代码实现一个链表结构
步城曦
04-05 771
首先我们简单的解释一下这个链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一...
用java代码实现链表结构_java实现链表结构
weixin_29371981的博客
02-26 140
package edu.hue.ji.list;// 自定义链表类class TheList{Object obj; //链表的值TheList next; // 链表的直接后继public TheList() {super();}//链表的初始化方法TheList(Object obj){this.obj=obj;this.next=null; ...
java代码实现链表
uhana的博客
04-04 1679
java代码实现链表
Java-实现链表数据结构
weixin_45203607的博客
01-13 938
什么是链表？ 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。 每一个链表都包含多个节点，节点又包含两个部分，一个是数据域（储存节点含有的信息），一个是引用域（储存下一个节点或者上一个节点的地址）。 链表的理解示意图: ...
利用java实现一个简单的链表结构
weixin_34378045的博客
01-10 128
定义： 所谓链表就是指在某节点存储数据的过程中还要有一个属性用来指向下一个链表节点，这样的数据存储方式叫做链表 链表优缺点： 优点：易于存储和删除 缺点：查询起来较麻烦 下面我们用java来实现如下链表结构： 首先定义节点类： 复制代码 package LinkTest; /** 链表节点类 @author admin / public class Node { private int va...
用java代码实现链表
07-10
以下用Java代码实现链表的示例： ```java // 定义链表节点类 class Node { int data; Node next; public Node(int data) { this.data = data; this.next = null; } } // 定义链表类 class LinkedList { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值