剑指offer31-40

整数中1出现的次数

public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        int count=0;
        while(n>0)
        {
            String s=String.valueOf(n);
            char[] chars=s.toCharArray();
            for(int i=0;i<chars.length;i++)
            {
                if(chars[i]=='1')
                    count++;
            }
            n--;
        }
        return count;
    }
}

把数组排成最小的数

import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public String PrintMinNumber(int [] numbers) {
        String nums[]=new String[numbers.length];
        for(int i=0;i<numbers.length;i++)
        {
            nums[i]=numbers[i]+"";
        }
        Arrays.sort(nums,(s1,s2)->(s1+s2).compareTo(s2+s1));
        String ret="";
        for(String str:nums)
        {
            ret=ret+str;
        }
        return ret;
    }
}

丑数

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        //将所有的丑数记录下来，
        if(index<=6)
            return index;
        int array[]=new int[index];
        int i2=0,i3=0,i5=0;
        array[0]=1;
        for(int i=1;i<index;i++)
        {
            //先找出三个丑数中最小的依次向下延伸
            int n2=array[i2]*2,n3=array[i3]*3,n5=array[i5]*5;
            array[i]=Math.min(n2,Math.min(n3,n5));
            if(array[i]==n2)
                i2++;
            if(array[i]==n3)
                i3++;
            if(array[i]==n5)
                i5++;
        }
        return array[index-1];
    }
}

第一个只出现一次的字符

public class Solution {
    public int FirstNotRepeatingChar(String str) {
        int array[]=new int[256];
        for(int i=0;i<str.length();i++)
        {
            array[str.charAt(i)]++;
        }
        for(int i=0;i<str.length();i++)
        {
            if(array[str.charAt(i)]==1)
                return i;
        }
        return -1;
    }
}

两个链表的第一个公共节点

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode l1=pHead1;
        ListNode l2=pHead2;
        while(l1!=l2)
        {
            l1=(l1==null)?pHead2:l1.next;
            l2=(l2==null)?pHead1:l2.next;
        }
        return l1;
 //定义两个指针分别跑自己的链表，当一个跑到终点的时候就从另外一个链表的头结点开始跑直到两个链表的节点重合
 //当两个链表的指针重合的时候就证明到了第一个公共节点  因为ａ＋ｃ＋ｂ＝ｂ＋ｃ＋ａ；
    }
}

统计一个数字在排序数组中排序数组中出现的次数

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int first=BinarySearch(array,k);//记录数字为k的起始坐标
        int last=BinarySearch(array,k+1);//记录数字为k+1的起始坐标
        return (first==array.length||array[first]!=k)?0:last-first;
   
    }
    private int BinarySearch(int []num,int k)
    {
        int last=num.length;//所需要查询的数组的尾坐标
        int first=0;//所需查询的数组的起始坐标
        while(first<last)
        {
            int mid=first+(last-first)/2;//中间坐标
            if(num[mid]>=k)
                last=mid;
            else
                first=mid+1;
        }
        return first;
        
    }
}

二叉树的深度

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
import java.lang.Math;
public class Solution {
    public int TreeDepth(TreeNode root) {
        return root==null?0:1+Math.max(TreeDepth(root.left),TreeDepth(root.right));
        
    }
}

判断二叉树是否是平衡二叉树

import java.lang.Math;
public class Solution {
    private boolean isbalance=true;
    //平衡二叉树的左右子树的高度之差不超过1
    public boolean IsBalanced_Solution(TreeNode root) {
        int height=HeightSeeking(root);
        return isbalance;
        
    }
    private int HeightSeeking(TreeNode root){
        if(root==null)
            return 0;
        int left=HeightSeeking(root.left);
        int right=HeightSeeking(root.right);
        if(Math.abs(left-right)>1)
            isbalance=false;
        return 1+Math.max(left,right);
        
    }
}

数组中只出现一次的数字

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int[] nums, int num1[], int num2[]) {
        int diff = 0;
        for (int num : nums)
            diff ^= num;//因为其它成对出现的两个数字相与就是0000而任何元素与0000想与都是他本身所以求出的diff就是这两个只出现
        //一次数字进行相与的结果
        diff &= -diff;//得到diff最右侧不为0的位，这可以对这两个数进行区分
        for (int num : nums) {
            if ((num & diff) == 0)
                num1[0] ^= num;//这样可以区分出这两个不一样的数，如果除了这两个其它的数满足条件肯定是成对添加的，所以还收0000与这两个书其中的一个进行想与
            else
                num2[0] ^= num;
        }
    }
}

和为s的连续正数序列

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList <ArrayList<Integer>>ret=new ArrayList();
        int start=1;//起始位置
        int end=2;//中止位置
        int cursum=3;//当前的数组和
        while(end<sum)
        {
            if(cursum>sum){
                cursum-=start;
                start++;
            }
            else if(cursum<sum){
                end++;
                cursum+=end;
            }
            else
            {
                ArrayList<Integer> list=new ArrayList<Integer>();
                for(int i=start;i<=end;i++)
                {
                    list.add(i);
                }
                ret.add(list);
                cursum-=start;
                start++;
                end++;
                cursum+=end;
            }
        }
        return ret;
    }
}