单链表和双链表

最新推荐文章于 2024-07-22 15:15:11 发布

原创最新推荐文章于 2024-07-22 15:15:11 发布 · 256 阅读

0 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了链表和双端链表的基本概念、实现方式及操作方法，包括插入、删除、查找等核心功能，展示了链表在数据结构中的应用与灵活性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单链表：是一个Node，存储当前对象，并指向下一个next,；插入在第一位Node，next指向原来的first

单链表：只保存第一个node的引用，

双端链表：保存两个node的引用，第一个和最后一个node,可以从第一个插入，也可以从最后一个插入，也可以从头部和尾部删除

/*
* 链结点，相当于是车厢
*/
public class Node {
   //数据域
   public long data;
   //指针域
   public Node next;

   public Node(long value) {
       this.data = value;
   }

   /**
   * 显示方法
   */
   public void display() {
       System.out.print(data + " ");
   }
}

/*
* 链表，相当于火车
*/
public class LinkList {
   //头结点
   private Node first;

   public LinkList() {
       first = null;
   }

   /**
   * 插入一个结点，在头结点后进行插入
   */
   public void insertFirst(long value) {
       Node node = new Node(value);
       node.next = first;
       first = node;
   }

   /**
   * 删除一个结点，在头结点后进行删除
   */
   public Node deleteFirst() {
       Node tmp = first;
       first = tmp.next;
       return tmp;
   }

   /**
   * 显示方法
   */
   public void display() {
       Node current = first;
       while(current != null) {
           current.display();
           current = current.next;
       }
       System.out.println();
   }

   /**
   * 查找方法
   */
   public Node find(long value) {
       Node current = first;
       while(current.data != value) {
           if(current.next == null) {
               return null;
           }
           current = current.next;
       }
       return current;
   }

   /**
   * 删除方法，根据数据域来进行删除
   */
   public Node delete(long value) {
       Node current = first;
       Node previous = first;
       while(current.data != value) {
           if(current.next == null) {
               return null;
           }
           previous = current;
           current = current.next;
       }

       if(current == first) {
           first = first.next;
       } else {
           previous.next = current.next;
       }
       return current;

   }
}

public static void main(String[] args) {
       LinkList linkList = new LinkList();
       linkList.insertFirst(34);
       linkList.insertFirst(23);
       linkList.insertFirst(12);
       linkList.insertFirst(0);
       linkList.insertFirst(-1);

//       linkList.display();
//
//       linkList.deleteFirst();
//       linkList.display();
//
//       Node node = linkList.find(23);
//       node.display();

       Node node1 = linkList.delete(0);
       node1.display();
       System.out.println();
       linkList.display();
   }

2、双端链表

/*
* 链结点，相当于是车厢
*/
public class Node {
   //数据域
   public long data;
   //指针域
   public Node next;
   public Node previous;

   public Node(long value) {
       this.data = value;
   }

   /**
   * 显示方法
   */
   public void display() {
       System.out.print(data + " ");
   }
}
public class DoubleLinkList {
   //头结点
   private Node first;
   //尾结点
   private Node last;

   public DoubleLinkList() {
       first = null;
       last = null;
   }

   /**
   * 插入一个结点，在头结点后进行插入
   */
   public void insertFirst(long value) {
       Node node = new Node(value);
       if(isEmpty()) {
           last = node;
       } else {
           first.previous = node;
       }
       node.next = first;
       first = node;
   }

   /**
   * 插入一个结点，从尾结点进行插入
   */
   public void insertLast(long value) {
       Node node = new Node(value);
       if(isEmpty()) {
           first = node;
       } else {
           last.next = node;
           node.previous = last;
       }
       last = node;
   }

   /**
   * 删除一个结点，在头结点后进行删除
   */
   public Node deleteFirst() {
       Node tmp = first;
       if(first.next == null) {
           last = null;
       } else {
           first.next.previous = null;
       }
       first = tmp.next;
       return tmp;
   }

   /**
   * 删除结点，从尾部进行删除
   */
   public Node deleteLast() {
       Node tmp = last;
       if(first.next == null) {
           first = null;
       } else {
           last.previous.next = null;
       }
       last = last.previous;
       return last;
   }

   /**
   * 显示方法
   */
   public void display() {
       Node current = first;
       while(current != null) {
           current.display();
           current = current.next;
       }
       System.out.println();
   }

   /**
   * 查找方法
   */
   public Node find(long value) {
       Node current = first;
       while(current.data != value) {
           if(current.next == null) {
               return null;
           }
           current = current.next;
       }
       return current;
   }

   /**
   * 删除方法，根据数据域来进行删除
   */
   public Node delete(long value) {
       Node current = first;
       while(current.data != value) {
           if(current.next == null) {
               return null;
           }
           current = current.next;
       }

       if(current == first) {
           first = first.next;
       } else {
           current.previous.next = current.next;
       }
       return current;

   }

   /**
   * 判断是否为空
   */
   public boolean isEmpty() {
       return (first == null);
   }
}
public static void main(String[] args) {
       DoubleLinkList dl = new DoubleLinkList();
       dl.insertLast(45);
       dl.insertLast(56);
       dl.insertLast(90);
       dl.display();


       while(!dl.isEmpty()) {
           dl.deleteFirst();
           dl.display();
       }
   }