双向链表的简单实现

package dataStructure;

public class DoubleLinkedList<T> {

    private final Node<T> head;
    private int count = 0;

    public DoubleLinkedList()
    {
        head = new Node<T>(null,null,null);
        head.pre = head;
        head.next = head;
    }

    public int size()
    {
        return count;
    }

    public boolean isEmpty()
    {
        return count == 0;
    }

    public void add(T data)
    {
        Node<T> n = new Node<T>(data, head.pre, head);
        head.pre = n;
        n.pre.next = n;
        count ++;

    }

    private Node<T> getNode(int index)
    {
        if(index < 0 || index >count)
        {
            throw new IndexOutOfBoundsException();
        }
        Node<T> tmp = head;
        if(index <= count/2)
        {
            for(int i= 0;i<index;i++)
            {
                tmp = tmp.next;
            }
        }
        else
        {
            for(int i=0;i< count-index;i++)
            {
                tmp = tmp.pre;
            }
        }
        return tmp;
    }

    public T get(int index)
    {
        Node<T> n = getNode(index);
        return n.data;
    }

    public void del(int index)
    {
        Node<T> n = getNode(index);
        n.pre.next = n.next;
        n.next.pre = n.pre;
        count--;

    }
    public String toString()
    {
        StringBuffer sb = new StringBuffer();
        Node<T> n = head;
        for(int i = 0;i<count+1;i++)
        {
            sb.append(n.toString()).append("-->");
            n = n.next;
        }
        return sb.toString();
    }
    private class Node<T>
    {
        T data;
        Node<T> pre;
        Node<T> next;
        public Node(T data,Node<T> pre,Node<T> next)
        {
            this.data = data;
            this.pre = pre;
            this.next = next;
        }

        public String toString()
        {
            return "data:"+this.data;
        }

    }

    public static void main(String[] args)
    {
        DoubleLinkedList<Integer> d = new DoubleLinkedList<>();
        System.out.println(d);
        for (int i = 0 ;i<10;i++)
        {
            d.add(i);
        }
        System.out.println(d.toString());
        System.out.println(d.get(1));
        d.del(1);
        System.out.println(d.get(1));
        System.out.println(d);

    }
}

参考http://www.cnblogs.com/skywang12345/p/3561803.html#a33

原文地址:https://www.cnblogs.com/jesh/p/8811269.html

时间: 2024-11-09 00:31:07

双向链表的简单实现的相关文章

双向链表的简单Java实现-sunziren

写在前面,csdn的那篇同名博客就是我写的,我把它现在在这边重新发布,因为我实在不想用csdn了,那边的广告太多了,还有就是那个恶心人的"阅读更多"按钮,惹不起我躲得起. 在上次分享完单向链表的简单编写后,索性对于双向链表进行了一定的了解,在上次的基础上进行了一定程度的改进,做了一个非循环的双向链表. 双向链表的特点在于每个节点不仅知道自己的下属节点而且还知道自己的父节点.在双向链表的逆序方法中,我使用的队列来支持这个操作,利用了队列的先进先出的特点. 1 package demo_4

双向链表实现简单的list

双向链表结构: 定义一个如下结构体 struct Node { Object data; Node *next; Node *prev; }; 下面为list的具体实现: #include <iostream> using namespace std; template <typename Object> class List { private: //链表结点的定义 struct Node { Object data; Node *next; Node *prev; Node(c

c语言 双向链表的简单操作-创建、插入、删除

数据结构-双向链表的创建.插入和删除 双向链表是数据结构中重要的结构,也是线性结构中常用的数据结构,双向指针,方便用户从首结点开始沿指针链向后依次遍历每一个结点,结点的前驱和后继查找方便. #include <stdio.h> #include <stdlib.h> //双向链表结点的定义 typedef struct dbnode { int data; struct dbnode *prio, *next; }DbNode, linkdblist; //创建双向链表 DbNod

双向链表(3) - 反转双向链表

双向链表的反转过程,可以参考下面的例图: (a) 原始双向链表 (b) 反转后的双向链表 下面是一个用于反转双向链表的简单方法.所需要做的事情就是交换每个节点的前向指针和后向指针,然后调整链表的头指针和尾指针. #include <iostream> struct Node { int data; Node *next; // 指向下一个节点 Node *prev; // 指向前一个节点 }; //对链表进行反转 void reverse(Node **head) { Node *temp =

JAVA实现单双向链表的增、删、改、查

单向链表 package com.ywx.link; /** * 单向链表 * @author vashon * */ public class LinkTest { public static void main(String[] args) { Link l=new Link(); l.addNode("A"); l.addNode("B"); l.addNode("C"); l.addNode("D"); l.addNo

redis 5.0.7 源码阅读——双向链表

redis中动态字符串sds相关的文件为:adlist.h与adlist.c 一.数据结构 redis里定义的双向链表,与普通双向链表大致相同 单个节点: 1 typedef struct listNode { 2 struct listNode *prev; 3 struct listNode *next; 4 void *value; 5 } listNode; 链表: 1 typedef struct list { 2 listNode *head; 3 listNode *tail; 4

一口气说出Redis 5种数据结构及对应使用场景,面试要加分的

整理了一些Java方面的架构.面试资料(微服务.集群.分布式.中间件等),有需要的小伙伴可以关注公众号[程序员内点事],无套路自行领取 更多优选 一口气说出 9种 分布式ID生成方式,面试官有点懵了 3万字总结,Mysql优化之精髓 为了不复制粘贴,我被逼着学会了JAVA爬虫 技术部突然宣布:JAVA开发人员全部要会接口自动化测试框架 写在前边 也当过面试官,面试过不少应聘者,因为是我自己招人自己用,所以我不会看应聘者造火箭的技术有多牛比,只看拧螺丝的手艺瓷不瓷实.毕竟以后是一个整体,拖了大家后

详谈双向链表的实现与简单操作

1.单链表的一个优点是结构简单,但是它也有一个缺点,即在单链表中只能通过一个结点的引用访问其后续结点,而无法直接访问其前驱结点,要在单链表中找到某个结点的前驱结点,必须从链表的首结点出发依次向后寻找,但是需要Ο (n)时间.为此我们可以扩展单链表的结点结构,使得通过一个结点的引用,不但能够访问其后续结点,也可以方便的访问其前驱结点.扩展单链表结点结构的方法是,在单链表结点结构中新增加一个域,该域用于指向结点的直接前驱结点.扩展后的结点结构是构成双向链表的结点结构.在双向链表中进行查找与在单链表中

C语言双向链表简单实现及图示(初始化/插入节点/删除节点)

-------------------------------------------- 双向链表 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 和单向链表相比有以下优势: 插入删除不需要移动元素外,可以原地插入删除 可以双向遍历 - - - - -