leetcode insertion-sort-list(Java)

leetcode题目

insertion-sort-list

题目描述

Sort a linked list using insertion sort.

思路

 * 1、两层循环
 * 2、外层循环，从头节点开始，每次访问节点，内部循环找到后面元素的最小值，插入到当前位置
 * 3、内部循环，从当前外层节点的下一个节点开始，比较内外层节点的值，小的放到外层节点位置

代码

package com.my.test.leco;

/**
 * 题目：
 * insertion-sort-list
 * 
 * 题目描述：
 * Sort a linked list using insertion sort.
 *  
 */
public class InsertSortedList
{
    
    static class ListNode {
        int val;
        ListNode next;
        ListNode(int x) {
            val = x;
            next = null;
        }
        @Override
        public String toString() {
            if (this.next == null) {
                return String.valueOf(this.val);
            }
            return this.val + "->" + this.next.toString();
        }
    }
    /**
     * insertionSortList<br>
     * 插入排序<br>
     * 
     * 思路：
     * 1、两层循环
     * 2、外层循环，从头节点开始，每次访问节点，内部循环找到后面元素的最小值，插入到当前位置
     * 3、内部循环，从当前外层节点的下一个节点开始，比较内外层节点的值，小的放到外层节点位置
     */
    public ListNode insertionSortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode curNode = head;
        // 从头节点开始，每次访问节点，内部循环找到后面元素的最小值，插入到当前位置
        while (curNode != null) {
            ListNode temp = curNode.next;
            while (temp != null) {
                // 遍历余下的节点，值比当前节点大，则交换值到当前位置
                if (curNode.val >= temp.val) {
                    swapVal(curNode, temp);
                }
                // 推进内层循环节点
                temp = temp.next;
            }
            // 推进外部循环节点
            curNode = curNode.next;
        }
        return head;
    }

    private void swapVal(ListNode node1, ListNode node2) {
        int temp = node1.val;
        node1.val = node2.val;
        node2.val = temp;
    }
    
    public static void main(String[] args) {
        ListNode head = createTestLinkedList();
        ListNode newHead = new ListNode(13);
        newHead.next = head;
        System.out.println(newHead);
        System.out.println(new InsertSortedList().insertionSortList(newHead));
    }
    
    private static ListNode createTestLinkedList() {
        ListNode head = new ListNode(0);
        ListNode curNode = head;
        for (int i = 1; i < 10; i++) {
            curNode.next = new ListNode(i);
            curNode = curNode.next;
        }
        return head;
    }

}

相关：
链表的冒泡排序
链表的快速排序
双向链表的快速排序
链表的归并排序