BM12 单链表的排序(数组排序法和双指针法)

一.数组排序法

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    public ListNode sortInList (ListNode head) {
        // write code here

        //如果头结点为空，直接返回空
        if (head == null) {
            return null;
        }

        //如果头结点的next域为空，返回头结点就行
        if (head.next == null) {
            return head;
        }

        //创建一个数组用来存放链表的值，用来排序
        ArrayList<Integer> list = new ArrayList<>();

        //定义一个cur指针用来遍历头结点
        ListNode cur = head;

        //将遍历到的值存放到list数组中
        while (cur != null) {
            list.add(cur.val);
            cur = cur.next;
        }

        //调用Collections.sort()方法对数组list进行排序
        Collections.sort(list);

        //创建一个虚拟头结点
        ListNode dummy = new ListNode(-1);

        //最后要返回的是dummy.next
        dummy.next = head;
        
        //遍历整个数组的大小，将链表的值依次替换为排好序的值
        for (int i = 0; i < list.size(); i++) {
            head.val = list.get(i);
            if (head != null) {
                head = head.next;
            }
        }

        return dummy.next;
    }
}

二.双指针法

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    //从区间分割链表，进行排序
    private static ListNode merrage(ListNode pHead1,ListNode pHead2) {

        //pHead1为空，说明第一段链表不存在，返回pHead2
        if (pHead1 == null) {
            return pHead2;
        }
        
        //pHead2为空，说明第一段链表不存在，返回pHead1
        if (pHead2 == null) {
            return pHead1;
        }

        //定义一个虚拟结点node，让cur指向node
        ListNode node = new ListNode(0);
        ListNode cur = node;

        //遍历两个链表
        while (pHead1 != null && pHead2 != null) {

            /*
                如果pHead1.val <= pHead2.val成立，
                让小的结点先插入到cur的位置
             */
            if (pHead1.val <= pHead2.val) {
                cur.next = pHead1;
                pHead1 = pHead1.next;
            }else {
                
                //小的结点插入完成，就剩下大的结点，依次插入到cur的位置
                cur.next = pHead2;
                pHead2 = pHead2.next;
            }
            
            cur = cur.next;
        }

        /*
            pHead1不为空，cur.next连接到pHead1，
            否则连接到pHead2
         */
        if (pHead1 != null) {
            cur.next = pHead1;
        }else {
            cur.next = pHead2;
        }
        
        //最后返回虚拟结点的next指向
        return node.next;
    }

    public ListNode sortInList (ListNode head) {
        // write code here
        //如果head等于空或者head.next为空，返回head头结点
        if (head == null || head.next == null) {
            return head;
        }

        /*
            定义left为第一段链表的尾巴指针，
            mid为第二段链表的头指针，
            right指针用来遍历链表
         */
        ListNode left = head;
        ListNode mid = head.next;
        ListNode right = head.next.next;

        while (right != null && right.next != null) {
            left = left.next;
            mid = mid.next;
            right = right.next.next;
        }

        //将第一段的尾巴节点与第二段的头结点断开
        left.next = null;
        
        //调用merrage排序方法
        return merrage(sortInList(head), sortInList(mid));
    }
}