链表的冒泡排序(Java)

链表的冒泡排序：

 * 思路一：
 * 1、交换两个节点的值(建议使用此种交换元素方式，简单易行)
 * 
 * 思路二：
 * 2、交换两个节点的指针

代码：

package com.my.test.datastructure.linkedlist;

/**
 * 链表的冒泡排序
 * 
 * 思路一：
 * 1、交换两个节点的值
 * 
 * 思路二：
 * 2、交换两个节点的指针
 * 
 */
public class BubbleSortLinkedList
{
    static class Node {
        int value;
        Node next;
        Node(int value) {
            this.value = value;
        }
        
        @Override
        public String toString() {
            if (this.next == null) {
                return String.valueOf(this.value);
            }
            return this.value + "->" + this.next.toString();
        }
    }
    /**
     * 交换两个节点的值
     */
    public static Node bubbleSort1(Node head, int len) {
        for (int i = 0; i < len - 1; i++) {
            Node curNode = head;
            for (int j = 0; j < len - 1 - i; j++) {
                if (curNode.value > curNode.next.value) {
                    int temp = curNode.value;
                    curNode.value = curNode.next.value;
                    curNode.next.value = temp;
                }
                curNode = curNode.next;
            }
        }
        
        return head;
    }    

    /**
     * 交换两个节点的指针
     */
    public static Node bubbleSort2(Node head, int len) {
        // 缓存新链表头结点
        Node newHead = head;
        for (int i = 0; i < len - 1; i++) {
            
            // 前一个元素指针
            Node preNode = null;
            
            // 当前处理的元素
            Node curNode = newHead;
            
            for (int j = 0; j < len - 1 - i; j++) {
                
                if (curNode.value > curNode.next.value) {
                    
                    // 1、交换两个节点的引用，此时curNode的指针交换后会前移，只需要更新preNode指向即可
                    
                    // 1.1、缓存下下个节点
                    Node tmpNode = curNode.next.next;
                    
                    curNode.next.next = curNode;
                    
                    // 1.2、前驱节点指向nextNode
                    if (preNode != null) {
                        preNode.next = curNode.next;
                    // 1.3、没有前驱节点证明当前节点为头结点，更新头结点
                    } else {
                        newHead = curNode.next;
                    }
                    
                    // 因为需要把preNode指向原来的下个节点，所以此处赋值preNode，preNode后移
                    preNode = curNode.next;
                    
                    // 1.4、curNode指向下下个节点
                    curNode.next = tmpNode;
                
                // 更新preNode & curNode指针
                } else {
                    preNode = curNode;
                    curNode = curNode.next;
                }
            }
        }
        
        return newHead;
    } 
    
    public static void main(String[] args)
    {
        Node node1 = new Node(5);
        Node node2 = new Node(4);
        Node node3 = new Node(3);
        Node node4 = new Node(2);
        Node node5 = new Node(1);
        Node node6 = new Node(0);
        
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        
        System.out.println("Origin link: " + node1);
        
        // System.out.println("Sorted link: " + bubbleSort1(node1, 6));
        
        System.out.println("Sorted link: " + bubbleSort2(node1, 6));
        
    }

}

更多链表排序

参考：https://www.cnblogs.com/TenosDoIt/p/3666585.html