鏈表中第一個公共節點

• 公節點定義：同一個節點在兩個鏈表中，并不是節點值相同
• 題目：輸入兩個節點，找出他們的第一個公共節點，節點定義如需

/*** 鏈表元素節點** @author liaojiamin* @Date:Created in 12:17 2021/3/5*/ public class ListNode implements Comparable<ListNode> {private String key;private Integer value;private ListNode next;private ListNode before;...

• 本文中所有有關鏈表定義以及操作都使用自己實現的鏈表相關方法，如需看詳細實現可裝到對應章節：數據結構與算法–鏈表實現以及應用

• 兩個單向鏈表，特點在于只能同頭開始遍歷，因此最簡單方案，還是雙循環，每次遍歷鏈表A的節點時候，與鏈表B中節點逐個比較，直到找到相同的節點問題

• 這種方法實現簡單，但是時間復雜度是最大的，如果A有m個階段，B有n個階段那么時間復雜度是O(mn)，應該有更好的方案

• 方案二：

  • 單向鏈表有共同節點，因為每個節點都是有一個next指針
  • 因此從共同節點開始，之后的所有節點都是相同的，因此這個兩個鏈表應該是個Y字形狀，如下圖
  • 因為兩個鏈表可能節點個數不同，因此從頭開始遍歷不能直接得到，
  • 那么如果從后開始遍歷，那邊一定就是相同的節點
  • 如果能將鏈表反轉，從后向前遍歷，最后一個相同的節點就是我們需要求解的值，如下圖解

• 從后向前

• 如上圖，第一個想到的方法是反轉鏈表，因為單向鏈表只能從頭開始，反轉后可以從尾部開始遍歷，反轉后出現如下情況：

• 當修改第一個鏈表時候，第二個鏈表其實也被修改了，并且此時已經找不到地兒個鏈表的尾部節點，因此方法是不成了。
• 還有另外方法，我們將鏈表的每個節點存儲到另外一個數組中，然后從數組尾部開始遍歷
• 那么用棧來存儲鏈表節點，此時是最適合的
• 遍歷兩個鏈表，分別存儲兩個棧，stack1， stack2,
• 接著遍歷stack1， stack2， 因為后進先出，因此先處理的必然是相等的，我們只需要找到第一個不相等的節點
• 如下實現，此處對棧的定義以及相關方法的實現都是用的自己對棧的實現方法，可到之前對應章節查看詳細的實現：數據結構與算法–簡單棧實現及其應用

/*** 尋找兩個單向鏈表的第一個公共節點* 公共節點定義：同一個節點在兩個鏈表中，并不是節點值相同** @author liaojiamin* @Date:Created in 15:30 2021/6/15*/ public class FindFirstCommonNode {public static void main(String[] args) {Random random = new Random();Integer number1 = random.nextInt(100);ListNode node1 = new ListNode(number1.toString(), number1);for (int i = 0; i < 3; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node1, newNode);}Integer number2 = random.nextInt(100);ListNode node2 = new ListNode(number2.toString(), number2);for (int i = 0; i < 6; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node2, newNode);}ListNode node3 = new ListNode("x", 3);MyLinkedList.addToTail(node1, node3);MyLinkedList.addToTail(node2, node3);for (int i = 0; i < 3; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node1, newNode);}MyLinkedList.print(node1);System.out.println();MyLinkedList.print(node2);ListNode commonNode = findFirstCommonNodeStack(node1, node2);System.out.println();System.out.println(commonNode.getKey());}/*** 方法一，棧方法，后進先出*/public static ListNode findFirstCommonNodeStack(ListNode node1, ListNode node2) {if (node1 == null || node2 == null) {return null;}if (node1.getNext() == null && node2.getNext() == null) {return node1.equals(node2) ? node1 : null;}MyStack stack1 = new MyStack();ListNode head = node1;while (head != null) {stack1.push(head);head = head.getNext();}MyStack stack2 = new MyStack();head = node2;while (head != null) {stack2.push(head);head = head.getNext();}ListNode commonNode = null;while (!stack1.isEmpty() && !stack2.isEmpty()) {ListNode popStack1 = (ListNode) stack1.pop();ListNode popStack2 = (ListNode) stack2.pop();if (popStack1.equals(popStack2)) {commonNode = popStack1;}}return commonNode;} }

• 利用棧額外存儲了一份節點數據，來找到對應的相同節點，用空間換時間的方法，時間復雜度O(m+n)，空間復雜度O(m+n)

• 方法三

  • 如果題目有更苛刻的要求，不能使用額外空間
  • 在這種情況下，我先想到的是雙指針法，我們在之前的文章：數據結構與算法–代碼魯棒性案例分析中詳細介紹了雙指針法獲取鏈表中倒數第N個數
  • 此處有兩個鏈表自然想到雙指針。
  • 但是分析發現，此時兩個鏈表可能元素個數不同，雙指針同樣也需要O(mn)的時間復雜度
  • 還是受到：數據結構與算法–代碼魯棒性案例分析 中雙指針的啟發，其中A指針先走了n步驟，B指針才開始遍歷，當A指針到尾部，B指針就是倒數第n個數據
  • 此處同樣的思想，我們先查詢A，B鏈表長度，如果A比B長N， 那么讓A指針先走N不，那么A，B指針則在統一起跑線。
  • 此時同時遍歷A，B并且比較對應節點，直到找到相同的第一個節點為止
  • 經如上分析有如下代碼：

/*** 尋找兩個單向鏈表的第一個公共節點* 公共節點定義：同一個節點在兩個鏈表中，并不是節點值相同** @author liaojiamin* @Date:Created in 15:30 2021/6/15*/ public class FindFirstCommonNode {public static void main(String[] args) {Random random = new Random();Integer number1 = random.nextInt(100);ListNode node1 = new ListNode(number1.toString(), number1);for (int i = 0; i < 3; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node1, newNode);}Integer number2 = random.nextInt(100);ListNode node2 = new ListNode(number2.toString(), number2);for (int i = 0; i < 6; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node2, newNode);}ListNode node3 = new ListNode("x", 3);MyLinkedList.addToTail(node1, node3);MyLinkedList.addToTail(node2, node3);for (int i = 0; i < 3; i++) {Integer number = random.nextInt(100);ListNode newNode = new ListNode(number.toString(), number);MyLinkedList.addToTail(node1, newNode);}MyLinkedList.print(node1);System.out.println();MyLinkedList.print(node2);System.out.println();ListNode commonNode2 = findFirstCommonNode(node1, node2);System.out.println(commonNode2.getKey());}/*** 方法二，錯位遍歷* */public static ListNode findFirstCommonNode(ListNode node1, ListNode node2){if (node1 == null || node2 == null) {return null;}if (node1.getNext() == null && node2.getNext() == null) {return node1.equals(node2) ? node1 : null;}Integer countNode1 = 0;ListNode header = node1;while (header != null){countNode1 ++;header = header.getNext();}Integer countNode2 = 0;header = node2;while (header != null){countNode2 ++;header = header.getNext();}Integer prefix = Math.abs(countNode1 - countNode2);ListNode header1 = node1;ListNode header2 = node2;if(countNode1 > countNode2){for (int i =0; i< prefix; i++){if(header1 != null){header1 = header1.getNext();}}}else {for (int i =0; i< prefix; i++){if(header2 != null){header2 = header2.getNext();}}}while (header1 != null && header2 != null){if(header1.equals(header2)){return header1;}header1 = header1.getNext();header2 = header2.getNext();}return null;} }

• 方法三中沒有用到額外的存儲空間，時間復雜度同樣也是O(m+n)，要優于方法二，這是目前想到的最優方案。

上一篇：數據結構與算法–數組中的逆序對
下一篇：數據結構與算法–最小的k個數

總結

以上是生活随笔為你收集整理的数据结构与算法--两个链表中第一个公共节点的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。