JAVA实现双向链表

原创 2018年04月16日 21:09:47

用java写链表简直爽歪歪
我中有你,你中有我

package task4_14;
interface Link {//接口,放各种链表操作的方法
    void add (Object obj);
    boolean remove (int index);
    int indexOf(Object obj);
    boolean set(int index,Object obj);
    Object get(int index);
    int length();
    void clear();
    Object[] toArray();
    void printLink();
}
class Factory {//工厂类,简化main函数,直接调用Factor类产生一个链表
    private  Factory() {}
    public static Link getLinkInstance() {//产生链表对象
        return new LinkImpl();
    }       
}
class LinkImpl implements Link {//产生链表的类,继承了接口
    private int size = 0;//链表长度
    private Node  first;//头头结点
    private Node last;//尾巴节点
    private class Node {//产生节点的方法
        private Object item;//存放元素
        private Node next;//前一个节点
        private Node prev;//后一个节点
        private Node(Node prev,Object item,Node next) {//产生节点的构造方法,用private私有化,在本类中产生
            this.item = item;
            this.next = next;//后节点
            this.prev = prev;//前节点
        }
    }
    @Override
    public void add(Object obj) {//增加节点,这儿有点绕=.=
        Node tmp = this.last;//先把尾节点存起来
        Node newNode = new Node(tmp, obj, null);//产生一个新节点,里面的头结点放了当前的尾节点
        this.last = newNode;//先放进去,尾节点都要放的,这样,每次都是尾巴,逃不了....惨
        if (null == tmp) {//空的,第一次加节点
            this.first = newNode;//给头结点,以后找后面的节点就靠你了
        }else {
            tmp.next = newNode;//不是空的,就放到.next里
        }
        this.size++;
    }

    @Override
    public boolean remove(int index) {//移除下标为index的对象
        Node tmp = this.first;//不能拿头结点随便玩,那个临时的玩
        if(index <0 || index >this.size) {//判断下标是否合理
            return false;
        }
        while(0 !=index--){//合理,开始找啊
            tmp = tmp.next;
        }//铁定找到了
        tmp.prev.next = tmp.next;//tmp前一个节点的.next指向tmp的下一个节点
        tmp.next.prev = tmp.prev;//tmp的后一个节点的.prev指向tmp的上一个节点//tmp被抛弃
        return true;
    }

    @Override
    public int indexOf(Object obj) {//根据对象找下标
        int i = 0;
        Node tmp = this.first;//老规矩
        if (obj == null) {//对象可能是null,没事放个null在链表里也是闲得慌
            while (null != tmp) {//遍历链表
                if (tmp.item == null) {//找null
                    return i;//找到了,送走
                }
                tmp = tmp.next;//下一个
                i++;
            }
        }
        else {
            while (null != tmp) {//正常的
                if (obj.equals(tmp.item)) {//注意这里,equals的这么用的,如果对象是null,NullPointException
                return i;
                }
            tmp = tmp.next;
            i++;
            }
        }
        return -1;//查无此人

    }
    @Override
    public boolean set(int index, Object obj) {//插呀...
        Node tmp =this.first;
        Node newNode = new Node(null, obj, null);//产生一个新节点
//      Node newNode = null//错误的写法
//      newNode.item = obj;
        if(index <0 || index >this.size) {//下标合理否
            return false;
        }
        while(0 !=index--){//找位置
            tmp = tmp.next;
        }
        newNode.next =tmp.next;//新节点中存下一个节点的位置
        tmp.next = newNode;//上一个加点中存新节点
        newNode.prev =tmp;//新节点中存上一个节点的位置
        newNode.next.prev = newNode;//下一个节点中存新节点
        return true;
    }

    @Override
    public Object get(int index) {//根据下标获取对象
        Node tmp = this.first;
        if(index <0 || index >this.size) {//下标合理否
            return false;
        }
        while (0 !=index--) {//循环找
            tmp = tmp.next;
        }
        return tmp.item;
    }

    @Override
    public int length() {//链表长度
        return this.size;//直接返回size
    }

    @Override
    public void clear() {//清空链表
        Node tmp = this.first;
        while (null !=tmp) {//都得死,一个也跑不了
            Node fina =tmp.next;
            tmp.prev =null;
            tmp.item =null;
            tmp.next =null;
            tmp = fina;
        }//全部干掉
        this.size =0;//置零
        this.last = null;
        this.first = null;//你俩也得死
    }

    @Override
    public Object[] toArray() {//链表转对象数组
        int i = 0;
        Node tmp = this.first;
        Object[] num= new Object[this.size];//看,数组这么用的//创建一个链表那么长的对象数组
        while(null !=tmp) {//放进去
            num [i] = tmp.item;
            tmp = tmp.next;
            i ++;
        }
        while (0 != i--) {//看看放进去没,正好用i吧,不过是倒序
            System.out.println(num[i]);
        }
        return num;
    }

    @Override
    public void printLink() {//打印链表
        Node tmp = this.first;
        while (null != tmp) {
            System.out.println(tmp.item);
            tmp =tmp.next;
        }
    }

}

public class Test {//主类
    public static void main(String[] args) {
        Link link = Factory.getLinkInstance();//调用工厂类的getter方法产生一个链表
        //以下都是测试
        //+++++++++++++++++++ 我是分割线+++++++++++++++++++
        link.add("0");
        link.add("1");
        link.add(null);
        link.add("2");
        link.add("3");
        link.add("4");
        /*测试length(),indexOf(),indexOf(null);
        System.out.println(link.length());
        System.out.println(link.indexOf("2"));
        System.out.println(link.indexOf("1"));
        System.out.println(link.indexOf(null));
        */
//      link.printLink();//打印链表
//      System.out.println("++++++++++++");
//      link.remove(1);
//      link.printLink();//打印链表
//      System.out.println(link.indexOf("4"));
//      System.out.println(link.get(2));//获取下标元素
        //测set
//      link.printLink();//打印链表
//      System.out.println("++++++++++++");
//      link.set(1, "2");
//      link.printLink();//打印链表
        //测clear
//      link.printLink();
//      link.clear();
//      System.out.println("+++++++++++++++++");
//      link.printLink();


        link.printLink();
        System.out.println("+++++++++++++++++");
        link.toArray();
    }
}

//+++++++++++++++++++++++++++++++++++++++==




Java双向链表实现

public class DoublyLinkList { private class Data{ private Object obj; private Data left = null;...
  • a19881029
  • a19881029
  • 2014-04-03 22:42:08
  • 8404

数据结构之双向链表(JAVA实现)

最近重新复习了一些基础的数据结构,发觉自己好多已经淡忘了,索性重新捡起来以前的知识,今天笔者回顾了一下链表的知识,用JAVA实现了一个双向链表,下面来看代码:public class DoubleLi...
  • as02446418
  • as02446418
  • 2015-07-28 23:25:29
  • 2131

Java 实现双向链表,基于双向链表实现双端队列

双向链表: 就是有双向指针 即 双向的链域 链结点的结构: ┌────┬────┬────────┐ │data│next│previous│ └────┴────┴────────┘ 双向链表不必...
  • jjwwmlp456
  • jjwwmlp456
  • 2014-10-26 00:29:49
  • 4751

java链表之--java双向链表的增删改查

单向链表只能从一个方向遍历链表,即只能查找结点的下一个结点(后继结点),而不能查找结点的上一个结点(前驱结点)。鉴于上述问题,引入了双向链表。由于双向循环链表包含双向链表的所有功能操作。因此,我们只讲...
  • basycia
  • basycia
  • 2016-07-06 15:27:06
  • 438

剑指offer:二叉搜索树与双向链表(java)

题目:输入一颗二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建新的结点,只能调整树中结点指针的指向。 比如如下图中的二叉搜索树,则输出转换之后的排序双向链表为:     由于要...
  • abc7845129630
  • abc7845129630
  • 2016-10-03 22:12:04
  • 347

JAVA实现双向链表终极解析!!熟练使用接口

双向链表结构和单向链表的区别:最后一个结点的链接地址上,单向链表是null,而双向链表是表头的链接地址。 即双向链表的head和last互相指向 示意图 表头为空       ...
  • defineshan
  • defineshan
  • 2016-08-21 10:35:47
  • 1216

二叉搜索树与双向链表(java版)

题目描述 输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向。 分析:      对于二叉搜索树,用中序搜索...
  • hll174
  • hll174
  • 2016-03-27 22:18:48
  • 1136

java实现双向链表的操作

单向链表只能单方向的查找链表中的节点,并且在插入或者删除某一个节点的时候,必须知道其的前一个节点。当单向链表的前一个节点指向这个链表的第一个节点的时候称为循环链表。 双向链表的每个结构分为三个部分,...
  • liuwei0604
  • liuwei0604
  • 2013-04-25 07:15:23
  • 707

Java 单链表的反转 以及 双向链表的实现

Java 单链表的反转 双向链表的实现
  • fuckluy
  • fuckluy
  • 2016-03-27 09:34:36
  • 902

实现一个双向链表的倒置功能(1->2->3 变成 3->2->1)

  • 2018年04月15日 13:41
  • 6KB
  • 下载
收藏助手
不良信息举报
您举报文章:JAVA实现双向链表
举报原因:
原因补充:

(最多只允许输入30个字)