剑指offer刷刷题

1、编程实现设计模式：Singleton（单例模式）

public class Singleton{ private Singleton(){} private static Singleton s = new Singleton(); public static Singleton getSingleton() { return s; }}

2、在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 

public class Solution {    // Parameters:    //    numbers:     an array of integers    //    length:      the length of array numbers    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]    // Return value:       true if the input is valid, and there are some duplications in the array number    //                     otherwise false    public boolean duplicate(int numbers[],int length,int [] duplication)     {    if (length == 0 || length == 1)    return false;    for (int i = 0; i < length; i++)    {    if (numbers[i] != i)    {    if (numbers[i] == numbers[numbers[i]])    {    duplication[0] = numbers[i];    return true;    }    int temp = numbers[i];    numbers[i] = numbers[temp];    numbers[temp] = temp;        }        }    return false;    }}

3、在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路：从右上角开始！

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

4、二叉树的下一结点：

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

思路： 

（1）下一节点是它右子树中的最左子节点。

（2）如果没有右子节点，若其节点是它父节点的左子节点，则下一节点就是它的父节点。

（3）若其还是其父节点的右子节点，向上遍历。

/*public class TreeLinkNode {    int val;    TreeLinkNode left = null;    TreeLinkNode right = null;    TreeLinkNode next = null;    TreeLinkNode(int val) {        this.val = val;    }}*/public class Solution {    public TreeLinkNode GetNext(TreeLinkNode pNode)    {        if (pNode == null) return null;        if (pNode.right != null)        {        TreeLinkNode t1 = pNode.right;        while (t1.left != null)        {        t1 = t1.left;        }        return t1;        }        else if (pNode.next != null)        {        TreeLinkNode curr = pNode;        TreeLinkNode parent = pNode.next;        while (parent != null && curr == parent.right)        {        curr = parent;        parent = parent.next;        }        return parent;        }        else         return null;    }}

面试题11：旋转数组的最小数字

思路： 二分查找，比较中间值mid与left的值，若mid > left 说明最小值在后半部分；否则，在前半部分。

import java.util.ArrayList;public class Solution {    public int minNumberInRotateArray(int [] array)     {     if (array.length == 1) return array[0];      int l = 0;     int r = array.length - 1;     while (array[l] >= array[r])     {     if (r - l == 1) return array[r];     int mid = l + (r - l) / 2;     if (array[mid] >= array[l]) l = mid;     else r = mid;     }     return array[l];    }}

面试题12：矩阵中的路径

思路：回溯法，递归。

public class Solution {   public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {    boolean[] visited = new boolean[cols * rows];    for (int i = 0; i < rows * cols; i++)    visited[i] = false;    int Pathlenth = 0;    for (int row = 0; row < rows; row++)    for (int col = 0; col < cols; col++)    {    if (hasPathCore(matrix, rows, cols, str, row, col, Pathlenth, visited))    return true;    }    return false; }private boolean hasPathCore(char[] matrix, int rows, int cols, char[] str, int row, int col, int Pathlenth, boolean[] visited){if (Pathlenth >= str.length) return true;boolean hasPath = false;if (row >=0 && row < rows && col >=0 && col < cols && str[Pathlenth] == matrix[row * cols + col] && visited[row * cols + col] == false){visited[row * cols + col] = true;Pathlenth++;hasPath = hasPathCore(matrix, rows, cols, str, row+1, col, Pathlenth, visited) || hasPathCore(matrix, rows, cols, str, row-1, col, Pathlenth, visited) ||hasPathCore(matrix, rows, cols, str, row, col+1, Pathlenth, visited) ||hasPathCore(matrix, rows, cols, str, row, col-1, Pathlenth, visited);if (!hasPath){visited[row * cols + col] = false;Pathlenth--;}}   return hasPath;}}

面试题13：机器人的运动范围

思路： 回溯法，机器人从（0，0）点开始，某点能到达的方格数为1+ 该点上下左右能到达的方格数

public class Solution { public int movingCount(int threshold, int rows, int cols)    {    boolean[] visited = new boolean[rows * cols];    for (int i = 0; i < rows * cols; i++)    visited[i] = false;    int count = movingCountCore(threshold, rows, cols, 0, 0, visited);    return count;                }    private int movingCountCore(int threshold, int rows, int cols,int row, int col, boolean[] visited)    {    int count = 0;    if (check(threshold, rows, cols, row, col, visited))    {    visited[row * cols + col] = true;    count = 1 + movingCountCore(threshold, rows, cols, row+1, col, visited) +  movingCountCore(threshold, rows, cols, row, col+1, visited)      + movingCountCore(threshold, rows, cols, row-1, col, visited) +  movingCountCore(threshold, rows, cols, row, col-1, visited);    }    return count;    }    private boolean check (int threshold, int rows, int cols,int row, int col, boolean[] visited)    {    if (row >= 0 && row < rows && col >= 0 && col < cols && digitsum(row,col,threshold) && visited[row * cols + col] == false)    return true;    else     return false;    }    private boolean digitsum(int row, int col, int threshold)    {    int sum1 = 0,sum2 = 0;    while (row > 0)    {    sum1 = sum1 + row % 10;    row = row / 10;    }    while (col > 0)    {    sum2 = sum2 + col % 10;    col = col / 10;    }    if (sum1 + sum2 <= threshold) return true;    else return false;        }}

面试题15：二进制中1的个数

思路： 一个数字与其减1得到的数字按位与，会把该整数最右边的1变成0；

public class Solution{    public int NumberOf1(int n)     {    int sum = 0;        while(n != 0)        {        sum++;            n = (n-1) & n;        }        return sum;    }    public static void main(String[]  args)    {    Solution so = new Solution();    System.out.println(so.NumberOf1(5));    }}

面试题18：删除链表中重复的结点

思路：

（1）套用删除重复节点的思路，给定头结点与要删除的结点，将后一个结点的值赋给当前结点，删除后一节点。

第一步：（2）从头遍历链表，如当前结点与后一结点值相同，使用（1）删除后一节点，并记录值

第二步：（3）若当前结点值与记录值相同，删除当前结点（注意当前结点为头结点时的情况），更新当前结点。

第三步：（4）若不同于以上两种情况，更新当前结点。

/* public class ListNode {    int val;    ListNode next = null;    ListNode(int val) {        this.val = val;    }}.*/public class Solution{public ListNode deleteDuplication(ListNode pHead)    {ListNode temp = pHead;ListNode pre = null;if (pHead == null || pHead.next == null) return pHead;int val = 0;boolean del = false;while (temp != null){if (temp.next != null && temp.val == temp.next.val) {val = temp.val;del = true;deletenode(pHead, temp.next);}else if (del && temp.val == val){if (temp == pHead){ pHead = pHead.next; temp = pHead;}else{deletenode(pHead, temp); temp = pre;}}else{pre = temp;temp = temp.next;}}return pHead;    }private void deletenode(ListNode listHead, ListNode toDelete){if (listHead == null || toDelete == null) return;if (toDelete.next != null){toDelete.val = toDelete.next.val;toDelete.next = toDelete.next.next;return;}else{ListNode pNode = listHead;while (pNode.next != toDelete){pNode = pNode.next;}pNode.next = null;return;}}}

面试题19：正则表达式匹配

思路：（1）若模式中下一个字符不是“*”，那么只用比较，然后将pattern,str指针分别后移即可。

（2）若模式下一个字符为“*”，则str当下字符可跟pattern当下字符比较；跟‘*’后字符比较；str下一个字符可跟pattern当下字符比较。

public class Solution {    public boolean match(char[] str, char[] pattern) {  if (str.length == 0 && pattern.length == 0) return true;  if (pattern.length == 0 && str.length != 0) return false;  return isMatch(0, 0, str, pattern); } private boolean isMatch(int i, int j, char[] str, char[] pattern) { if (str.length <= i && pattern.length <= j) return true; if (str.length > i && pattern.length <= j) return false; if (j + 1 < pattern.length &&  pattern[j+1] == '*') { if ((str.length > i && str[i] == pattern[j]) || (pattern[j] == '.' && str.length > i)) { return (isMatch(i + 1, j, str, pattern) || isMatch(i + 1, j + 2, str, pattern) || isMatch(i, j + 2, str, pattern)); } else return isMatch(i, j + 2, str, pattern); } if ((str.length > i && pattern.length > j && str[i] == pattern[j]) || (pattern.length > j && str.length > i && pattern[j] == '.' )) return isMatch(i + 1, j + 1, str, pattern); return false; }}