码迷,mamicode.com
首页 > 编程语言 > 详细

leetcode链表算法题实现思路

时间:2019-10-29 19:28:30      阅读:84      评论:0      收藏:0      [点我收藏+]

标签:split   dde   添加   非递归   bsp   防止   ext   成交   merge   

找出两个链表的交点(leetcode160

  一条链表遍历完之后跳转到下一条链表的头节点继续遍历。

       因为当两条链表均被遍历一遍以后,第二次遍历时会同时到达节点相等的地方。如果没有相交的节点,两条链表均遍历两遍后,同时等于null,故返回null。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode l1 = headA, l2 = headB;
    while (l1 != l2) {
        l1 = (l1 == null) ? headB : l1.next;
        l2 = (l2 == null) ? headA : l2.next;
    }
    return l1;
}

 

链表反转(leetcode206)

  1、非递归

    新建一个头结点newHeadNode,将新头节点的next赋给旧头节点的next,然后将旧头节点赋给新头节点的next并继续迭代。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newHeadNode = new ListNode(-1);
        while(head != null) {
            ListNode next = head.next;
            head.next = newHeadNode.next;
            newHeadNode.next = head;
            head = next;
        }
        return newHeadNode.next;
    }
}

//更简单的办法

class Solution {
    public ListNode reverseList(ListNode head) {       
    ListNode newHead = null;
      while (head != null) {
         ListNode nextNode = head.next;
         head.next = newHead;
         newHead = head;
         head = nextNode;
      }
      return newHead;
  } 
}
 

  2、递归

    进入递归直到head.next == null,然后回到上一层,此时newHeadNode是最后一个节点,head是倒数第二个节点。将最后一个节点的next指向倒数第二个节点,再将倒数第二个节点的next置空,以防止链表反转后最后一个节点的next不为null。依此类推反复执行head.next.next = head; head.next = null;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode newHeadNode = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHeadNode;
    }
}

 

归并两个有序链表(leetcoed21)

  1、递归

    比较两个链表的值的大小,若l1.val < l2.val则将l2向后迭代,直至l1或l2为null并返回另一个不为null的节点然后开始逐层拼接。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) return l2;
        if(l2 == null) return l1;      
        if(l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        }else{
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

  2、非递归

    创建一个新的链表并将两条链表逐一添加到新链表中。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode newHeadNode = new ListNode(-1);
        ListNode prev = newHeadNode;
        while(l1 != null && l2 != null) {            
            if(l1.val < l2.val) {
                prev.next = l1;
                l1 = l1.next;
            }else{
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }        
        prev.next = l1 == null ? l2 : l1;//添加最后一个节点     
        return newHeadNode.next;
    }
}

 

 删除排序链表中的重复元素(leetcode83)

  1、非递归

    判断当前链表节点的值与后一个链表的值是否相等,若相同,则将后一个节点的next指向当前节点的next。若不同,则向后迭代直至边界。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode current = head;
        while (current != null && current.next != null) {
          if (current.next.val == current.val) {
              current.next = current.next.next;
          } else {
              current = current.next;
          }
      }
      return head;
    }
}

  2、递归

     递归到最后一层开始返回,如果head.val == head.next.val 则一直返回最后一个节点,如果不同则开始拼接。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null)   return head;
        head.next = deleteDuplicates(head.next);
        return head.next.val == head.val ? head.next : head;
    }
}

 

删除链表的倒数第n个节点(leetcode19)

  1、两次循环

    先遍历获取链表长度,再遍历找到节点的前一个位置。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode curr = new ListNode(-1);
        curr.next = head;
        ListNode first = head;
        int length = 0;
        while(first != null) {
            first = first.next;
            length++;
        }
        length -= n;
        first = curr;
        while(length-- > 0) {
            first = first.next;
        }
        first.next = first.next.next;
        return curr.next;
    }
}

   2、一次循环

    创建两个节点一个指向head,一个指向距head节点 n 个节点的节点,即n+1个节点。当第n+1个节点为null时,指向head的节点刚好指向倒数第n个位置。

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode fast = head;
    while (n-- > 0) {
        fast = fast.next;
    }
    if (fast == null) return head.next;
    ListNode slow = head;
    while (fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return head;
}

 

交换链表中的相邻结点(leetcode24)

  1、递归

    递归至尾节点,然后将最后一个节点的next指向head.next,head指向next.next。完成交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}

    2、非递归

    思路如上,从头开始俩俩交换。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode pre = new ListNode(0);
        pre.next = head;
        ListNode temp = pre;
        while(temp.next != null && temp.next.next != null) {
            ListNode start = temp.next;
            ListNode end = temp.next.next;
            temp.next = end;
            start.next = end.next;
            end.next = start;
            temp = start;
        }
        return pre.next;
    }
}

 

两数相加 II(leetcode445) 

  双栈法。即利用两个栈进行运算并拼接链表。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> stack1 = buildStack(l1);
        Stack<Integer> stack2 = buildStack(l2);
        ListNode head = new ListNode(-1);
        int carry = 0;
        while (!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
            int x = stack1.isEmpty() ? 0 : stack1.pop();
            int y = stack2.isEmpty() ? 0 : stack2.pop();
            int sum = x + y + carry;
            ListNode node = new ListNode(sum % 10);
            node.next = head.next;
            head.next = node;
            carry = sum / 10;
        }
        return head.next;
    }
    
    private Stack<Integer> buildStack(ListNode l) {
        Stack<Integer> stack = new Stack<>();
        while (l != null) {
            stack.push(l.val);
            l = l.next;
        }
        return stack;
    }
}

 

回文链表(leetcode)

  找到中间点,分割,反转,比较。  

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) return true;
    ListNode slow = head, fast = head.next;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    if (fast != null) slow = slow.next;  // 偶数节点,让 slow 指向下一个节点
    cut(head, slow);                     // 切成两个链表
    return isEqual(head, reverse(slow));
}

private void cut(ListNode head, ListNode cutNode) {
    while (head.next != cutNode) {
        head = head.next;
    }
    head.next = null;
}

private ListNode reverse(ListNode head) {
    ListNode newHead = null;
    while (head != null) {
        ListNode nextNode = head.next;
        head.next = newHead;
        newHead = head;
        head = nextNode;
    }
    return newHead;
}

private boolean isEqual(ListNode l1, ListNode l2) {
    while (l1 != null && l2 != null) {
        if (l1.val != l2.val) return false;
        l1 = l1.next;
        l2 = l2.next;
    }
    return true;
}

 

 分割链表(leetcode725)

  先遍历确定链表的长度,然后和k值进行运算比较确定每个分割链表的大小,最后进行遍历填充。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode[] splitListToParts(ListNode root, int k) {
        int N = 0;
        ListNode cur = root;
        while (cur != null) {
            N++;
            cur = cur.next;
        }
        int mod = N % k;
        int size = N / k;
        ListNode[] ret = new ListNode[k];
        cur = root;
        for (int i = 0; cur != null && i < k; i++) {
            ret[i] = cur;
            int curSize = size + (mod-- > 0 ? 1 : 0);
            for (int j = 0; j < curSize - 1; j++) {
                cur = cur.next;
            }
            ListNode next = cur.next;
            cur.next = null;
            cur = next;
        }
        return ret;
    }
}

 

奇偶链表(leetcode328)

  新建一个奇数位置的迭代指针odd和一个偶数位置迭代指针even,然后第一个.next = 第三个;第二个.next = 第四个;并向后迭代最后把偶数头部指向奇数末尾odd。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head == null) {
            return head;
        }
        ListNode odd = head, even = head.next, evenHead = even;
        while(even != null && even.next != null) {
            odd.next = odd.next.next;
            odd = odd.next;
            even.next = even.next.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}

 

 

leetcode链表算法题实现思路

标签:split   dde   添加   非递归   bsp   防止   ext   成交   merge   

原文地址:https://www.cnblogs.com/yrtx/p/11524008.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!