【数据结构】链表的原理及与其相关的常见面试题总结

一：链表原理

    链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。    单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。     上图中最左边的节点即为头结点（Head），但是添加节点的顺序是从右向左的，添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用，所以头节点就可以操作所有节点了。     下图描述了单向链表存储情况。存储是分散的，每一个节点只要记录下一节点，就把所有数据串了起来，形成了一个单向链表。    节点（Node）是由一个需要储存的对象及对下一个节点的引用组成的。也就是说，节点拥有两个成员：储存的对象、对下一个节点的引用。下面图是具体的说明：

二、链表的实现

[html] view plain copy print?
package com.zjn.LinkAndQueue;

/**
* 自定义链表设计
*
* @author zjn
*
*/
public class MyLink {
Node head = null; // 头节点

/**   * 链表中的节点，data代表节点的值，next是指向下一个节点的引用   *    * @author zjn   *   */  class Node {      Node next = null;// 节点的引用，指向下一个节点      int data;// 节点的对象，即内容      public Node(int data) {          this.data = data;      }  }  /**   * 向链表中插入数据   *    * @param d   */  public void addNode(int d) {      Node newNode = new Node(d);// 实例化一个节点      if (head == null) {          head = newNode;          return;      }      Node tmp = head;      while (tmp.next != null) {          tmp = tmp.next;      }      tmp.next = newNode;  }  /**   *    * @param index:删除第index个节点   * @return   */  public boolean deleteNode(int index) {      if (index < 1 || index > length()) {          return false;      }      if (index == 1) {          head = head.next;          return true;      }      int i = 1;      Node preNode = head;      Node curNode = preNode.next;      while (curNode != null) {          if (i == index) {              preNode.next = curNode.next;              return true;          }          preNode = curNode;          curNode = curNode.next;          i++;      }      return false;  }  /**   *    * @return 返回节点长度   */  public int length() {      int length = 0;      Node tmp = head;      while (tmp != null) {          length++;          tmp = tmp.next;      }      return length;  }  /**   * 在不知道头指针的情况下删除指定节点   *    * @param n   * @return   */  public boolean deleteNode11(Node n) {      if (n == null || n.next == null)          return false;      int tmp = n.data;      n.data = n.next.data;      n.next.data = tmp;      n.next = n.next.next;      System.out.println("删除成功！");      return true;  }  public void printList() {      Node tmp = head;      while (tmp != null) {          System.out.println(tmp.data);          tmp = tmp.next;      }  }  public static void main(String[] args) {      MyLink list = new MyLink();      list.addNode(5);      list.addNode(3);      list.addNode(1);      list.addNode(2);      System.out.println("linkLength:" + list.length());      System.out.println("head.data:" + list.head.data);      list.printList();      list.deleteNode(4);      System.out.println("After deleteNode(4):");      list.printList();  }  

}
运行结果如下：

三、链表相关的常见面试题总结

1. 链表反转
   调整指针的指向，反转后链表的头结点是原始链表的尾节点。
   [html] view plain copy print?
   /**

   • 链表反转
   • 
     
     • @param head

   • @return
     */
     public Node ReverseIteratively(Node head) {
     Node pReversedHead = head;
     Node pNode = head;
     Node pPrev = null;
     while (pNode != null) {
     Node pNext = pNode.next;
     if (pNext == null) {
     pReversedHead = pNode;
     }
     pNode.next = pPrev;
     pPrev = pNode;
     pNode = pNext;
     }
     this.head = pReversedHead;
     return this.head;
     }
     运行结果：

     1. 查找单链表的中间节点
        采用快慢指针的方式查找单链表的中间节点，快指针一次走两步，慢指针一次走一步，当快指针走完时，慢指针刚好到达中间节点。
        [html] view plain copy print?
        /**
   • 链表反转
   • 
     
     • @param head
   • @return
     */
     public Node ReverseIteratively(Node head) {
     Node pReversedHead = head;
     Node pNode = head;
     Node pPrev = null;
     while (pNode != null) {
     Node pNext = pNode.next;
     if (pNext == null) {
     pReversedHead = pNode;
     }
     pNode.next = pPrev;
     pPrev = pNode;
     pNode = pNext;
     }
     this.head = pReversedHead;
     return this.head;
     }
     3.查找倒数第k个元素
     采用两个指针P1,P2，P1先前移K步，然后P1、P2同时移动，当p1移动到尾部时，P2所指位置的元素即倒数第k个元素 。
     [html] view plain copy print?
     /**
   • 查找倒数 第k个元素
   • 
     
     • @param head
   • @param k
   • @return
     */
     public Node findElem(Node head, int k) {
     if (k < 1 || k > this.length()) {
     return null;
     }
     Node p1 = head;
     Node p2 = head;
     for (int i = 0; i < k; i++)// 前移k步
     p1 = p1.next;
     while (p1 != null) {
     p1 = p1.next;
     p2 = p2.next;
     }
     return p2;
     }
     
     1. 对链表进行排序
        [html] view plain copy print?
        /**
   • 排序

   • • @return
       */
       public Node orderList() {
       Node nextNode = null;
       int tmp = 0;
       Node curNode = head;
       while (curNode.next != null) {
       nextNode = curNode.next;
       while (nextNode != null) {
       if (curNode.data > nextNode.data) {
       tmp = curNode.data;
       curNode.data = nextNode.data;
       nextNode.data = tmp;
       }
       nextNode = nextNode.next;
       }
       curNode = curNode.next;
       }
       return head;
       }
       运行结果：

       1. 删除链表中的重复节点
          [html] view plain copy print?
          /**
   • 删除重复节点
     */
     public void deleteDuplecate(Node head) {
     Node p = head;
     while (p != null) {
     Node q = p;
     while (q.next != null) {
     if (p.data == q.next.data) {
     q.next = q.next.next;
     } else
     q = q.next;
     }
     p = p.next;
     }

   }

   1. 从尾到头输出单链表，采用递归方式实现
      [html] view plain copy print?
      /**

      • 从尾到头输出单链表，采用递归方式实现
      • 
        
        • @param pListHead
          */
          public void printListReversely(Node pListHead) {
          if (pListHead != null) {
          printListReversely(pListHead.next);
          System.out.println(“printListReversely:” + pListHead.data);
          }
          }

   2. 判断链表是否有环，有环情况下找出环的入口节点
      [html] view plain copy print?
      /**

      • 判断链表是否有环，单向链表有环时，尾节点相同
      • 
        
        • @param head
      • @return
        */
        public boolean IsLoop(Node head) {
        Node fast = head, slow = head;
        if (fast == null) {
        return false;
        }
        while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
        if (fast == slow) {
        System.out.println(“该链表有环”);
        return true;
        }
        }
        return !(fast == null || fast.next == null);
        }

   /**

   • 找出链表环的入口
   • 
     
     • @param head
   • @return
     */
     public Node FindLoopPort(Node head) {
     Node fast = head, slow = head;
     while (fast != null && fast.next != null) {
     slow = slow.next;
     fast = fast.next.next;
     if (slow == fast)
     break;
     }
     if (fast == null || fast.next == null)
     return null;
     slow = head;
     while (slow != fast) {
     slow = slow.next;
     fast = fast.next;
     }
     return slow;
     }