31、连续子数组的最大和
题目描述： 输入一个整型数组，数组里有正数和负数，数组中一个或者多个连续的数字组成一个子数组，求所有子数组的最大值，要求时间复杂度为O(N)
思路1：
/*
算法时间复杂度O（n）
用total记录累计值，maxSum记录和最大
基于思想：对于一个数A，若是A的左边累计数非负，那么加上A能使得值不小于A，认为累计值对
整体和是有贡献的。如果前几项累计值负数，则认为有害于总和，total记录当前值。
此时 若和大于maxSum 则用maxSum记录下来
*/
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
if(array.length==0)
return 0;
else{
int total=array[0],maxSum=array[0];
for(int i=1;i<array.length;i++){
if(total>=0)
total+=array[i];
else
total=array[i];
if(total>maxSum)
maxSum=total;
}
return maxSum;
}
}
}
思路2：动态规划（相当重点）
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
//动态规划，主要是找到状态转移方程
//设f(j)是从s[0]到s[j]最大和
//f(j) = max(s[j], f[j-1]+s[j])
if(array.length == 0)
return 0;
int result = Integer_MinValue;
int sum = 0;
for(int i = 0; i < array.length; ++i)
{
sum = max(array[i], sum + array[i]);
result = max(result, sum);
}
return result;
}
}
32、整数中1出现的次数（从1到n整数中1出现的次数）
题目描述 例如n=13的整数中1出现的次数，1~13中包含1的数字有1、10、11、12、13因此共出现6次
思路： 一、1的数目
编程之美上给出的规律： 1、 如果第i位（自右至左，从1开始标号）上的数字为0，则第i位可能出现1的次数由更高位决定（若没有高位，视高位为0），等于更高位数字 * 当前位数的权重10^(i-1)。
2、如果第i位上的数字为1，则第i位上可能出现1的次数不仅受更高位影响，还受低位影响（若没有低位，视低位为0），等于更高位数字 * 当前位数的权重10^(i-1)+（低位数字+1）。
3、如果第i位上的数字大于1，则第i位上可能出现1的次数仅由更高位决定（若没有高位，视高位为0），等于（更高位数字+1） * 当前位数的权重10^(i-1)。
二、X的数目 这里的 X∈[1,9] ，因为 X=0 不符合下列规律，需要单独计算。
首先要知道以下的规律： 从 1 至 10，在它们的个位数中，任意的 X 都出现了 1 次。 从 1 至 100，在它们的十位数中，任意的 X 都出现了 10 次。 从 1 至 1000，在它们的百位数中，任意的 X 都出现了 100 次。
依此类推，从 1 至 10^ i ，在它们的左数第二位（右数第 i 位）中，任意的 X 都出现了 10^(i-1) 次。
这个规律很容易验证，这里不再多做说明。 接下来以 n=2593,X=5 为例来解释如何得到数学公式。从 1 至 2593 中，数字 5 总计出现了 813 次，其中有 259 次出现在个位，260 次出现在十位，294 次出现在百位，0 次出现在千位。
现在依次分析这些数据， 首先是个位。从 1 至 2590 中，包含了 259 个 10，因此任意的 X 都出现了 259 次。最后剩余的三个数 2591, 2592 和 2593，因为它们最大的个位数字 3 < X，因此不会包含任何 5。（*也可以这么看，3 < X，则个位上可能出现的X的次数仅由更高位决定，等于更高位数字（259）10^(1-1)=259）。
然后是十位。从 1 至 2500 中，包含了 25 个 100，因此任意的 X 都出现了 25×10=250 次。剩下的数字是从 2501 至 2593，它们最大的十位数字 9 > X，因此会包含全部 10 个 5。最后总计 250 + 10 = 260。（*也可以这么看，9>X，则十位上可能出现的X的次数仅由更高位决定，等于更高位数字（25+1）10^(2-1)=260）。
接下来是百位。从 1 至 2000 中，包含了 2 个 1000，因此任意的 X 都出现了 2×100=200 次。剩下的数字是从 2001 至 2593，它们最大的百位数字 5 == X，这时情况就略微复杂，它们的百位肯定是包含 5 的，但不会包含全部 100 个。如果把百位是 5 的数字列出来，是从 2500 至 2593，数字的个数与百位和十位数字相关，是 93+1 = 94。最后总计 200 + 94 = 294。（*也可以这么看，5==X，则百位上可能出现X的次数不仅受更高位影响，还受低位影响，等于更高位数字（2）10^(3-1)+（93+1）=294）。
最后是千位。现在已经没有更高位，因此直接看最大的千位数字2< X，所以不会包含任何 5。（*也可以这么看，2< X，则千位上可能出现的X的次数仅由更高位决定，等于更高位数字（0）10^(4-1)=0）。 到此为止，已经计算出全部数字 5 的出现次数。
总结一下以上的算法，可以看到，当计算右数第 i 位包含的 X 的个数时：
- 1、取第 i 位左边的数字（高位），乘以 10 ^(i−1) ，得到基础值 a 。
- 2、取第 i 位数字，计算修正值：
- 1、如果大于 X，则结果为 a+ 10 ^(i−1) 。
- 2、如果小于 X，则结果为 a 。
- 3、如果等 X，则取第 i 位右边（低位）数字，设为 b ，最后结果为 a+b+1 。
相应的代码非常简单，效率也非常高，时间复杂度只有 O( log 10 n) 。
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
//当x=1时
return NumberOfXBetween1AndN_Solution1(n,1);
}
/**
* @param n
* @param x [1,9]
* @return （从1到n整数中x出现的次数）
*/
public int NumberOfXBetween1AndN_Solution1(int n,int x) {
if(n<0||x<1||x>9)
return 0;
int high,low,curr,tmp,i = 1;
high = n;
int total = 0;
while(high!=0){
high = n/(int)Math.pow(10, i);// 获取第i位的高位
tmp = n%(int)Math.pow(10, i);
curr = tmp/(int)Math.pow(10, i-1);// 获取第i位
low = tmp%(int)Math.pow(10, i-1);// 获取第i位的低位
if(curr==x){
total+= high*(int)Math.pow(10, i-1)+low+1;
}else if(curr<x){
total+=high*(int)Math.pow(10, i-1);
}else{
total+=(high+1)*(int)Math.pow(10, i-1);
}
i++;
}
return total;
}
}
33、把数组排成最小的数
题目描述： 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
package cn.zhuang.offer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Main {
/* 解题思路：
* 考虑到大数问题，先将整型数组转换成String数组，然后将String数组排序，最后将排好序的字符串数组拼接出来。关键就是制定排序规则。
* 排序规则如下：
* 若ab > ba 则 a > b，
* 若ab < ba 则 a < b，
* 若ab = ba 则 a = b；
* 解释说明：
* 比如 "3" < "31"但是 "331" > "313"，所以要将二者拼接起来进行比较
*/
public static String PrintMinNumber(int [] numbers) {
if(numbers == null || numbers.length == 0) return "";
int len = numbers.length;
String[] str = new String[len];
StringBuilder sb = new StringBuilder();
for(int i = 0; i < len; i++){
str[i] = String.valueOf(numbers[i]);
}
//此处较为重要，新的排序规则,如若取最大值，~c1.compareTo(c2)
Arrays.sort(str,new Comparator<String>(){
@Override
public int compare(String s1, String s2) {
String c1 = s1 + s2;
String c2 = s2 + s1;
return c1.compareTo(c2);
}
});
for(int i = 0; i < len; i++){
sb.append(str[i]);
}
return sb.toString();
}
public static void main(String[] args){
int[] a = {3,32,421};
System.out.println(PrintMinNumber(a));
}
}
java中的compareto方法，返回参与比较的前后两个字符串的asc码的差值，看下面一组代码 String a="a",b="b"; System.out.println(a.compareto.b); 则输出-1； 若a="a",b="a"则输出0； 若a="b",b="a"则输出1；
单个字符这样比较，若字符串比较长呢？？ 若a="ab",b="b",则输出-1； 若a="abcdef",b="b"则输出-1； 也就是说，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值；
如果首字母相同呢？？ 若a="ab",b="a",输出1； 若a="abcdef",b="a"输出5； 若a="abcdef",b="abc"输出3； 若a="abcdef",b="ace"输出-1； 即参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值，如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值
34、丑数
题目描述： 把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路1：最简单的方法就是先通过将一个数不断除以2，3，5来判定该数是不是丑数，而后在从1开始，依次往后判断每个数是不是丑数，并记下丑数的个数，这样当计算的个数为给定值时，便是需要求的第n个丑数，这种方法的时间复杂度为O（k），这里的k为第n个丑数的大小，比如第1500个丑数的大小为859963392，那么就需要判断859963392次，时间效率非常低。
public boolean IsUgly(int number)
{
while(number % 2 == 0)
number /= 2;
while(number % 3 == 0)
number /= 3;
while(number % 5 == 0)
number /= 5;
return (number == 1) ? true : false;
}
public int GetUglyNumber(int index)
{
if(index <= 0)
return 0;
int number = 0;
int uglyFound = 0;
while(uglyFound < index)
{
++number;
if(IsUgly(number))
{
++uglyFound;
}
}
return number;
}
思路Better2：直观的优化措施就是看能不能将时间复杂度降低到O（n），即只在丑数上花时间，而不在非丑数上浪费时间。剑指offer上给的思路很好，用O（n）的辅助空间来得到O(n)的时间复杂度。其核心思想是：每一个丑数必然是由之前的某个丑数与2，3或5的乘积得到的，这样下一个丑数就用之前的丑数分别乘以2，3，5，找出这三这种最小的并且大于当前最大丑数的值，即为下一个要求的丑数。
import java.util.*;
public class Solution
{
public int GetUglyNumber_Solution(int n)
{
if(n==0)return 0;
ArrayList<Integer> res=new ArrayList<Integer>();
res.add(1);
int i2=0,i3=0,i5=0;
while(res.size()<n)
{
int m2=res.get(i2)*2;
int m3=res.get(i3)*3;
int m5=res.get(i5)*5;
int min=Math.min(m2,Math.min(m3,m5));
res.add(min);
if(min==m2)i2++;
if(min==m3)i3++;
if(min==m5)i5++;
}
return res.get(res.size()-1);
}
}
35、第一个只出现一次的字符
描述：在一个字符串(1<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符的位置。若为空串，返回-1。位置索引从0开始，如“abaccdrff”，则输出“b”
第一种，数组方法：
public class Solution {
public int FirstNotRepeatingChar(String str) {
if (str.length() == 0) {
return -1;
}
char c = 'A';
if(str.charAt(0) >= 'a'){
c = 'a';
}
int[] counts = new int[26];
for (int i = 0; i < str.length(); i++) {
counts[str.charAt(i) - c]++;
}
for (int i = 0; i < str.length(); i++) {
if (counts[str.charAt(i) - c] == 1){
return i;
}
}
return -1;
}
}
第二种，HashMap方法：
import java.util.LinkedHashMap;
// use linkedhashmap to keep the order
public class Solution {
public int FirstNotRepeatingChar(String str) {
LinkedHashMap <Character, Integer> map = new LinkedHashMap<Character, Integer>();
for(int i=0;i<str.length();i++){
if(map.containsKey(str.charAt(i))){
int time = map.get(str.charAt(i));
map.put(str.charAt(i), ++time);
}
else {
map.put(str.charAt(i), 1);
}
}
int pos = -1;
int i=0;
for(;i<str.length();i++){
char c = str.charAt(i);
if (map.get(c) == 1) {
return i;
}
}
return pos;
}
}
36、数组中的逆序对
题目描述： 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。 {7，5，6，4}，则76，75，74，64，65，一共5个
思路： [图片上传失败...(image-6cd73e-1558756284765)]
public class Solution {
private int reversePair = 0;
public int InversePairs(int [] array) {
if(array==null)
return 0;
int len = array.length;
if(len==0)
return 0;
sort(array,0,len-1);
return reversePair;
}
private void sort(int[]arr,int start,int end){
if(start<end){
int mid = start+(end-start)/2;
sort(arr,start,mid);
sort(arr,mid+1,end);
merger(arr,start,mid,mid+1,end);
}
}
private void merger(int[] arr, int start1, int end1, int start2, int end2) {
int len= end2-start1+1;
int[] anx = new int[len];
int k = end2-start1+1;
int i = end1;
int j= end2;
while(i>=start1&j>=start2){
if(arr[i]>arr[j]){
anx[--k]=arr[i];
i--;
reversePair = reversePair+(j-start2+1);
}
else{
anx[--k]=arr[j];
j--;
}
}
for(;i>=start1;i--)
anx[--k]=arr[i];
for(;j>=start2;j--)
anx[--k]=arr[j];
for(int m=0;m<len;m++)
arr[start1++]=anx[m];
}
}
37、两个链表的第一个公共交点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
if (pHead1 == null||pHead2 == null) {
return null;
}
int count1 = 0;
ListNode p1 = pHead1;
while (p1!=null){
p1 = p1.next;
count1++;
}
int count2 = 0;
ListNode p2 = pHead2;
while (p2!=null){
p2 = p2.next;
count2++;
}
int flag = count1 - count2;
if (flag > 0){
while (flag>0){
pHead1 = pHead1.next;
flag --;
}
while (pHead1!=pHead2){
pHead1 = pHead1.next;
pHead2 = pHead2.next;
}
return pHead1;
}
if (flag <= 0){
while (flag<0){
pHead2 = pHead2.next;
flag ++;
}
while (pHead1 != pHead2){
pHead2 = pHead2.next;
pHead1 = pHead1.next;
}
return pHead1;
}
return null;
}
}
38、数字在排序数组中出现的次数
思路：重点是有序数组这个条件，采用二分查找法，分别找到第一个和最后一个，这样无论最好最坏复杂度都是O（lgN）
public class Solution {
public int GetNumberOfK(int [] array , int k) {
int num = 0;
if (array != null && array.length > 0) {
int firstKIndex = getFirstK(array, k, 0, array.length - 1);
int lastKIndex = getLastK(array, k, 0, array.length - 1);
if (firstKIndex > -1 && lastKIndex > -1)
num = lastKIndex - firstKIndex + 1;
}
return num;
}
/*
* 找到第一个出现的数字的下标
*/
public int getFirstK(int[] array, int k, int start, int end) {
if (start > end)
return -1;
int middleIndex = start + (end - start) / 2;
int middleData = array[middleIndex];
if (middleData == k) {
//判断是不是第一个K，前一个不等于K，就是第一个K
if (middleIndex > 0 && array[middleIndex - 1] != k || middleIndex == 0) {
return middleIndex;
} else
end = middleIndex - 1;
} else if (middleData > k) {
end = middleIndex - 1;
} else
start = middleIndex + 1;
return getFirstK(array, k, start, end);
}
/*
* 找到最后一个出现的数字的下标
*/
public int getLastK(int array[], int k, int start, int end) {
if (start > end) {
return -1;
}
int middleIndex = (start + end) / 2;
int middleData = array[middleIndex];
if (middleData == k) {
//判断是不是最后一个K，后一个不等于K，就是最后一个K
if (middleIndex < array.length - 1 && array[middleIndex + 1] != k || middleIndex == array.length - 1)
return middleIndex;
else
start = middleIndex + 1;
} else if (middleData < k) {
start = middleIndex + 1;
} else
end = middleIndex - 1;
return getLastK(array, k, start, end);
}
}
39、二叉树的深度
题目描述： 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路：递归，下一层根节点到上一层根节点，深度加1，判断左子树和右子树的最大值，然后+1
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
};*/
public class Solution {
public int getHeight(TreeNode root) {
if (root == null)
return 0;
return max(getHeight(root.left), getHeight(root.right)) + 1;
}
private int max(int a, int b) {
return (a > b) ? a : b;
}
}
扩展题：判断二叉树平衡
描述：如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
第一种思路：简洁，但是效率不高，因为会重复遍历子节点
public class Solution {
public boolean IsBalanced(TreeNode root) {
if (root == null)
return true;
if (Math.abs(getHeight(root.left) - getHeight(root.right)) > 1)
return false;
return IsBalanced(root.left) && IsBalanced(root.right);
}
public int getHeight(TreeNode root) {
if (root == null)
return 0;
return max(getHeight(root.left), getHeight(root.right)) + 1;
}
private int max(int a, int b) {
return (a > b) ? a : b;
}
}
第二种Better思路：从底向上判断，这样可以记录下一层的深度
public class Solution {
public boolean IsBalanced(TreeNode root) {
int depth = 0;
return IsBalanced(root, depth);
}
public boolean IsBalanced(TreeNode root, int depth) {
if (root == null) {
depth = 0;
return true;
}
int left = 0, right = 0;
if (IsBalanced(root.left, left) && IsBalanced(root.right, right)) {
int diff = left - right;
if (diff <= 1 && diff >= -1) {
depth = 1 + (left > right ? left : right);
return true;
}
}
return false;
}
}
40-数组只指出现一次的数字：
异或去重:
适应情景：数组中只有一个数字出现了奇数次，其他的都出现了偶数次。或者只有一个数字出现了偶数次，其他的都出现了奇数次 性质：对于任意的a：a^a=0，a^0=a，a^(-1)=~a。
下面来看三道题目：
1、1-1000放在含有1001个元素的数组中，只有唯一的一个元素值重复，其它均只出现一次。每个数组元素只能访问一次，设计一个算法，将它找出来；不用辅助存储空间，能否设计一个算法实现？
当然，这道题，可以用最直观的方法来做，将所有的数加起来，减去1+2+3+...+1000的和，得到的即是重复的那个数，该方法很容易理解，而且效率很高，也不需要辅助空间，唯一的不足时，如果范围不是1000，而是更大的数字，可能会发生溢出。
我们考虑用异或操作来解决该问题。现在问题是要求重复的那个数字，我们姑且假设该数字式n吧，如果我们能想办法把1-1000中除n以外的数字全部异或两次，而数字n只异或一次，就可以把1-1000中出n以外的所有数字消去，这样就只剩下n了。我们首先把所有的数字异或，记为T，可以得到如下：
T = 1^2^3^4...^n...^n...^1000 = 1^2^3...^1000（结果中不含n）
而后我们再让T与1-1000之间的所有数字（仅包含一个n）异或，便可得到该重复数字n。如下所示：
T^(a^2^3^4...^n...^1000) = T^(T^n) = 0^n = n
2、一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
样例输入：2 4 3 6 3 2 5 5 样例输出：4 6
思路：异或去重是知道如果只有一个只出现一次的数字的求法，但这里是有两个只出现一次的数字，我们便要想办法把他分为两个子数组，每个子数组中包含一个只出现一次的数字，其他的数字都出现了两次。
首先依然从头到尾异或所有的数字，如ABCCDDEEFF，这样得到的结果就是AB异或的结果，那么在异或后的结果中找出其二进制中最右边为1的位，该位既然为1，说明AB对应的该位肯定不同，必定一个为1，一个为0，因此我们可以考虑根据此位是否为1来划分这两个子数组，这样两个只出现一次的数字就分开了
但我们还要保证出现两次的数字都分到同一个子数组中，很明显，相同的数字相同的位上的值是相同的，要么都为1，要么都为0，因此我们同样可以通过判断该位是否为1来将这些出现两次的数字划分到同一个子数组中，该位如果为1，就分到一个子数组中，如果为0，就分到另一个子数组中。
这样就能保证每个子数组中只有一个出现一次的数字，其他的数字都出现两次，分别全部异或即可得到这两个只出现一次的数字。时间复杂度为O(n)。
另外，**所有元素异或后，在找出最右边为1的时,**X&(-X)之后得到的数字，是把X中最右边的1保留下来
注意，这里的-X是X的相反数，-X是对X所有位取反+1
package cn.zhuang.offer;
public class Main {
public static void FindNumsAppearOnce(int[] arr)
{
int len = arr.length;
if(len<2)
return;
int i;
int AllXOR = 0;
//全部异或
for(i=0;i<len;i++)
AllXOR ^= arr[i];
//找出第几位为1，如010
int res = FindFirstBit1(AllXOR);
int num1=0, num2 = 0;
for(i=0;i<len;i++)
{ //分成了两组
if(IsBit1(arr[i],res))
num1 ^= arr[i];
else
num2 ^= arr[i];
}
System.out.println(num1+"and"+num2);
}
/*
返回num的最低位的1，其他各位都为0
*/
public static int FindFirstBit1(int num)
{
//二者与后得到的数，将num最右边的1保留下来，其他位的全部置为了0
return num & (-num);
}
/*
判断data中特定的位是否为1，
这里的要判断的特定的位由res确定，
res中只有一位为1，其他位均为0，由FindFirstBit1函数返回，
而data中要判断的位便是res中这唯一的1所在的位
*/
public static boolean IsBit1(int data,int res)
{
return ((data & res)==0) ? false:true;
}
public static void main(String[] args) {
int[] a = { 1,1,2,2,3,44,55,55,66,66,34,34,5,5,7,7 };
FindNumsAppearOnce(a);
}
}
3、题目：一个int数组中有三个数字a、b、c只出现一次，其他数字都出现了两次。请找出三个只出现一次的数字。
通用性的方法，对于2个，3个出现一次的数字这类的问题，都可以按照该思路去求解，只是时间复杂度可能要稍微大些，为O(8* sizeof(int)* N)，8位* 4字节* N自然就是数组的长度了。
该方法的思路如下：
首先由于有3个数字出现一次，其他的都出现两次，所以N肯定为奇数，该方法通过扫描整数的每一位来逐个判断。
再看这3个只出现一次的数字，他们的bit位肯定不可能全部相同，至少有一个位，要么110，要么001，我们可以通过扫面int的所有bit位，扫描每个bit位的时候，遍历数组，首先找到一个，另外的两个就可以按照上题的解法。
如何找到第一个数？
我们遍历数组，分别统计该数组元素中该bit位为1和0的元素个数，分别设为count1和count0，并同时将所有该bit位为1的元素异或结果为temp1，所有该bit位为0的元素异或，得到的结果为temp0。
如果111或000这两种状态，肯定三个都在count为奇数的里边，不好区分，主要找110或001的区分
先看第一种情况，001，如果count1为奇数，则为111或001，则在count1的数组里，如果temp0==0，则为111，此位不是判断的位，下一位，如果temp0==1，则为001，temp1则为所求。
先看第二种情况，110，如果count1为偶数，则为110或000，则在count1的数组里，如果temp1==0，则为000，此位不是判断的位，下一位，如果temp1==1，则为110，temp0则为所求。
说白了，就是看count1为奇数时，temp0是否为1，count1为偶数时，temp1是否为1。
package cn.zhuang.offer;
public class Main {
/*
* 找出这三个只出现一次的数字
*/
public static void FindThreeNumsAppearOnce(int[] arr, int len) {
if (len < 3)
return;
int num1 = FindOneNumAppearOnce(arr, len);
System.out.println(num1);
// 找到第一个找出的数字，并与最后一个元素交换，便于接下来剩下的两个数字
int i;
for (i = 0; i < len; i++){
if (num1 == arr[i]){
int temp ;
temp = arr[i];
arr[i] = arr[len -1];
arr[len - 1]=temp;
break;
}
}
FindTwoNumsAppearOnce(arr, len - 1);
}
/*
* 通过扫面每一位，先找出一个只出现一次的数
*/
public static int FindOneNumAppearOnce(int[] arr, int len) {
int count1 = 0; // 某一位上1的个数
int count0 = 0; // 某一位上0的个数
int temp1 = 0; // 某一位为1的所有数相异或的结果
int temp0 = 0; // 某一位为0的所有数相异或的结果
int i, j;
// 循环计算每一位的以上四个数据
for (i = 0; i < 32; i++) {
count1 = count0 = temp1 = temp0 = 0;// 每次计算下一位时清零
for (j = 0; j < len; j++) {
// 每次向左移一位进行计算
if ((arr[j] & (1 << i)) != 0) {
temp1 ^= arr[j];
count1++;
} else {
temp0 ^= arr[j];
count0++;
}
}
if ((temp1 & 1) != 0) {
// 某位上有奇数个1
if (temp0 == 0) // 此时3个不同数的该位都为1
continue;
else
// 此时3个不同数的该位有1个1，2个0
return temp1;
} else {
// 某位上有偶数个1
if (temp1 == 0) // 此时3个不同数的该位都为0
continue;
else
// 此时3个不同数的该位有1个0，2个1
return temp0;
}
}
return Integer.MAX_VALUE;
}
public static void FindTwoNumsAppearOnce(int[] arr, int len) {
int i;
int AllXOR = 0;
// 全部异或
for (i = 0; i < len; i++)
AllXOR ^= arr[i];
int res = FindFirstBit1(AllXOR);
int num1 = 0;
int num2 = 0;
for (i = 0; i < len; i++) {
if (IsBit1(arr[i], res))
num1 ^= arr[i];
else
num2 ^= arr[i];
}
System.out.println(num1);
System.out.println(num2);
}
/*
* 返回num的最低位的1，其他各位都为0
*/
public static int FindFirstBit1(int num) {
// 二者与后得到的数，将num最右边的1保留下来，其他位的全部置为了0
return num & (-num);
}
/*
* 判断data中特定的位是否为1， 这里的要判断的特定的位由res确定， res中只有一位为1，其他位均为0，由FindFirstBit1函数返回，
* 而data中要判断的位便是res中这唯一的1所在的位
*/
public static boolean IsBit1(int data, int res) {
return ((data & res) == 0) ? false : true;
}
public static void main(String[] args) {
int[] a = { 1,2,2,3,44,55,55,66,66,34,34,5,5,7,7 };
FindThreeNumsAppearOnce(a, a.length);
}
}
声明：此文章为本人原创，如有转载，请注明出处
如果您觉得有用，欢迎关注我的公众号，我会不定期发布自己的学习笔记、AI资料、以及感悟，欢迎留言，与大家一起探索AI之路。
