链表题

class Solution{
	public ListNode removeNthFromEnd(ListNode head,int n){
		if(head==null){
			return head;//判空
		}
		ListNode dumy=new ListNode(0);//创建虚拟头节点
		dummy.next=head;//虚拟头结点指向
		ListNode slow=dummy,fast=dummy;//定义两个指针分别指向虚拟头结点
		//让fast往后走n步，然后让first和slow往后面走，当fast走到最后一个点的时候终止
		for(int i=0;i<n;i++){
			fast=fast.next;
			
		}
		while(fast.next !=null){
			fast=fast.next;
			slow=slow.next;
		}
		
		//再把slow指出来的下一个点删掉
		slow.next=slow.next.next;
		//返回虚拟头结点的下一个点
		return dummy.next;
	}
}

class Solution{
	public void deleteNode(ListNode node){
		node.val=node.next.val;//把当前点伪装成下一个点
		node.next=node.next.next;//再把下一个点删掉
	}
}

class solution{
	public ListNode rotate(ListNode head){
		if(head==null)return null;//判空
		int size=1;
		ListNode fast=head,slow=head;//定义两个结点，分别指向头结点
		while(fast.next!=null){
			size++;
			fast=fast.next;//当下一个点不为空时，fast先走一步
		}
		for(int size-k%size;i>1;i--){
			slow=slow.next;//slow也开始往后走
		}
		fast.next=head;//当上面的for循环结束后，fast指向头节点
		head=slow.next;//头结点指向slow的下一节点
		slow.next=null;//slow.next指向空
	}
}

class Solution{
	public ListNode swapPairs(ListNode head){
		ListNode dummy=new ListNode(0);//建立虚拟结点
		dummy.next=head;//虚拟节点指向头结点
		ListNode start=dummy;//开始节点指向虚拟节点
		while(start.next !=null&& start.next.next !=null){//当开始节点的下两个都不为空时
			ListNode first=start.next;//first先走
			ListNode second=start.next.next;//second走
			start.next=second;
			first.next=second.next;//交互
			second.next=first;//交互
			start.first;
		}
		return dummy.next;
	}
}

class Solution{
	public ListNode reverseList(ListNode head){
		ListNode prev=null;
		while(head !=null){
			ListNode next=head.next;
			head.next=prev;
			prev=head;
			head=next;//a=b,b=c的意思
		}
		return prev;
	}
}

import java.util.PriorityQueue;

/**
 *
 * Sort a linked list in O(n log n) time using constant space complexity.
 * 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。
 *
 */

public class SortList {
    public static class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

    public static void main(String[] args){
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        n4.next = n2;
        n2.next = n1;
        n1.next = n3;
        ListNode head = sortList(n4);
        System.out.print(head.val);
        head = head.next;
        while(head != null){
            System.out.print("," + head.val);
            head = head.next;
        }
        System.out.println("");
    }

    //堆排序
    public static ListNode sortList(ListNode head) {
        PriorityQueue<ListNode> minheap = new PriorityQueue<>((l1, l2) -> Integer.compare(l1.val, l2.val));
        ListNode p = head;
        while(p != null){
            minheap.add(p);
            p = p.next;
        }

        if(!minheap.isEmpty())
            p = minheap.poll();
        ListNode newhead = p;
        while(!minheap.isEmpty()){
            p.next = minheap.poll();
            p = p.next;
            //若不加此句，链表可能会成环并无限运行
            p.next = null;
        }

        return newhead;
    }

    //归并排序：最佳
    public static ListNode sortList1(ListNode head){
        if(head == null || head.next == null)
            return head;

        //快慢指针找中点
        ListNode fast = head.next.next;
        ListNode low = head;
        while(fast != null && fast.next != null){
             fast = fast.next.next;
             low = low.next;
        }

        //递归调用（非常重要：递归排序右半部，后将左右截断）
        ListNode l1 = sortList1(low.next);
        low.next = null;
        ListNode l2 = sortList1(head);

        //归并排序
        ListNode newhead = new ListNode(0);
        fast = newhead;
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                fast.next = l1;
                l1 = l1.next;
            }else{
                fast.next = l2;
                l2 = l2.next;
            }
            fast = fast.next;
        }
        fast.next = l1 == null ? l2 : l1;

        return newhead.next;
    }

    //快速排序
    public static ListNode sortList2(ListNode head){
        return QuickSort(head, null);
    }

    public static ListNode QuickSort(ListNode begin, ListNode end){
        if(begin == end || begin.next == end)
            return begin;

        ListNode head = new ListNode(0);
        ListNode smaller = head;
        ListNode partition = begin;
        ListNode bigger = begin;

        while(begin.next != end){
            if(begin.next.val < partition.val){
                smaller.next = begin.next;
                smaller = smaller.next;
                begin.next = begin.next.next;
            }else{
                begin = begin.next;
            }
        }
        smaller.next = bigger;

        ListNode left = QuickSort(head.next, partition.next);
        ListNode right = QuickSort(partition.next, end);
        head.next = left;
        while(left.next != null)
            left = left.next;
        left = right;

        return head.next;
    }

    //插入排序
    public ListNode insertionSortList(ListNode head) {
        if(head == null){
            return head;
        }
        
        ListNode newhead = new ListNode(0);
        ListNode cur = head;
        ListNode pre = newhead;
        while(cur != null){
            ListNode next = cur.next;
            while(pre.next != null && pre.next.val < cur.val){
                pre = pre.next;
            }
            //将cur插入pre.next
            cur.next = pre.next;
            pre.next = cur;
            pre = newhead;
            cur = next;
        }
        return newhead.next;        
    }
}