Java双链表实现数据的增删改查(CRUD)!

Java双链表实现数据的增删改查(CRUD)!

简单的说一下单链表与双链表的区别：

单链表：单链表有一个指针和一个数据域，所以单链表只能通过这一个指针进行正向的访问节点的数据，操作简单。

双链表：除了有一个指向下一结点的指针外，还有一个指向前一结点的指针，可以通过前指针快速找到前一结点，但多了一个指针，所以需要的存储空间大于单链表，同时具有从双向链表中的任意一个结点开始,都可以很方便地访问前驱结点和后继结点。

适用场景
单向链表更适合元素的增加与删除，双向链表更适合元素的查询工作。

代码也就不多解释都有注释的

package List;

/**
 * @author ganxiang
 * IDE      IntelliJ IDEA
 * @project_name and filename JavaDemo DoubleList
 * @date 2020/02/25 0025 09:50
 */


public class DoubleList {

    class  DefineDoubleNode{
        int data;
        DefineDoubleNode pre;
        DefineDoubleNode next;
        public DefineDoubleNode(){//初始化链表
            this.data=0;
            this.pre =null;
            this.next=null;
        }
        public DefineDoubleNode (int data){
            this.data=data;
        }//初始化链表
        public  int getData(){
            return data;
        }//获取节点数据
        public void setData(int data){
            this.data =data;
        }//设置节点数据
        public DefineDoubleNode getPre(){
            return pre;
        }//获取前驱节点地址
        public void setPre(DefineDoubleNode pre){
            this.pre=pre;
        }//设置前驱节点地址
        public DefineDoubleNode getNext(){
            return this.next;
        }//获取下一个节点地址
        public void setNext(DefineDoubleNode next){
            this.next =next;
        }//设置下一个节点的地址

    }
    public  void printList(DefineDoubleNode ahead){//正向遍历链表
        while (ahead!=null){
            System.out.print(ahead.getData());
            System.out.print(" ");
            ahead=ahead.getNext();
        }
    }

    public void reversePrintList(DefineDoubleNode head){//反向遍历链表
        DefineDoubleNode ahead =head;
        while (ahead.getNext()!=null){
            ahead =ahead.getNext();
        }
        while (ahead!=null){
            System.out.print(ahead.getData());
            System.out.print(" ");
            ahead =ahead.getPre();
        }
    }

    public int getLength(DefineDoubleNode head){//计算链表长度
        int len=0;
        while (head!=null){
            len++;
            head =head.getNext();
        }
        return  len;
    }
    DefineDoubleNode head=null;//这个head节点之后都是对他操作的，很重要
    public DefineDoubleNode inset_many(DefineDoubleNode head){//插入多个数据
        DefineDoubleNode ahead=head ;
        for (int i=10;i<=15;i++){
           if (ahead==null){
               ahead =new DefineDoubleNode(i);
//               printList(t);
           }
           else{
               DefineDoubleNode thead =ahead;
               while (thead.next!=null){
                   thead= thead.next;
               }
               DefineDoubleNode temp =new DefineDoubleNode();
               temp.setData(i);
               temp.setPre(thead);
               thead.setNext(temp);
//               printList(ahead.next);
           }
        }
        return ahead;
    }
        public DefineDoubleNode addFirst(int data,DefineDoubleNode head){//在头结点插入数据
        DefineDoubleNode temp=new DefineDoubleNode(data);
        DefineDoubleNode ahead =head;
        if(ahead==null)ahead=temp;
        else{
            temp.setPre(null);
            ahead.setPre(temp);
            temp.setNext(ahead);
            ahead =temp;
        }
        return ahead;
    }
    public DefineDoubleNode addLast(int data,DefineDoubleNode head){//在尾节点插入数据
        DefineDoubleNode ahead =head;
        DefineDoubleNode temp =new DefineDoubleNode(data);
        while (ahead.next!=null){
            ahead =ahead.next;
        }
        temp.setPre(ahead);
        temp.setNext(null);
        ahead.setNext(temp);
        return head;
    }
    public  DefineDoubleNode insert_index(int k,int data,DefineDoubleNode head){//在指定的位置k插入数据
        DefineDoubleNode ahead =head;
        if (k<1||k>getLength(ahead))System.out.println("不在操作范围！");
        else if (k==1) return addFirst(data,ahead);
        else  if (k==getLength(ahead)) return addLast(data,ahead);
        else {
            DefineDoubleNode newNode = new DefineDoubleNode(data);
            int count =1;
            DefineDoubleNode temp=ahead;
            while(count<k-1){
                temp=temp.getNext();
                count++;
            }
            DefineDoubleNode curNode =temp.getNext();
            newNode.setNext(curNode);
            newNode.setPre(temp);
            temp.setNext(newNode);
            curNode.setPre(newNode);
        }

        return ahead;
    }

    public DefineDoubleNode delFirst(DefineDoubleNode head){//删除头结点
        DefineDoubleNode ahead =head;
        if (ahead ==null) System.out.println("空表，无法操作！");
        else{
            ahead =ahead.getNext();
            ahead.getNext().setPre(null);
        }
        return ahead;
    }
    public DefineDoubleNode delLast(DefineDoubleNode head){//删除尾结点
        DefineDoubleNode ahead =head;
        while (ahead.getNext().getNext()!=null){
            ahead =ahead.getNext();
        }
        ahead.getNext().setPre(ahead);
        ahead.setNext(null);
        return head;
    }

    public DefineDoubleNode del_index(int k,DefineDoubleNode head){//在指定的位置k删除节点
        DefineDoubleNode ahead =head;
        if (k<1||k>getLength(ahead))System.out.println("不在操作范围！");
        else if (k==1) return delFirst(ahead);
        else if (k==getLength(ahead)) return delLast(ahead);
        else {
            int count=1;
            DefineDoubleNode tmp=ahead;
            while (tmp.getNext()!=null&&count<k-1){
                count++;
                tmp =tmp.getNext();
            }
            DefineDoubleNode curNode =tmp.getNext();
            DefineDoubleNode lastNode =curNode.getNext();
            tmp.setNext(lastNode);
            lastNode.setPre(tmp);
        }
        return ahead;
    }

    public DefineDoubleNode update_First(int data,DefineDoubleNode head){//更新头结点
        DefineDoubleNode ahead =head;
        if(ahead==null)System.out.println("空表，无法操作！");
        else{
            DefineDoubleNode curNode =ahead;
            curNode.setData(data);
            curNode.setPre(null);
            curNode.setNext(curNode.getNext());
        }
        return ahead;

    }
    public DefineDoubleNode update_Last(int data,DefineDoubleNode head){//更新尾结点
        DefineDoubleNode ahead =head;
        if(ahead==null)System.out.println("空表，无法操作！");
        else {
            DefineDoubleNode curNode =ahead;
            DefineDoubleNode newNode =new DefineDoubleNode();
            int count =1;
            while (count<getLength(ahead)-1){
                count++;
                curNode =curNode.getNext();
            }
            newNode.setData(data);
            newNode.setNext(null);
            newNode.setPre(curNode);
            curNode.setNext(newNode);
        }
        return ahead;
    }

    public DefineDoubleNode update_index(int k,int data,DefineDoubleNode head){//在指定的索引位置k更新节点
        DefineDoubleNode ahead =head;
        if (k<1||k>getLength(ahead))System.out.println("不在操作范围！");
        else if (k==1) return update_First(data,ahead);
        else if (k==getLength(ahead)) return update_Last(data,ahead);
        else {
            DefineDoubleNode tmp =ahead;
            DefineDoubleNode newNode =new DefineDoubleNode();
            int count =1;
            while (count<k-1){
                count++;
                tmp =tmp.getNext();
            }
            DefineDoubleNode curNode =tmp.getNext();
            DefineDoubleNode lastNode =curNode.getNext();
            newNode.setData(data);
            newNode.setNext(lastNode);
            tmp.setNext(newNode);
            newNode.setPre(tmp);
        }

        return ahead;
    }
    public static void main(String[] args) {
        DoubleList doubleList =new DoubleList();
//        DefineDoubleNode head =doubleList.inset_One(doubleList.head,12);
//        doubleList.printList(head);
        DefineDoubleNode temp =doubleList.inset_many(doubleList.head);
        System.out.println("insert_many的数据为：");
        doubleList.printList(temp);
        System.out.println();
        System.out.println("insert_many链表的正向数据为:");
        doubleList.printList(temp);
        System.out.println();
        System.out.println("insert_many链表的反向数据为：");
        doubleList.reversePrintList(temp);
        System.out.println();

//        DefineDoubleNode addFirst =doubleList.addFirst(100,temp);
//        System.out.println("addFirst在链表头部插入数据的链表为：");
//        doubleList.printList(addFirst);

//        DefineDoubleNode addLast =doubleList.addLast(200,temp);
//        System.out.println("addLast在链表尾部插入数据的链表为：");
//        doubleList.printList(addLast);

//        DefineDoubleNode insert_index =doubleList.insert_index(5,300,temp);
//        System.out.println("insert_index指定索引插入数据的链表为：");
//        doubleList.printList(insert_index);

//        DefineDoubleNode delFirst =doubleList.delFirst(temp);
//        System.out.println("delFirst()删除头结点的链表数据为：");
//        doubleList.printList(delFirst);

//        DefineDoubleNode delLast =doubleList.delLast(temp);
//        System.out.println("delLast()删除尾结点的链表数据为：");
//        doubleList.printList(delLast);

//        DefineDoubleNode del_index =doubleList.del_index(2,temp);
//        System.out.println("del_index()在指定索引位置删除结点的链表数据为：");
//        doubleList.printList(del_index);
//
//        DefineDoubleNode update_First =doubleList.update_First(500,temp);
//        System.out.println("update_First()更新头结点后链表为：");
//        doubleList.printList(update_First);

//        DefineDoubleNode update_Last =doubleList.update_Last(500,temp);
//        System.out.println("update_First()更新尾结点后链表为：");
//        doubleList.printList(update_Last);

        DefineDoubleNode update_index =doubleList.update_index(5,500,temp);
        System.out.println("update_index()在指定位置更新头结点后链表为：");
        doubleList.printList(update_index);
    }

}

运行展示
更指定的数据 指定k=5 将第五个节点的数据更新为500

指定插入 指定k=5插入节点数据为300

指定删除 k=2的节点