厚积薄发打卡Day110：链表（九）排序的循环链表

厚积薄发打卡Day110：链表（九）<排序的循环链表>

排序的循环链表

问题：在一个循环链表中节点的值递增排序，请设计一个算法在该循环链表中插入节点，并保证插入节点之后的循环链表仍然是排序的。例如，图4.15（a）所示是一个排序的循环链表，插入一个值为4的节点之后的链表如图4.15（b）所示。

实现

/**
 * 排序的循环链表
 */
public class SortedCycleNodeList {

    public static ListNode insert(ListNode head, int insertVal) {
        ListNode node = new ListNode(insertVal);
        //链表为空
        if (head == null) {
            head = node;
            head.next = head;
        }
        //链表为一个元素
        else if (head.next == head) {
            head.next = node;
            node.next = head;
        } else {
            insertCore(head, node);
        }
        return head;
    }

    private static void insertCore(ListNode head, ListNode node) {
        ListNode cur = head;
        ListNode next = head.next;
        ListNode biggest = head;
        while (!(cur.val <= node.val && next.val >= node.val) && next != head) {
            cur = next;
            next = next.next;
            if (cur.val >= biggest.val) {
                biggest = cur;
            }
        }
        if (cur.val <= node.val && next.val >= node.val) {
            cur.next = node;
            node.next = next;
        } else {
            node.next = biggest.next;
            biggest.next = node;
        }
    }

    public static void main(String[] args) {
        ListNode node1 = new ListNode(1);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(3);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        node1.next = node2;
        node2.next = node3;
        node3.next = node5;
        node5.next = node6;
        node6.next = node1;
        ListNode.printCycleNodeList(node1);
        insert(node1,4);
        ListNode.printCycleNodeList(node1);
    }
}

1->2->3->5->6->[~1->2->3->5->6~]
1->2->3->4->5->6->[~1->2->3->4->5->6~]

补充

1. 在上述代码中函数 insert 中先处理链表是空的或链表中只有一个节点的情况，然后调用函数insertCore处理链表中的节点数超过一个的情况。在函数insertCore中试图找到相邻的两个节点 cur和next，使cur的值小于或等子待插人的值且 next 的值大于或等于特插入的值。如果找到了就将新节点插入它们之间。如果没有找到符合条件的两个节点，就将新的节点插入值最大的节点biggest的后面。

2. 如果用传统的链表打印循环链表那么一定会出现栈溢出的情况，因此新的循环链表打印方法

      /**
        * 打印循环链表方法
        *
        * @param head
        */
       public static void printCycleNodeList(ListNode head) {
           StringBuilder res = new StringBuilder();
           Set<ListNode> set = new HashSet<>();
           ListNode endNode = null;
           while (head != null) {
               res.append(head).append("->");
               set.add(head);
               ListNode cur = head;
               head = head.next;
               if (set.contains(head)) {
                   endNode = cur;
                   break;
               }
           }
           res.append("[~");
           while (head != endNode) {
               res.append(head).append("->");
               head = head.next;
           }
           res.append(endNode).append("~]");
           System.out.println(res);
       }
   }
          }
           res.append(endNode).append("~]");
           System.out.println(res);
       }
   }