链表初相识

什么是链表

​ 我们知道数组需要一块连续的内存空间来存储数据,而链表恰恰相反,它并不需要连续的内存空间,它通过"指针"将零散的内存块连接起来使用,通常将内存块称为链表的“结点”.

常见的链表结构

单链表

通常我们将头部称为头结点,把尾部称为尾结点.头结点用来记录链表的基地址,通过它我们可以遍历整个链表,而尾结点没有指向下一结点,而是指向了一个空地址null

既然是存储数据,那就少不了插入和删除操作,与数组不同,链表的插入和删除不需要搬移数据,

插入

删除

从图中可以看出链表的插入和删除操作,只需要改变相邻结点的指针就可以了,相比数组而言,链表不需要搬移数据,因为链表中并非连续存储数据,所以链表无法像数组一样,支持随机访问.如果链表要查找某个数据需要从头结点开始遍历查找,直到找到要查找的数据.

循环链表

循环链表是一种特殊的单链表，尾结点的指针指向首结点的地址

双向链表

从图中可以看出双向链表需要额外的空间来存储前结点的地址,与单链表相比,存储同样的数据双向链表要占用更多的空间,但却的特点的条件下,使用双向链表要比使用单向链表的效率要高些,毕竟吃的多不出力可不行(空间换时间),例如要在指定结点前插入一个数据时,双向链表已经记录了前一个结点的地址,可以直接操作,而单向链表需要重新查询.

常见链表操作

单链表反转

public static Node reverse(Node list) {
    Node curr = list, pre = null;
    while (curr != null) {
      Node next = curr.next;
      curr.next = pre;
      pre = curr;
      curr = next;
    }
    return pre;
  }

链表中环的检测

public static boolean checkCircle(Node list) {
    if (list == null) return false;

    Node fast = list.next;
    Node slow = list;

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

      if (slow == fast) return true;
    }

    return false;
  }

两个有序链表的合并

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode soldier = new ListNode(0); 
        ListNode p = soldier;
        
        while ( l1 != null && l2 != null ){
            if ( l1.val < l2.val ){
                p.next = l1;
                l1 = l1.next;
            }
            else{
                p.next = l2;
                l2 = l2.next;
            }
            p = p.next;
        }
        
        if (l1 != null) { p.next = l1; }
        if (l2 != null) { p.next = l2; }
        return soldier.next;   
    }

删除链表倒数第n个结点

public static Node deleteLastKth(Node list, int k) {
    Node fast = list;
    int i = 1;
    while (fast != null && i < k) {
      fast = fast.next;
      ++i;
    }

    if (fast == null) return list;

    Node slow = list;
    Node prev = null;
    while (fast.next != null) {
      fast = fast.next;
      prev = slow;
      slow = slow.next;
    }

    if (prev == null) {
      list = list.next;
    } else {
      prev.next = prev.next.next;
    }
    return list;
  }

求链表的中间结点

public static Node findMiddleNode(Node list) {
    if (list == null) return null;

    Node fast = list;
    Node slow = list;

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

    return slow;
  }

  public static void printAll(Node list) {
    Node p = list;
    while (p != null) {
      System.out.print(p.data + " ");
      p = p.next;
    }
    System.out.println();
  }

  public static Node createNode(int value) {
    return new Node(value, null);
  }

  public static class Node {
    private int data;
    private Node next;

    public Node(int data, Node next) {
      this.data = data;
      this.next = next;
    }

    public int getData() {
      return data;
    }
  }

链表 PK 数组

通过前面的内容,我们知道了,数组和链表是两种截然不同的内存组织方式,正是因为内存存储的区别,导致了他们的特性截然相反.

数组

优点	缺点
随机访问性强	插入和删除效率低
查找效率高	可能浪费内存
	数组大小固定,不能动态扩展

链表

优点	缺点
插入删除速度快	不能随机查找
内容利用率高	必须从第一个开始遍历，查找效率低
大小没有固定,扩展和灵活

标签：Node,相识,list,fast,next,链表,null
来源： https://www.cnblogs.com/JavaUrl/p/13974025.html