LeetCode(三)

最长不重复子串

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s==null || s.length()==0){return 0;}
        int len = s.length(),maxLen=0,slow=0,fast=0;
        HashMap<Character,Integer>  map = new HashMap<Character,Integer>();
        for(;fast<len;fast++){
            char currentChar = s.charAt(fast);
            if(map.get(currentChar) == null){
                map.put(currentChar,fast);
                maxLen = Integer.max(maxLen,fast-slow + 1);
            }else{
                int lastPosition = map.get(currentChar);
                if(lastPosition < slow){
                    maxLen = Integer.max(maxLen,fast - slow + 1);
                    map.put(currentChar,fast);
                }else{
                    slow = lastPosition + 1;
                    map.put(currentChar,fast);
                }
            }
        }
        return maxLen;
    }
}

String to Integer

public class Solution {
    public int myAtoi(String str) {
        int p = 0, ret = 0;
        if(p == str.length()) return 0;
        while(Character.isWhitespace(str.charAt(p)) && p<str.length()) p++;
        boolean isNeg = (str.charAt(p) == '-') ? true : false;
        if(str.charAt(p) == '+' || str.charAt(p) == '-') p++;
        for(;p<str.length();p++){
            if(str.charAt(p)>'9' || str.charAt(p)<'0'){
                break;
            }else{
                int digit = str.charAt(p) - '0';
                if(!isNeg  && ret > (Integer.MAX_VALUE - digit)/10) return Integer.MAX_VALUE;
                else if(isNeg && ret < (Integer.MIN_VALUE + digit)/10) return Integer.MIN_VALUE;
                ret = ret * 10 + (isNeg ? -digit : digit);
            }
        }
        return ret;
    }
}

Reverse LinkedList

public class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null) return head;

        ListNode newhead = new ListNode(0);
        newhead.next = head;

        while(head.next!=null) {
            ListNode tmp = head.next;
            head.next = head.next.next;

            tmp.next = newhead.next;
            newhead.next = tmp;
        }
        return newhead.next;
    }
}

Reverse LinkedList II

public class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if(head == null) return null;
        ListNode dummy = new ListNode(0); // create a dummy node to mark the head of this list
        dummy.next = head;
        ListNode pre = dummy; // make a pointer pre as a marker for the node before reversing
        for(int i = 0; i<m-1; i++) pre = pre.next;
        ListNode start = pre.next; // a pointer to the beginning of a sub-list that will be reversed
        ListNode then = start.next; // a pointer to a node that will be reversed
        // 1 - 2 -3 - 4 - 5 ; m=2; n =4 ---> pre = 1, start = 2, then = 3
        // dummy-> 1 -> 2 -> 3 -> 4 -> 5
        for(int i=0; i<n-m; i++)
        {
            start.next = then.next;
            then.next = pre.next;
            pre.next = then;
            then = start.next;
        }
        // first reversing : dummy->1 - 3 - 2 - 4 - 5; pre = 1, start = 2, then = 4
        // second reversing: dummy->1 - 4 - 3 - 2 - 5; pre = 1, start = 2, then = 5 (finish)
        return dummy.next;
    }
}

Reverse Nodes in K-Group

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode begin;
        if (head==null || head.next ==null || k==1)
            return head;
        ListNode dummyhead = new ListNode(-1);
        dummyhead.next = head;
        begin = dummyhead;
        int i=0;
        while (head != null){
            i++;
            if (i%k == 0){
                begin = reverse(begin, head.next);
                head = begin.next;
            } else {
                head = head.next;
            }
        }
        return dummyhead.next;
    }
    public ListNode reverse(ListNode begin, ListNode end){
        ListNode curr = begin.next;
        ListNode next, first;
        ListNode prev = begin;
        first = curr;
        while (curr!=end){
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        begin.next = prev;
        first.next = curr;
        return first;
    }
}

Linked List Cycle

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode p = head,pre = head;
        while(p != null && p.next != null){
            if (p.next == head) return true;
            p = p.next;
            pre.next = head;
            pre = p;
        }
        return false;
    }
}

Linked List Cycle II

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast!=null && fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                ListNode slow2 = head; 
                while (slow2 != slow){
                    slow = slow.next;
                    slow2 = slow2.next;
                }
                return slow;
            }
        }
        return null;
    }
}

Sort List

public class Solution {
    ArrayList<Integer> theArray=new ArrayList<Integer>();
    public ListNode sortList(ListNode head) {
        if(head==null)return head;

        ListNode focusNode=head;
        while(focusNode!=null)
        {
            theArray.add(focusNode.val);
            focusNode=focusNode.next;
        }

        quickSort(0,theArray.size()-1);

        focusNode=head;
        for(int i=0;focusNode!=null;i++)
        {
            focusNode.val=theArray.get(i);
            focusNode=focusNode.next;
        }

        return head;
    }

    public void quickSort(int left,int right)
    {
        if(right-left<=0)
            return;
        else {
            int pivot=theArray.get(right);

            int partition=partioning(left, right, pivot);
            quickSort(left, partition-1);
            quickSort(partition+1, right);
        }
    }
    public int partioning(int left,int right,long pivot)
    {
        int leftptr=left-1;
        int rightptr=right;
        while(true)
        {
            while(theArray.get(++leftptr)<pivot)
                ;
            while(rightptr>0 &&theArray.get(--rightptr)>pivot)
                ;
            if(leftptr>=rightptr)
                break;
            else {
                swap(leftptr,rightptr);
            }

        }
        swap(leftptr,right);
        return leftptr;
    }
    public void swap(int indx1,int indx2)
    {
        int temp=theArray.get(indx1);
        theArray.set(indx1, theArray.get(indx2));
        theArray.set(indx2, temp);
    }
}

Reorder List

public class Solution {
    public void reorderList(ListNode head) {
        if(head==null||head.next==null) return;

        //Find the middle of the list
        ListNode p1=head;
        ListNode p2=head;
        while(p2.next!=null&&p2.next.next!=null){ 
            p1=p1.next;
            p2=p2.next.next;
        }

        //Reverse the half after middle  1->2->3->4->5->6 to 1->2->3->6->5->4
        ListNode preMiddle=p1;
        ListNode preCurrent=p1.next;
        while(preCurrent.next!=null){
            ListNode current=preCurrent.next;
            preCurrent.next=current.next;
            current.next=preMiddle.next;
            preMiddle.next=current;
        }

        //Start reorder one by one  1->2->3->6->5->4 to 1->6->2->5->3->4
        p1=head;
        p2=preMiddle.next;
        while(p1!=preMiddle){
            preMiddle.next=p2.next;
            p2.next=p1.next;
            p1.next=p2;
            p1=p2.next;
            p2=preMiddle.next;
        }
    }
}

Copy List with Random Pointer

public class Solution {
    public RandomListNode copyRandomList(RandomListNode head) {
        if(head==null){
            return null;
        }
        RandomListNode n = head;
        while (n!=null){
            RandomListNode n2 = new RandomListNode(n.label);
            RandomListNode tmp = n.next;
            n.next = n2;
            n2.next = tmp;
            n = tmp;
        }

        n=head;
        while(n != null){
            RandomListNode n2 = n.next;
            if(n.random != null)
                n2.random = n.random.next;
            else
                n2.random = null;
            n = n.next.next;
        }

        //detach list
        RandomListNode n2 = head.next;
        n = head;
        RandomListNode head2 = head.next;
        while(n2 != null && n != null){
            n.next = n.next.next;
            if (n2.next == null){
                break;
            }
            n2.next = n2.next.next;

            n2 = n2.next;
            n = n.next;
        }
        return head2;

    }
}

​