LinkedList小练习及相关算法

/**
 * Created by chump on 2017/7/6.
 */

import java.lang.reflect.WildcardType;
import java.nio.file.NotLinkException;
import java.util.Stack;

/**
 * Created with IntelliJ IDEA
 * Created By chump
 * Date: 2017/7/6
 * Time: 8:33
 */
public class LinkedList {
    //求链表长度
    public int Length(ListNode head) {
        int length = 0;
        ListNode currentNode = head;
        while (currentNode != null) {
            currentNode = currentNode.getNext();
            length++;
        }
        return length;
    }

    //链表中插入节点
    public ListNode InsertInLinkedList(ListNode head, ListNode nodeToInsert, int position) {
        if (head == null)                 //如果链表为空，则直接插入
            return nodeToInsert;
        int size = Length(head);
        if (position < 1 || position > size + 1) {
            System.out.println("插入位置不合理，有效插入位置为:1-" + size + 1);
            return head;
        }

        if (position == 1) {               //在链表头插入
            nodeToInsert.setNext(head);
            return nodeToInsert;
        } else {                         //在链表中间或末尾插入
            int index = 0;
            ListNode preNode = head;
            while (index < position) {
                preNode = preNode.getNext();
                index++;
            }
            ListNode currentNode = preNode.getNext();
            nodeToInsert.setNext(currentNode);
            preNode.setNext(nodeToInsert);
        }
        return head;

    }

    //删除链表中的节点
    public ListNode DeleteNode(ListNode head, int position) {
        if (head == null) {
            System.out.println("链表为空！");
            return null;
        }
        int size = Length(head);
        if (position < 1 || position > size + 1) {
            System.out.println("删除位置不合理，有效删除位置为1-" + size + 1);
            return head;
        }
        if (position == 1) {                            //删除链表的头节点
            ListNode currentNode = head.getNext();
            head = null;
            return currentNode;
        } else {                                     //删除中间节点或尾节点
            int index = 1;
            ListNode previousNode = head;
            while (index < position) {
                previousNode = previousNode.getNext();
                index++;
            }
            ListNode currentNode = previousNode.getNext();
            previousNode.setNext(currentNode.getNext());
            currentNode = null;
        }
        return head;
    }

    //删除整个单向链表
    public void DeleteLinkedList(ListNode head) {
        ListNode auxilaryNode, currentNode = head;         //auxiliary 辅助节点
        while (currentNode != null) {
            auxilaryNode = currentNode.getNext();
            currentNode = null;
            currentNode = auxilaryNode;
        }
    }
    //判断单向链表是否有环（Floyd算法，双指针思想）
    public boolean IsLinkedListHasLoop(ListNode head) {
        if (head == null)
            return false ;
        ListNode sloPtr = head, fasPtr = head;
        while (sloPtr.getNext() != null && fasPtr.getNext().getNext() != null) {
            sloPtr = sloPtr.getNext();              //初始节点相同，需要先走再判定
            fasPtr = fasPtr.getNext().getNext();
            if (sloPtr == fasPtr)
                return true;
        }
        return false;
    }
    //找到含有环的链表中的起始节点(IsLinkedListHasLoop(head))为true
    public ListNode FindFirstLoopNode(ListNode head){
        ListNode sloPtr = head ,fasPtr = head ;

        while (sloPtr.getNext()!=null&&fasPtr.getNext().getNext()!=null){
            sloPtr = sloPtr.getNext();
            fasPtr = fasPtr.getNext().getNext();
            if (sloPtr==fasPtr)
                break;
        }
        fasPtr = head ;
        //由两指针移动方式可知，慢指针位于快指针和链表表头位置的中点，
        //分别从慢指针位置和表头开始移动，可知一旦进入环，它们就会相遇
        while (fasPtr!=sloPtr){
            fasPtr = fasPtr.getNext();
            sloPtr = sloPtr.getNext();
        }
        return fasPtr ;
    }
    //逆置单向链表
    public ListNode ReverseLinkedList(ListNode head){
        if (head == null)
            return head ;
        ListNode temp = null ,nextNode = null ;
        while (head!=null){
            nextNode = head.getNext() ;
            head.setNext(temp);
            temp = head ;
            head = nextNode ;
        }
        return temp ;
    }
    //从表尾输出链表 (递归遍历到表尾，返回时输出元素)
    public void PrintFromEnd(ListNode head){
        if (head == null)
            return;
        PrintFromEnd(head.getNext());
        System.out.println(head.getData());
    }
    //求两个单向链表的合并点
    public ListNode FindMergeNode(ListNode head1,ListNode head2){
        Stack stack1 = new Stack();
        Stack stack2 = new Stack();
        if ((head1 == null) && (head2 == null))
            return null ;
        ListNode listNode1 = head1 ;
        ListNode listNode2 = head2 ;
        while (listNode1!=null){
            stack1.push(listNode1);
            listNode1 = listNode1.getNext();
        }
        while (listNode2!=null){
            stack2.push(listNode2);
            listNode2 = listNode2.getNext();
        }
        ListNode temp = null ;
        while (stack1.peek() == stack2.peek()){
            temp = (ListNode) stack1.pop();
            stack2.pop();
        }
        return temp ;
    }
    //逐对逆置链表    （递归）
    public ListNode ReversePairRecursive(ListNode head){
        ListNode temp ;
        if (head == null||head.getNext()==null)
            return head ;
        else {
             temp = head.getNext();
             head.setNext(temp.getNext());
             temp.setNext(head);
             head = temp ;
             ReverseLinkedList(head.getNext().getNext());
             return  head ;
        }
    }
    //逐对逆置链表 （迭代）
    public ListNode ReversePairIterative(ListNode head){
        ListNode temp1 = null ;
        ListNode temp2 = null ;
        while (head!=null&&head.getNext()!=null){
            temp1 = head ;
            temp2 = head.getNext();
            temp2.setNext(temp1);
            temp1.setNext(temp2.getNext());
            head = head.getNext().getNext();
        }
        return head ;
    }
    //约瑟夫环问题       循环链表问题
    /*
        N个人想选出一个领头人，它们排成一个环，沿着环每数到第M个人就从环中排除该人，
        并从下一个人开始重新数。找出最后一个留在环中的人。
     */
    public void GetJosephusPosition(int n,int skip){
        ListNode p = new ListNode() ,q  ;
        p.setData(1);
        q = p ;
        //建立循环链表
        for (int i = 2 ;i<= n ;i++){
            ListNode temp = new ListNode(i);
            p.setNext(temp);
            p = temp ;
        }
        p.setNext(q);  //使表尾节点指向表头

        //如果链表长度大于1，剔除第skip个元素
        for (int count = n;count>1;count--){
            for (int i = 0 ;i<skip-1;i++){
                p = p.getNext() ;
            }
            p.setNext(p.getNext().getNext());       //删除剔除的元素
        }
        System.out.println("The Least one :"+p.getData());

    }

}