首页 > 其他分享> 文章详细

链表初相识

2020-11-15 09:31:29 阅读：204 来源： 互联网

标签：Node 相识 list fast next 链表 null

什么是链表

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

常见的链表结构

单链表

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9