双向链表简单实现

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量159 收藏
点赞数
分类专栏： 数据结构算法 文章标签： java golang 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33399665/article/details/106324739
版权

双向链表

JAVA实现

package com.wc4cloud.list;

import java.util.Iterator;

/**
 * 简单双向链表
 *
 * @author WC
 * @date 2020/5/24
 */
public class LinkedList<T> implements Iterable<T> {

    private Node<T> first;
    private Node<T> last;
    private long size;

    /**
     * 初始化链表
     */
    public LinkedList() {
        // first中不保存实际数据
        first = new Node<>(null, null, null);
        last = null;
        size = 0;
    }

    /**
     * 清空链表
     */
    public void clear() {
        first.next = null;
        last = null;
        size = 0;
    }

    /**
     * 判断链表是否为空
     *
     * @return 为空返回true
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表第一个元素
     *
     * @return 元素
     */
    public T getFirst() {
        if (isEmpty()) {
            return null;
        }
        return first.next.value;
    }

    /**
     * 获取链表最后一个元素
     *
     * @return 元素
     */
    public T getLast() {
        if (isEmpty()) {
            return null;
        }
        return last.value;
    }

    /**
     * 插入元素
     *
     * @param value 被插入的元素
     * @return 成功返回true
     */
    public boolean insert(T value) {
        if (isEmpty()) {
            last = new Node<>(first, value, null);
            first.next = last;
        } else {
            Node<T> newNode = new Node<>(last, value, null);
            last.next = newNode;
            last = newNode;
        }
        size++;
        return true;
    }

    /**
     * 插入元素到特定位置
     *
     * @param value 被插入的元素
     * @param index 插入的位置下标
     * @return 成功返回true
     */
    public boolean insert(T value, int index) {
        if (index < size) {
            Node<T> prev = first;
            for (int i = 0; i < index; i++) {
                prev = prev.next;
            }

            Node<T> current = prev.next;
            Node<T> newNode = new Node<>(prev, value, current);
            prev.next = newNode;
            current.prev = newNode;

            size++;
            return true;
        } else {
            return insert(value);
        }

    }

    /**
     * 获取特定位置的元素
     *
     * @param index 下标
     * @return 查找到的元素
     */
    public T get(int index) {
        if (index >= size) {
            return null;
        }
        Node<T> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.next.value;
    }

    /**
     * 获取元素所在位置的下标
     *
     * @param value 查找元素
     * @return 所在位置下标， 未找到返回-1
     */
    public int indexOf(T value) {
        Node<T> node = first;
        for (int i = 0; node.next != null; i++) {
            node = node.next;
            if (node.value.equals(value)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 移除特定位置的元素
     *
     * @param index 位置下标
     * @return 被移除的元素
     */
    public T remove(int index) {
        if (index < size) {
            Node<T> node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }

            Node<T> current = node.next;
            current.prev.next = current.next;

            size--;
            return current.value;
        }
        return null;
    }

    /**
     * 将特定位置的元素重新赋值
     *
     * @param value 新的赋值
     * @param index 下标位置
     * @return 成功返回true
     */
    public boolean set(T value, int index) {
        if (index >= size) {
            return false;
        }

        Node<T> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        node.next.value = value;
        return true;
    }

    /**
     * 提供for-each方法
     *
     * @return 迭代器
     */
    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {

            private Node<T> node = first;

            @Override
            public boolean hasNext() {
                return node.next != null;
            }

            @Override
            public T next() {
                node = node.next;
                return node.value;
            }
        };
    }

    private static class Node<T> {

        private Node<T> prev;
        private T value;
        private Node<T> next;

        public Node(Node<T> prev, T value, Node<T> next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
}

快慢指针判断环形链表

package com.wc4cloud.list;

/**
 * @author WC
 * @date 2020/5/25
 */
public class CircularLinkedList<T> {

    private static class Node<T> {
        private Node<T> prev;
        private T value;
        private Node<T> next;

        public Node(Node<T> prev, T value, Node<T> next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    public static void main(String[] args) {
        //创建环形链表
        Node<Integer> head = new Node<>(null, 0, null);

        Node<Integer> node = head;
        for (int i = 1; i < 41; i++) {
            node.next = new Node<>(node, i, null);
            node = node.next;
        }
        Node<Integer> circular = head;
        for (int i = 0; i < 15; i++) {
            circular = circular.next;
        }
        node.next = circular;

        //快慢指针确定链表是否有环
        Node<Integer> slow = head;
        Node<Integer> fast = head;
        //临时指针判断环所在位置
        Node<Integer> temp = null;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            if (slow == fast) {
                System.out.println("队列为环形队列");
                temp = head;
                continue;
            }

            if (temp != null) {
                temp = temp.next;
                if (temp == slow) {
                    System.out.println("环形队列入口为:" + temp.value);
                    break;
                }
            }
        }

    }

}

Golang实现

package list

type Node struct {
	prev  *Node
	value interface{}
	next  *Node
}

func NewNode(prev *Node, value interface{}, next *Node) *Node {
	return &Node{prev: prev, value: value, next: next}
}

type LinkedList struct {
	first *Node
	last  *Node
	size  int
}

func NewLinkedList() *LinkedList {
	first := NewNode(nil, nil, nil)
	size := 0
	return &LinkedList{first: first, last: nil, size: size}
}

func (l *LinkedList) Clear() {
	l.first.next = nil
	l.last = nil
	l.size = 0
}

func (l *LinkedList) IsEmpty() bool {
	return l.size == 0
}

func (l *LinkedList) Size() int {
	return l.size
}

func (l *LinkedList) GetFirst() (value interface{}) {
	if l.IsEmpty() {
		return nil
	}
	return l.first.next.value
}

func (l *LinkedList) GetLast() interface{} {
	if l.IsEmpty() {
		return nil
	}
	return l.last.value
}

func (l *LinkedList) Insert(value interface{}) bool {
	if l.IsEmpty() {
		l.last = NewNode(l.first, value, nil)
		l.first.next = l.last
	} else {
		newNode := NewNode(l.last, value, nil)
		l.last.next = newNode
		l.last = newNode
	}
	l.size++
	return true
}

func (l *LinkedList) InsertIndex(value interface{}, index int) bool {
	if index < l.size {
		prev := l.first
		for i := 0; i < index; i++ {
			prev = prev.next
		}

		current := prev.next
		newNode := NewNode(prev, value, current)
		prev.next = newNode
		current.prev = newNode
		l.size++
		return true
	} else {
		return l.Insert(value)
	}
}

func (l *LinkedList) Get(index int) interface{} {
	if index >= l.size {
		return nil
	}
	node := l.first
	for i := 0; i < index; i++ {
		node = node.next
	}
	return node.next.value
}

func (l *LinkedList) IndexOf(value interface{}) int {
	node := l.first
	for i := 0; node.next != nil; i++ {
		node = node.next
		if node.value == value {
			return i
		}
	}
	return -1
}

func (l *LinkedList) Remove(index int) interface{} {
	if index < l.size {
		node := l.first
		for i := 0; i < index; i++ {
			node = node.next
		}

		current := node.next
		current.prev.next = current.next

		l.size--
		return current.value
	}
	return nil
}

func (l *LinkedList) Set(value interface{}, index int) bool {
	if index >= l.size {
		return false
	}

	node := l.first
	for i := 0; i < index; i++ {
		node = node.next
	}
	node.next.value = value
	return false
}
不准欺负我家小猪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 双向链表类模板的一种详细、简单的写法
that_good的博客
05-23 1618
双向类模板链表 一.双向链表 首先我们要复习下双向链表的大概思路： （当然实际储存并不这样摆放的，只是便于理解1） 这是一个节点的基本结构： prev：是一个指向前面一个节点的指针。 next： 是一个指向后面一个节点的指针。 data： 任意T类型的数据。 图例： （三个节点:head， 中间，tail） 可以看到 中间节点的prev存放着head这个节点的地址 中间节点的next存放着tali这个节点的地址 二.双向链表类模板的思路 分为三部分： 节点的构造（struct Node） 代码:
双向链表的简单实现
sinat_39061823的博客
07-10 1630
双向链表： 双向链表和单向链表的不同之处是它的指针域有指向前驱的指针pre和指向后驱的指针next。 typedef struct double_list {     int date;     struct double_list *pre;     struct double_list *next; }list; 双向链表的构成：（以下示意图均摘自来
双向链表详解及C++实现
Weirdo的博客
06-15 546
本文详细介绍了双向链表的基本结构、操作实现以及C++代码示例。双向链表通过引入两个指针（prev和next）来实现对前后节点的访问，从而在插入、删除和遍历等操作上提供了更高的灵活性。在实际应用中，双向链表常用于需要频繁进行节点插入和删除的场景，如LRU（最近最少使用）缓存淘汰算法等。通过掌握双向链表的基本原理和实现方法，读者可以更好地理解和应用这种数据结构。
C语言双向链表的实现
m0_63666616的博客
05-03 4767
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
【数据结构】双向链表的实现
adcxhw的博客
04-07 1297
又是一篇万字文章，建议收藏。
数据结构之双向链表的实现
qq_62905847的博客
10-02 699
java自主实现双向链表
Java实现双向链表
weixin_64448174的博客
06-01 4095
一、双向链表的简单理解 1、双向链表是什么？ 在前面的文章中，我们仔细讲解了单向链表，并且用代码实现了单向链表。单向链表的好处很多，虽然单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 "从前往后" 找，而 "从后往前" 找并不是它的强项，因此我们就有了双向链表这个东西，双向链表顾名思义就是链表的高级版，他与单向链表有所不同的一点在于在具有
链表之双向链表的实现
月亮夹馍干的博客
04-07 520
双向链表的实现（完整代码）
C语言简单的数据结构：双向链表的实现
2302_82004664的博客
04-14 1143
目录： 1.双向链表的结构和初始化 1.1双向链表的结构 1.2双向链表的初始化 2.双向链表的相关操作 2.1双向链表的尾插、打印和头插 2.11双向链表的尾插 2.12双向链表的打印 2.13双向链表的头插 2.2双向链表的尾删和头删 2.21双向链表的尾删 2.22双向链表的头删 2.3双向链表查找和任意位置插入、删除 2.31双向链表查找 2.32双向链表任意位置之后插入 2.33双向链表任意位置删除 2.4双向链表的销毁
Java数据结构：双向链表的实现
黄小黄的博客
10-25 983
本文对比了单链表和双向链表，并对双向链表的具体实现进行了讲解。文中附双向链表实现的完整代码及测试类，供码友们参考学习！
C++双向链表实现简单通讯录
08-19
C++双向链表实现简单通讯录 在本文中，我们将详细介绍C++双向链表实现简单通讯录的实现方法。我们将从头开始，了解C++双向链表的基本概念，然后逐步实现一个简单的通讯录系统。 首先，让我们了解一下C++双向链表...
C++的双向链表实现
04-15
**C++的双向链表实现** 在C++中，双向链表是一种数据结构，它包含节点，每个节点都有指向其前一个节点和后一个节点的指针。这使得在链表中的导航比单链表更加灵活，因为可以向前或向后移动。双向链表在许多算法和...
C语言实现双向链表
09-03
双向链表的优点在于其灵活性，可以在O(1)的时间复杂度内找到前一个或后一个节点，这使得插入和删除操作相对简单。但同时，由于每个节点需要额外存储前后指针，空间开销相对于单链表来说会更大。 需要注意的是，这段...
双向链表通讯录实现.cpp
06-01
用c++实现，添加备注，容易看懂，就一个代码，用双向链表实现通讯录，双向链表通讯录实现，数据结构的一个作业
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 68
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 501
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 757
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1041
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 691
linux上datax 安装以及使用
贪吃蛇双向链表c++实现
03-10
可以使用双向链表来实现贪吃蛇游戏，具体实现方法可以参考以下步骤： 1. 定义一个结构体来表示每个节点，包括...以上是一个简单的双向链表实现贪吃蛇游戏的方法，具体实现还需要考虑游戏逻辑和界面交互等方面的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值