剑指offer题解
数组中重复的数字
题目描述：在一个长度为n的数组里面的所有数字都在0~n-1的范围内。数组中某些数字是重复的，但是不知道有几个数字重复了，也不知道每个数字重复了几次，请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是重复的数字2或者3.
解题思路：
1.先把输入的数组排序，从排序的数组中找出重复的数字是一件很容易的事，只需从头到尾扫描排序后的数组就可以了。排序一个长度为n的数组需要O(nlogn)的时间。
2.可以利用哈希表来解决，从头到尾按顺序扫描数组的每个数字，每扫描到一个数字的时候，都可以用O(1)的时间判断哈希表里面是否已经包含了该数字。如果哈希表里面还没有这个数字，就把他加入哈希表，如果已经存在了该数字，就找到一个重复的数字，算法的时间复杂度是O(n)，空间复杂度为O(n)，
3.假设重排这个数组，如果数组中没有重复的数字，那么当数组排序后，数字i将出现在下标为i的位置。由于数组中有重复的数字，那有些位置可能存在多个数字，有些位置可能没有数字。
现在重排这个数组，从头打到尾依次扫描这个数组中的每个数字。当扫描到下标为i的数字时，首先比较这个数字m是不是等于i，如果是，则接着扫描下一个数字；如果不是，那么拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字；如果它和第m个数字不相等，就把第i个数字和第m个数字交换，把m放在属于它的位置，接下来重复这个比较交换的过程，直到发现第一个重复数字。
以 (2, 3, 1, 0, 2, 5) 为例：
position-0 : (2,3,1,0,2,5) // 2 <-> 1
(1,3,2,0,2,5) // 1 <-> 3
(3,1,2,0,2,5) // 3 <-> 0
(0,1,2,3,2,5) // already in position
position-1 : (0,1,2,3,2,5) // already in position
position-2 : (0,1,2,3,2,5) // already in position
position-3 : (0,1,2,3,2,5) // already in position
position-4 : (0,1,2,3,2,5) // nums[i] == nums[nums[i]], exit
遍历到位置 4 时，该位置上的数为 2，但是第 2 个位置上已经有一个 2 的值了，因此可以知道 2 重复。
例题：
题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
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 (numbers == null || numbers.length == 0) { return false; } for (int i = 0; i < length; i++) { while (numbers[i] != i) { if (numbers[i] == numbers[numbers[i]]) { duplication[0] = numbers[i]; return true; } swap(numbers, i, numbers[i]); } } return false; } public void swap(int[] numbers, int i, int j) { int temp = numbers[i]; numbers[i] = numbers[j]; numbers[j] = temp; } }
-----------------------------------------------------------------------
不修改数组找出重复的数字
题目描述：在一个长度为n+1的数组里面的所有数字都在1~n的范围内，所以数组中至少有一个数字是重复的，请找出数组当中任意一个重复的数字，但不能修改输入的数组。例如输入长度为8的数组{2,3,5,4,3,2,6,7}，那么对应的输出是重复的数字2或者3。
解题思路：
1.可以创建一个长度为n+1上午辅助数组，然后逐一把原数组的每个数字复制到辅助数组。如果原数组中被复制的数字是m，则把它复制到辅助数组中下标为m的位置，这样很容易就能发现哪个数字是重复的，这样需要O(n)的辅助空间。
2.可以把1~n的数字从中间的数字m分为两部分，前面一半为1~m，后面一半为m+1~n。如果1~m的数字的数目超过m,那么这一版的区间里面一定包含重复数字，否则另一半区间里面肯定包含重复数字。我们可以继续吧包含重复数字的区间一分为二，直到找到一个重复的数字，类似二分法。
例题:
633. 寻找重复的数 给出一个数组 nums 包含 n + 1 个整数，每个整数是从 1 到 n (包括边界)，保证至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。 样例 给出 nums = [5,5,4,3,2,1]，返回 5. 给出 nums = [5,4,4,3,2,1]，返回 4. 注意事项 1.不能修改数组(假设数组只能读) 2.只能用额外的O(1)的空间 3.时间复杂度小于O(n^2) 4.数组中只有一个重复的数，但可能重复超过一次
解法：
public class Solution { /** * @param nums: an array containing n + 1 integers which is between 1 and n * @return: the duplicate one */ public int findDuplicate(int[] nums) { // write your code here if (nums == null || nums.length == 0) { return -1; } int start = 1; int end = nums.length - 1; while (end >= start) { int mid = ((end - start) >> 1) + start; int count = countRange(nums, start, mid); if (end == start) { if (count > 1) { return start; } else { break; } } //前半部分数字在数组中出现的次数大于前半部分数字的个数 if (count > (mid - start + 1)) { end = mid; } else { start = mid + 1; } } return -1; } /** * 统计nums数组中某个范围当中的数字出现的次数 **/ public int countRange(int[] nums, int start, int end) { if (nums == null || nums.length == 0) { return 0; } int count = 0; for (int i = 0; i < nums.length; i++) { if (nums[i] >= start && nums[i] <= end) { count++; } } return count; } }
-------------------------------------------------------------------------------------
二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
Consider the following matrix: [ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30] ] Given target = 5, return true. Given target = 20, return false.
public class Solution { /** * 从左下角开始查找,复杂度：O(M + N) + O(1) **/ public boolean Find(int target, int [][] array) { if (array == null || array.length == 0 || array[0] == null || array[0].length == 0) { return false; } int row = array.length; int col = array[0].length; int i = row - 1; int j = 0; while (i >= 0 && j < col) { if (target == array[i][j]) { return true; } else if (target > array[i][j]) { j++; } else { i--; } } return false; } }
-------------------------------------------
替换空格
题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路 在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。 令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。 从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。
public class Solution { public String replaceSpace(StringBuffer str) { int oldLen = str.length() - 1; for (int i = 0; i < oldLen + 1; i++) { if (str.charAt(i) == ' ') { str.append(" "); } } int newLen = str.length() - 1; while (oldLen >= 0 && newLen > oldLen) { char temp = str.charAt(oldLen--); if (temp == ' ') { str.setCharAt(newLen--, '0'); str.setCharAt(newLen--, '2'); str.setCharAt(newLen--, '%'); } else { str.setCharAt(newLen--, temp); } } return str.toString(); } }
--------------------------------------------------------------------
从头到尾打印链表
题目描述
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
/** * public class ListNode { * int val; * ListNode next = null; * * ListNode(int val) { * this.val = val; * } * } * */ import java.util.ArrayList; import java.util.Stack; public class Solution { //使用栈 public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { Stack<Integer> stack = new Stack<>(); while (listNode != null) { stack.push(listNode.val); listNode = listNode.next; } ArrayList<Integer> res = new ArrayList<>(); while (!stack.isEmpty()) { res.add(stack.pop()); } return res; } }
-----------------------------------------------------------------------------------------
重建二叉树
根据前序遍历和中序遍历重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路
前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
递归的调用，实现功能。
/** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ import java.util.Map; import java.util.HashMap; public class Solution { public TreeNode reConstructBinaryTree(int [] pre,int [] in) { Map<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < in.length; i++) { map.put(in[i], i); } TreeNode root = helper(pre, 0, pre.length - 1, in, 0, in.length - 1, map); return root; } public TreeNode helper(int[] pre, int preStart, int preEnd, int[] in, int inStart, int inEnd, Map<Integer, Integer> inMap) { if (preStart > preEnd || inStart > inEnd) { return null; } TreeNode root = new TreeNode(pre[preStart]); int index = inMap.get(root.val); int leftNums = index - inStart; root.left = helper(pre, preStart + 1, preStart + leftNums, in, inStart, index - 1, inMap); root.right = helper(pre, preStart + leftNums + 1, preEnd, in, index + 1, inEnd, inMap); return root; } }
根据后序遍历和中序遍历重建二叉树
106. Construct Binary Tree from Inorder and Postorder Traversal
Given inorder and postorder traversal of a tree, construct the binary tree. Note: You may assume that duplicates do not exist in the tree. For example, given inorder = [9,3,15,20,7] postorder = [9,15,7,20,3] Return the following binary tree: 3 / \ 9 20 / \ 15 7
解题思路
后序遍历的最后一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
递归的调用，实现功能。
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public TreeNode buildTree(int[] inorder, int[] postorder) { if (inorder == null || postorder == null || inorder.length != postorder.length) { return null; } Map<Integer, Integer> map = new HashMap<>(); for (int i = 0; i < inorder.length; i++) { map.put(inorder[i], i); } TreeNode root = helper(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1, map); return root; } public TreeNode helper(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd, Map<Integer, Integer> map) { if (inStart > inEnd || postStart > postEnd) { return null; } TreeNode root = new TreeNode(postorder[postEnd]); int index = map.get(root.val); int leftNums = index - inStart; root.left = helper(inorder, inStart, index - 1, postorder, postStart, postStart + leftNums - 1, map); root.right = helper(inorder, index + 1, inEnd, postorder, postStart + leftNums, postEnd - 1, map); return root; } }
----------------------------------------------------------------
二叉树的下一个节点
题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
解题思路
① 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
② 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
/* 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 node = pNode.right; while (node.left != null) { node = node.left; } return node; } else { while (pNode.next != null) { TreeLinkNode p = pNode.next; if (p.left == pNode) { return p; } pNode = pNode.next; } } return null; } }
----------------------------------------------------------------------------------------------------------
两个栈实现队列
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路：
声明两个栈，stack1,stack2
进入队列的时候，都push到stack1中
从队列中出去的时候，从stack2中pop，如果stack2为空，
那么将stack1中的元素pop后压入stack2中，如果stack2还是为空，
那么抛出异常。
import java.util.Stack; public class Solution { Stack<Integer> stack1 = new Stack<Integer>(); Stack<Integer> stack2 = new Stack<Integer>(); public void push(int node) { stack1.push(node); } public int pop() throws Exception{ if (stack2.isEmpty()) { while (!stack1.isEmpty()) { stack2.push(stack1.pop()); } } if (stack2.isEmpty()) { throw new Exception("queue is empty"); } return stack2.pop(); } }
-----------------------------------------------------------------------------
两个队列实现栈
import java.util.ArrayDeque; import java.util.Queue; public class Demo08 { Queue<Integer> queue1 = new ArrayDeque<>(); Queue<Integer> queue2 = new ArrayDeque<>(); public void push(int node) { //两个栈都为空时，优先考虑queue1 if (queue1.isEmpty()&&queue2.isEmpty()) { queue1.add(node); return; } //如果queue1为空，queue2有元素，直接放入queue2 if (queue1.isEmpty()) { queue2.add(node); return; } if (queue2.isEmpty()) { queue1.add(node); return; } } public int pop() { //两个栈都为空时，没有元素可以弹出 if (queue1.isEmpty()&&queue2.isEmpty()) { try { throw new Exception("stack is empty"); } catch (Exception e) { } } //如果queue1为空，queue2有元素， 将queue2的元素依次放入queue1中，直到最后一个元素，我们弹出。 if (queue1.isEmpty()) { while (queue2.size()>1) { queue1.add(queue2.poll()); } return queue2.poll(); } if (queue2.isEmpty()) { while (queue1.size()>1) { queue2.add(queue1.poll()); } return queue1.poll(); } return (Integer) null; } public static void main(String[] args) { Demo08 demo08 = new Demo08(); demo08.push(1); demo08.push(2); demo08.push(3); demo08.push(4); System.out.println(demo08.pop()); System.out.println(demo08.pop()); demo08.push(5); System.out.println(demo08.pop()); System.out.println(demo08.pop()); System.out.println(demo08.pop()); } }
-----------------------------------------------------------------------------------
菲波那切数列
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
递归解法：
public class Solution { public int Fibonacci(int n) { if (n <= 1) { return n; } int[] f = new int[n + 1]; f[1] = 1; for (int i = 2; i <= n; i++) { f[i] = f[i - 1] + f[i - 2]; } return f[n]; } }
非递归解法：
public class Solution { public int Fibonacci(int n) { if (n <= 1) { return n; } //考虑到第 i 项只与第 i-1 和第 i-2 项有关， //因此只需要存储前两项的值就能求解第 i 项， //从而将空间复杂度由 O(N) 降低为 O(1)。 int pre = 0; int p = 1; int res = 0; for (int i = 2; i <= n; i++) { res = pre + p; pre = p; p = res; } return res; } }
-----------------------------------------------------------------------------
青蛙跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
解题思路： 首先考虑最简答的情况，如果只有一级台阶，那么只有一种跳法 如果有两级台阶，那么就有两种跳法 我们把n级台阶时的跳法看成n的函数，即为f(n)， 当n>2时，第一次跳的时候就有两种不同的选择： 第一种是第一次只跳一级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f(n-1) 第二种是第一次跳两级，此时的跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f(n-2) 因此，n级台阶的不同跳法的总数为f(n)=f(n-1)+f(n-2)。
public class Solution { public int JumpFloor(int target) { if (target <= 0) { return 0; } if (target >0 && target <= 2) { return target; } int pre = 1; int p = 2; int res = 0; for (int i = 3; i <= target; i++) { res = pre + p; pre = p; p = res; } return res; } }
变态跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
这个可以用数学来解释 F(n) = F（n-1）+F(n-2)+...+F(1) F(n-1) = F（n-2）+F(n-3)+...+F(1) 两个式子相减，很容易得出F(n)=2F(n-1) 每个台阶都有跳与不跳两种情况（除了最后一个台阶），最后一个台阶必须跳。所以共用2^(n-1)中情况
public class Solution { public int JumpFloorII(int target) { if (target == 0) { return 0; } if (target == 1) { return 1; } return 2 * JumpFloorII(target - 1); } }
--------------------------------------------------
矩形覆盖
题目描述
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
解题思路： 假设2*n的矩形的覆盖方法为f(8) 用第一个2x1的小矩形区覆盖大矩形的最左边有两种选择，竖着放或者横着放。当竖着放的时候，右边还剩2*(n-1)的区域，覆盖的方法有f(n-1)种。当横着放的税后，左下角也得横着放一个小矩形，右边还剩2*(n-2)，覆盖的方法还有f(n-2).即f(n)=f(n-1)+f(n-2)
public class Solution { public int RectCover(int target) { if (target <= 0) { return 0; } if (target > 0 && target <= 2) { return target; } int pre = 1; int p = 2; int res = 0; for (int i = 3; i <= target; i++) { res = p + pre; pre = p; p = res; } return res; } }
---------------------------------------------------------------------------------
旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
这个题目分为有重复元素和没有重复元素两种情况，没有重复元素时，利用二分法，这个时候首先要判断nums[mid]>nums[high],如果是的话，最小值肯定在在mid和high之间，令low=mid+1；否则的话领high=mid，代码如下：
public class Solution { public int findMin(int[] nums) { if (nums.length == 0 || nums == null) { return -1; } int low = 0; int high = nums.length - 1; if (nums[low] < nums[high]) { return nums[low]; } int mid; while (low < high) { mid = low + ((high - low) >> 1); if (nums[mid] > nums[high]) { low = mid + 1; } else { high = mid; } } return nums[low]; } }
那么判断nums[mid]>nums[high],如果是的话，那么最小值肯定在mid和high中间，然后判断nums[mid]<nums[low]，如果是的话最小值肯定在low和mid中间；否则的话都有可能，这个时候只需要令high--，代码如下：
public class Solution { public int findMin(int[] nums) { int low = 0; int high = nums.length - 1; if (nums[low] < nums[high]) { return nums[low]; } int mid; while (low < high) { mid = low + ((high - low) >> 1); if (nums[mid] > nums[high]) { low = mid + 1; } else if (nums[mid] < nums[high]) { high = mid; } else { high--; } } return nums[low]; } }
------------------------------------------------------------------------
搜索旋转排序数组
描述 假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。 你可以假设数组中不存在重复的元素。 您在真实的面试中是否遇到过这个题？ 样例 给出[4, 5, 1, 2, 3]和target=1，返回 2 给出[4, 5, 1, 2, 3]和target=0，返回 -1 挑战 O(logN) time
解题思路 这个题目解得时候，首先查找mid下标元素的值，判断nums[mid]是否等于target，
如果是，返回1;如果不是的话就与low位置的值相比较，判断nums[low]<nums[mid]，
如果是，那么这个范围内的数字是单调递增的，如果不是，那么这个范围内的数字不是单调的。
如果是单调递增的，那么判断这个nums[low]<=target<=nums[mid]，是的话那么让high=mid，否则的话low=mid+1,；
如果不是单调递增的话，那么判断nums[mid]=<target<=nums[high]，如果是的话，令low=mid,否则的话让high=mid-1。
由于区间是low+1<high，所以最后要对结果进行验证，判断low和high哪一个符合要求，具体代码如下:
public class Solution { public int search(int[] nums, int target) { if (nums.length == 0 || nums == null) { return -1; } int low = 0; int high = nums.length - 1; while(low + 1 < high) { int mid = low + ((high - low) >> 1); if (nums[mid] == target) { return mid; } if (nums[mid] > nums[low]) {//前半部分是升序 if (target >= nums[low] && target <= nums[mid]) {//待查找的元素再升序子序列中 high = mid; } else { low = mid + 1; } } else if (nums[mid] < nums[low]){//前半部分不是升序 if (target >= nums[mid] && target <= nums[high]) { low = mid; } else { high = mid - 1; } } } if (nums[low] == target) { return low; } if (nums[high] == target) { return high; } return -1; } }
另一种情况是旋转数组中存在重复元素的时候，这个时候与上面基本相似，就是加一个判断如果nums[mid]=nums[low]的话，就是让low++，具体代码如下：
public class Solution { public boolean search(int[] nums, int target) { if (nums.length == 0 || nums == null) { return false; } int low = 0; int high = nums.length - 1; while(low + 1 < high) { int mid = low + ((high - low) >> 1); if (nums[mid] == target) { return true; } if (nums[mid] > nums[low]) {//前半部分是升序 if (target >= nums[low] && target <= nums[mid]) {//待查找的元素再升序子序列中 high = mid; } else { low = mid + 1; } } else if (nums[mid] < nums[low]){//前半部分不是升序 if (target >= nums[mid] && target <= nums[high]) { low = mid; } else { high = mid - 1; } } else { low++; } } if (nums[low] == target) { return true; } if (nums[high] == target) { return true; } return false; } }
--------------------------------------------------------------------------------------------------------------
二进制中1的个数
题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解题思路：
n&(n-1) 该位运算去除 n 的位级表示中最低的1那一位。 n : 10110100 n-1 : 10110011 n&(n-1) : 10110000 时间复杂度：O(M)，其中 M 表示 1 的个数。
public class Solution { public int NumberOf1(int n) { int count = 0; while (n != 0) { count++; n &= n - 1; } return count++; } }
相关题目： 1.判断一个整数是不是2的整数次方。如果一个整数是2的整数次方，那么它的二进制表示中只有一位是1，
所以把这个整数减去1之后再和它自己做与运算，这个整数中唯一的1就会变成0. 2.输入两个整数m,n，计算需要改变m的二进制表示中的多少位才能得到n。比如10的二进制为1010,13的二进制为1101，
需要改变1010中3为才能得到1101.分为两步解决，第一步求这连个数的异或；第二步统计异或结果中1的位数。
-----------------------------------------------------------------------------------------
数值的整数次方
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
思路分析： 就是求解一个数的幂级数并返回，这道题的一个思路就是利用二分法，判断n的值，
如果n=0，直接返回1，如果n=1，返回x，否则的话判断n的奇偶性，
如果n是偶数，那么x的n次方就可以分解成两个x的n/2次方相乘，然后继续分解；
如果是奇数，那么直接分解成两个x的n/2次方相乘再乘以x，然后递归的调用分解函数就行，具体代码如下;
public class Solution { public double Power(double base, int exponent) { if (exponent == 0) { return 1; } if (exponent == 1) { return base; } if (exponent > 0) { return pow(base, exponent); } else { return 1 / pow(base, -exponent); } } public double pow(double x, int n) { if (n == 1) { return x; } double half = pow(x, n >>> 1); if (n % 2 == 0) { return half * half; } else { return half * half * x; } } }
------------------------------------------------------------------------
调整数组顺序使奇数位于偶数前面
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
public class Solution { public void reOrderArray(int [] array) { if (array == null || array.length == 0) { return; } int oddCnt = 0; for (int i = 0; i < array.length; i++) { if (array[i] % 2 == 1) { oddCnt++; } } int[] copy = array.clone(); int i = 0, j = oddCnt; for (int num : copy) { if (num % 2 == 1) { array[i++] = num; } else { array[j++] = num; } } } }
----------------------------------------------------------------------------------
链表中倒数第k个结点
题目描述
输入一个链表，输出该链表中倒数第k个结点。
解题思路
声明两个指针，第一个先后移k，然后两个指针同时后移，直到第一个到达最后。
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode FindKthToTail(ListNode head,int k) { if (head == null || k <= 0) { return null; } ListNode p = head; ListNode pre = head; while (p != null && k != 0) { p = p.next; k--; } if (k > 0) { return null; } while (p != null) { p = p.next; pre = pre.next; } return pre; } }
---------------------------------------------------------------------------
反转链表
题目描述
输入一个链表，反转链表后，输出新链表的表头。
有递归和非递归两种实现方式，对于非递归方式，
首先要定要三个指针，pre表示前驱节点，p表示当前节点，next表示下一个节点，
非递归的时候有非常固定的模式，
next=p.next,p.next=pre,pre=p,p=next;
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList(ListNode head) { if (head == null || head.next == null) { return head; } ListNode pre = head; ListNode p = head.next; ListNode next = null; while (p != null) { next = p.next; p.next = pre; pre = p; p = next; } head.next = null; return pre; } }
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList(ListNode head) { if (head == null || head.next == null) { return head; } ListNode next = head.next; head.next = null; ListNode newHead = ReverseList(next); next.next = head; return newHead; } }
-------------------------------------------------------------------------------------
合并两个排序的链表
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
将两个有序链表合并成一个有序链表，首先判断一下是否有一个为空，如果是的话返回另外一个，然后从头结点开始判断哪一个链表的节点值小，
将小的一个节点插入到新建的链表中，同时指针向后移动一个，最后知道有一个链表为空结束。最后还要判断哪一个链表没有结束，直接将新链表的next指向没有结束的链表即可.
另外还有一种递归的算法，直接比较两个链表的头结点大小，将小的一个作为新的头结点，然后递归的调用函数.
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode Merge(ListNode list1,ListNode list2) { if (list1 == null) { return list2; } if (list2 == null) { return list1; } ListNode dummy = new ListNode(0); ListNode p = dummy; while (list1 != null && list2 != null) { if (list1.val < list2.val) { p.next = list1; list1 = list1.next; } else { p.next = list2; list2 = list2.next; } p = p.next; } p.next = (list1 == null) ? list2 : list1; return dummy.next; } }
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode Merge(ListNode list1,ListNode list2) { if (list1 == null) { return list2; } if (list2 == null) { return list1; } if (list1.val < list2.val) { list1.next = Merge(list1.next, list2); return list1; } else { list2.next = Merge(list1, list2.next); return list2; } } }
-------------------------------------------------------------------------------
删除链表中重复的结点
题目描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
把所有重复的元素都要删除，因为头结点可能也是重复元素，所以要声明新的头结点，同样这次要声明三个指针pre,p,next；
pre初始化指向新生命的头结点，p初始化为头结点，要判断p和next的值是否相等，所以这两者都不能为空。直接判断p.val是否等于next.val，如果相等
将next后移直至不相等，然后pre.next = next，p = next，这样就将重复的元素都删除了，如果不想等的话直接将pre = p;p = p.next;然后继续执行循环，
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } */ public class Solution { public ListNode deleteDuplication(ListNode pHead) { if (pHead == null || pHead.next == null) { return pHead; } ListNode dummy = new ListNode(0); dummy.next = pHead; ListNode pre = dummy; ListNode p = pHead; ListNode next = null; while (p != null && p.next != null) { next = p.next; if (p.val == next.val) { while (next != null && next.val == p.val) { next = next.next; } pre.next = next; p = next; } else { pre = p; p = p.next; } } return dummy.next; } }
----------------------------------------------------------------
链表中环的入口结点
题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
利用快慢指针做，判断时主要有以下依据：
/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } */ public class Solution { public ListNode EntryNodeOfLoop(ListNode pHead) { if (pHead == null) { return null; } ListNode fast = pHead; ListNode slow = pHead; while (fast != null && fast.next != null) { fast = fast.next.next; slow = slow.next; if (slow == fast) { slow = pHead; while (slow != fast) { slow = slow.next; fast = fast.next; } return fast; } } return null; } }
----------------------------------------------------------------------------------------
