剑指offer_by牛客网

2017/9/6

二维数组中的查找 m*n

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。

找是否存在target

我的想法，for循环判断每行首尾，再进行二分

O（m*logn）

public class Solution {
    public boolean Find(int target, int [][] array) {
        if (array == null || array.length == 0 || array[0].length == 0) {
            return false;
        }
        int row = array.length;
        int col = array[0].length;
        for (int i = 0; i < row; i++) {
            int start = 0;
            int end = col - 1;
            if (array[i][0] <= target && array[i][end] >= target) {
               while (start + 1 < end) {
                   int mid = start + (end - start) / 2;
                    if (array[i][mid] == target) {
                        return true;
                    } else if (array[i][mid] > target) {
                        end = mid;
                    } else{
                        start = mid;
                    }
                } 
                if (array[i][start] == target) {
                    return true;
                }
                if (array[i][end] == target) {
                    return true;
                }
            }
            
        }
        return false;
    }
}

 答案：

从左下角（或右上角，进行二分）时间复杂度O（m+n）

public class Solution {
    public boolean Find(int target, int [][] array) {
        if (array == null || array.length == 0 || array[0].length == 0) {
            return false;
        }
        int row = array.length;
        int col = array[0].length;
        int i = 0;
        int j = col - 1;
        while (i < row && j >= 0) {
            if (array[i][j] == target) {
                return true;
            } else if (array[i][j] > target) {
                j--;
            } else {
                i++;
            }
        }
        return false;
    }
}

2017/9/7

从尾到头打印链表。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> result = new ArrayList<>();
        ArrayList<Integer> list = new ArrayList<>();
        if (listNode == null) {
            return result;
        }
        ListNode tmp = listNode;
        while (tmp != null) {
            result.add(tmp.val);
            tmp = tmp.next;
        }
        for (int i = result.size() - 1; i >= 0; i--) {
            list.add(result.get(i));
        } 
        return list;
    }
}

2017/9/21

复杂链表的复制

random指针

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if (pHead == null) {
            return null;
        }
        step1(pHead);
        step2(pHead);
        return step3(pHead);
        
    }
    private void step1(RandomListNode pHead) {
        RandomListNode temp = pHead;
        while (temp != null) {
            RandomListNode cur = new RandomListNode(temp.label);
            cur.next = temp.next;
            cur.random = null;
            temp.next = cur;
            temp = cur.next;
        }
        return;
    }
    private void step2(RandomListNode pHead) {
        RandomListNode old = pHead;
        RandomListNode newtemp = pHead;
        while (old != null) {
            newtemp = old.next;
            if (old.random != null) {
                newtemp.random = old.random.next;
            }
            old = newtemp.next;
        }
    }
    private RandomListNode step3(RandomListNode pHead) {
        RandomListNode newHead = pHead.next;
        RandomListNode oldtemp = pHead;
        RandomListNode newtemp = pHead;
        while (oldtemp.next != null) {
            newtemp = oldtemp.next;
            oldtemp.next = newtemp.next;
            oldtemp = newtemp;
        }
        return newHead;
    }
}

2017/9/22

字符串的排列

import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
       ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0)
           return result;
//        if (str.length() <= 1)
//            return result.add(str);
        char[] zhu = str.toCharArray();
        ArrayList<Character> temp = new ArrayList<>();
        int[] visited = new int[zhu.length];
        for (int i = 0; i < zhu.length; i++) {
            visited[i] = 0;
        }
        Arrays.sort(zhu);
        dfs(zhu, result, temp, visited);
        return result;
        
    }
    private void dfs(char[] zhu, ArrayList<String> result, ArrayList<Character> temp, int[] visited) {
        if (temp.size() == zhu.length) {
            StringBuilder str = new StringBuilder();
            for (Character character : temp) {//
                str.append(character);
            }
            result.add(str.toString());
        }
        for (int i = 0; i < zhu.length; i++){
            if (visited[i] == 0) {
                if (i != 0 && zhu[i] == zhu[i - 1] && visited[i - 1] == 0) {
                    continue;
                }
                temp.add(zhu[i]);
                visited[i] = 1;
                dfs(zhu, result, temp, visited);
                temp.remove(temp.size() - 1);
                visited[i] = 0;
            }
        }
        return;
    }
}