leetcode-148-排序链表(java|python)

---

title: leetcode-148-排序链表(java|python)
date: 2019-09-29 20:22:56
categories:

• leetcode
  tags:
• leetcode

---

leetcode-148-排序链表(java|python)

• 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

  示例 1:

  输入: 4->2->1->3
  输出: 1->2->3->4
  示例 2:

  输入: -1->5->3->4->0
  输出: -1->0->3->4->5

  来源：力扣（LeetCode）
  链接：https://leetcode-cn.com/problems/sort-list
  著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 解法一：利用递归，分治算法，不断的切切切达到目的，最后使用两个有序链表的拼接即可

  /**
   * Definition for singly-linked list.
   * public class ListNode {
   *     int val;
   *     ListNode next;
   *     ListNode(int x) { val = x; }
   * }
   */
  class Solution {
    public ListNode sortList(ListNode head){
          if(head==null||head.next==null)
              return head;
          ListNode fast = head.next;//快指针
          ListNode slow = head;//慢指针
          while(fast!=null&&fast.next!=null){
              slow = slow.next;
              fast = fast.next.next;
          }
          ListNode tmp = slow.next;
          slow.next = null;
          ListNode left = sortList(head);
          ListNode right = sortList(tmp);
          ListNode h = new ListNode(0);
          ListNode res = h;
          while (left != null && right != null) {
              if (left.val < right.val) {
                  h.next = left;
                  left = left.next;
              } else {
                  h.next = right;
                  right = right.next;
              }
              h = h.next;
          }
          h.next = left != null ? left : right;
          return res.next;
      }
  }
  

• 解法二：归并排序，对解法一的一个拓展

  /**
   * Definition for singly-linked list.
   * public class ListNode {
   *     int val;
   *     ListNode next;
   *     ListNode(int x) { val = x; }
   * }
   */
  class Solution {
      public ListNode sortList(ListNode head){
          return head == null ? head:mergeSort(head);
      }
      //归并
      private static ListNode mergeSort(ListNode head) {
          if (head.next == null || head==null) {
              return head;
          }
          ListNode s = head;
          ListNode f = head.next; 
          while (f!=null&&f.next!=null) {
              s = s.next;
              f = f.next.next;
          }
          ListNode tmp = s.next;
          s.next=null;
          ListNode left = mergeSort(head);
          ListNode right = mergeSort(tmp);
          return merge(left, right);
      }
      public static ListNode merge(ListNode l, ListNode r) {
          ListNode dummyHead = new ListNode(0);
          ListNode cur = dummyHead;
          while (l != null && r != null) {
              if (l.val <= r.val) {
                  cur.next = l;
                  cur = cur.next;
                  l = l.next;
              } else {
                  cur.next = r;
                  cur = cur.next;
                  r = r.next;
              }
          }
          if (l != null) {
              cur.next = l;
          }
          if (r != null) {
              cur.next = r;
          }
          return dummyHead.next;
      }
  }