标签：上下   rgs   内存   结构   oid   双向   script   信息   固定   

链表

链表

一、什么是链表？

1. 和数组一样，链表也是一种线性表。
2. 从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。
3. 链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针next。

二、链表的特点

1. 插入、删除数据效率高，为O(1)级别（只需更改指针指向即可），随机访问效率低O(n)级别（需要从链头至链尾进行遍历）。
2. 和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储后继指针。

三、常用链表：单链表、循环链表和双向链表

单链表

1）每个节点只包含一个指针，即后继指针。
2）单链表有两个特殊的节点，即首节点和尾节点。为什么特殊？用首节点地址表示整条链表，尾节点的后继指针指向空地址null。
3）性能特点：插入和删除节点的时间复杂度为O（1），查找的时间复杂度为O(n)。

循环链表

1）除了尾节点的后继指针指向首节点的地址外均与单链表一致。

2）适用于存储有循环特点的数据，比如约瑟夫问题。

  //约瑟夫环运作如下：
  //1、一群人围在一起坐成环状（如：N）
  //2、从某个编号开始报数（如：K）
  //3、数到某个数（如：M）的时候，此人出列，下一个人重新报数
  //4、一直循环，直到所有人出列[3]  ，约瑟夫环结束
  public class yuesefu 
  {
      static class Node
      {
          int val;
          Node next;
          Node(int v)
          {
              val=v;
          }        
      }
      public static void main(String[] args) {
          int N=9;//表示总个数
          int M=5;//数到几出列
          
          //头节点单列出来，方便形成循环链表
          Node t=new Node(1);
          Node x=t;
          
          //建立单向链表
          for(int i=2;i<=N;i++)
          {
              x=(x.next=new Node(i));
          }    
          
          //最后一个节点的next指向第一个节点，形成循环链表
          x.next=t;
          System.out.println("依次出来的顺序为：");
          while(x!=x.next)
          {
              for(int i=1;i<M;i++)
              {
                  x=x.next;
              }    
              System.out.print(x.next.val+" ");
              x.next=x.next.next;
          }
          System.out.println();
          System.out.println("最后剩余的是： "+x.val);    
      }
  }

双向链表

1）节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个节点地址（后继指针next）。
2）首节点的前驱指针prev和尾节点的后继指针均指向空地址。
3）性能特点：
和单链表相比，存储相同的数据，需要消耗更多的存储空间。
插入、删除操作比单链表效率更高O(1)级别。以删除操作为例，删除操作分为2种情况：给定数据值删除对应节点和给定节点地址删除节点。
对于前一种情况，单链表和双向链表都需要从头到尾进行遍历从而找到对应节点进行删除，时间复杂度为O(n)。
对于第二种情况，要进行删除操作必须找到前驱节点，单链表需要从头到尾进行遍历直到p->next = q，时间复杂度为O(n)，而双向链表可以直接找到前驱节点，时间复杂度为O(1)。
对于一个有序链表，双向链表的按值查询效率要比单链表高一些。因为我们可以记录上次查找的位置p，每一次查询时，根据要查找的值与p的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据。

• 双向循环链表：首节点的前驱指针指向尾节点，尾节点的后继指针指向首节点。

四、链表和哨兵

• 利用哨兵简化实现难度

  首先，我们先回顾一下链表的插入和删除操作。如果我们在节点p后面加入一个新的节点，只需要下面两行代码就能搞定。

  new_node->next = p->next;
  p->next = new_node;

  但是，当我们要想一个空链表插入地一个节点时就不能这样写了。我们需要特殊处理

  if(head==null){
      head = new_node;
  }

  这个时候，我们引入一个不储存数据的空节点，不管链表是不是空的，head都指向它，我们把这种有哨兵节点的链表叫带头链表. 有了哨兵节点我们就能统一实现插入和删除操作而不需要特殊处理了。

• 利用哨兵实现有序链表的合并

  // 有序链表的合并
  /**
  *Definition for singly-linked list
  *public class ListNode{
  *    int val;
  *    ListNode next;
  *    ListNode(int x){ val=x; }
  * }
  */
  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;
  }

  类似的应用有很多不仅限于链表，在归并排序等地方也有应用，等待我们去发掘！

五、选择数组还是链表？

1. 插入、删除和随机访问的时间复杂度
   数组：插入、删除的时间复杂度是O(n)，随机访问的时间复杂度是O(1)。
   链表：插入、删除的时间复杂度是O(1)，随机访问的时间复杂端是O(n)。
2. 数组缺点
   1）若申请内存空间很大，比如100M，但若内存空间没有100M的连续空间时，则会申请失败，尽管内存可用空间超过100M。
   2）大小固定，若存储空间不足，需进行扩容，一旦扩容就要进行数据复制，而这时非常费时的。
3. 链表缺点
   1）内存空间消耗更大，因为需要额外的空间存储指针信息。
   2）对链表进行频繁的插入和删除操作，会导致频繁的内存申请和释放，容易造成内存碎片，如果是Java语言，还可能会造成频繁的GC（自动垃圾回收器）操作。
4. 如何选择？
   数组简单易用，在实现上使用连续的内存空间，可以借助CPU的缓冲机制预读数组中的数据，所以访问效率更高，而链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法预读。
   如果代码对内存的使用非常苛刻，那数组就更适合。

链表一

标签：上下   rgs   内存   结构   oid   双向   script   信息   固定   

原文地址：https://www.cnblogs.com/jiaweixie/p/11307309.html