LeetCode算法 IntegertoEnglishWords的解题方法

说明：本人能力有限，部分算法效率较差，各位如有好的思路，请留言回复。

(相关资料图)

Integer to English Words：

解题思路：由于最大输入值不可能大于231- 1.即2147483647，第十位：Billion；第七位：Million；第四位：Thousand；第一位：个位。由此可能观察到，将输入值分成四个小组，每三个一组，从低到高依次输入四个小组中。然分别对每个小组中处理，分别百位，十位，个位。

Java实现：

publicclass Solution {

public String numberToWords(int num) {

if(num==0) return "Zero";

int[] grp=new int[4];

String[] strNum=new String[4];

strNum[0]="";

strNum[1]="";

strNum[2]="";

strNum[3]="";

int i=0;

while(num!=0){

int mod=num%1000;

grp[i++]=mod;

num=num/1000;

}

for(int j=i;j<GRP.LENGTH;J++)< strong="">

grp[j]=0;

for(int k=0;k<GRP.LENGTH;K++){

int third=grp[k]/100;

if(third!=0){

switch(third){

case1:strNum[k]+="One ";break;

case 2:strNum[k]+="Two";break;

case 3:strNum[k]+="Three";break;

case 4:strNum[k]+="Four";break;

case 5:strNum[k]+="Five";break;

case 6:strNum[k]+="Six";break;

case 7:strNum[k]+="Seven";break;

case 8:strNum[k]+="Eight";break;

case 9:strNum[k]+="Nine";break;

}

strNum[k]+="Hundred ";

}

grp[k]=grp[k]%100;

int second=grp[k]/10;

if(second!=0){

switch(second){

case 1:

switch(grp[k]){

case10:strNum[k]+="Ten ";break;

case11:strNum[k]+="Eleven ";break;

case12:strNum[k]+="Twelve ";break;

case13:strNum[k]+="Thirteen ";break;

case14:strNum[k]+="Fourteen ";break;

case15:strNum[k]+="Fifteen ";break;

case16:strNum[k]+="Sixteen ";break;

case17:strNum[k]+="Seventeen ";break;

case18:strNum[k]+="Eighteen ";break;

case19:strNum[k]+="Nineteen ";break;

}

break;

case 2:strNum[k]+="Twenty ";break;

case 3:strNum[k]+="Thirty ";break;

case 4:strNum[k]+="Forty ";break;

case 5:strNum[k]+="Fifty ";break;

case 6:strNum[k]+="Sixty ";break;

case 7:strNum[k]+="Seventy ";break;

case 8:strNum[k]+="Eighty ";break;

case 9:strNum[k]+="Ninety ";break;

}

}

if(second!=1){

grp[k]=grp[k]%10;

int first=grp[k];

if(first!=0){

switch(first){

case1:strNum[k]+="One ";break;

case 2:strNum[k]+="Two";break;

case 3:strNum[k]+="Three";break;

case 4:strNum[k]+="Four";break;

case 5:strNum[k]+="Five";break;

case 6:strNum[k]+="Six";break;

case 7:strNum[k]+="Seven";break;

case 8:strNum[k]+="Eight";break;

case 9:strNum[k]+="Nine";break;

}

}

}

if(strNum[k].length()>0){

switch(k){

case 1:strNum[k]+="Thousand";break;

case 2:strNum[k]+="Million";break;

case 3:strNum[k]+="Billion";break;

}

}

}

String res=strNum[3]+strNum[2]+strNum[1]+strNum[0];

return res.substring(0,res.length()-1);

}

}

url:https://leetcode.com/problems/integer-to-english-words/

2、Missing Number

解题思路：利用输入漏掉数字的数组所有数字之和和完全数组之和，做减法，即差值即是所要的。

Java代码实现：

public class Solution {

public intmissingNumber(int[] nums) {

int sum1=0;

int sum=0;

for(inti=0;i<NUMS.LENGTH+1;I++)< h3="">

sum1=sum1+i;

for(inti=0;i<NUMS.LENGTH;I++)< h3="">

sum=sum+nums[i];

return sum1-sum;

}

}

url:https://leetcode.com/problems/missing-number/

3，Ugly Number

解题思路：分别让输入值给2、3、5做除法，直至不存在上述数字的倍数为止。

Java代码实现：

public class Solution {

public booleanisUgly(int num) {

if(num==0) returnfalse;

while(num%2==0)num=num/2;

while(num%3==0)num=num/3;

while(num%5==0)num=num/5;

if(num==1) returntrue;

else return false;

}

}

url:https://leetcode.com/problems/ugly-number/

4、SingleNumber III

解题思路：该题利用一个集合存储遍历的数字，如何初始该集合中没有则加入，有的话则删除，最后集合里面的数字，即是所要求的。

Java代码实现：

public class Solution {

public int[]singleNumber(int[] nums) {

Set set=newHashSet();

for(inti=0;i<NUMS.LENGTH;I++){

if(!set.contains(nums[i])) set.add(nums[i]);

else set.remove(nums[i]);

}

int [] re=newint[set.size()];

Iteratorit=set.iterator();

int i=0;

while(it.hasNext()){

re[i++]=it.next();

}

//System.out.print(re);

return re;

}

}

url:https://leetcode.com/problems/single-number-iii/

5、AddDigits

解题思路：传统方法，按位相加，循环，直至只有一位为止。

Java代码实现：

public class Solution {

public intaddDigits(int num) {

int sum=0;

//System.out.println(num);

while(num/10>0){

StringstrNum=String.valueOf(num);

//System.out.println(strNum.length());

for(inti=0;i<STRNUM.LENGTH();I++){

sum+=Integer.valueOf(strNum.charAt(i))-48;

//System.out.println(sum);

}

System.out.println(sum);

num=sum;

sum=0;

}

sum=num;

return sum;

}

}

url：https://leetcode.com/submissions/detail/37775675/

6、ValidAnagram

解题思路：该题意思即是两个字符串是否具有相同的字符组成的串，首先记录第一个字符串出现的字符及其个数，然后与第二个字符串想比较。（另一个思路：将两个字符串分别排序，不过耗时。）

Java代码实现：

public class Solution {

public booleanisAnagram(String s, String t) {

if(s.length()!=t.length()) return false;

Mapmap =new HashMap();

for(inti=0;i<S.LENGTH();I++){

String str=String.valueOf(s.charAt(i));

if(map.containsKey(str)) map.put(str,map.get(str)+1);

else map.put(str, 1);

}

for(int i=0;i<T.LENGTH();I++){

String str=String.valueOf(t.charAt(i));

if(map.containsKey(str)) {

map.put(str, map.get(str)-1);

if(map.get(str)==0)map.remove(str);

}

else map.put(str, 1);

}

if(map.isEmpty())return true;

else return false;

}

}

url：https://leetcode.com/problems/valid-anagram/

7、DeleteNode in a Linked List

解题思路：指定删除任一节点，因无头节点指针，实际删除节点即是删除节点的值，所以可以将要删除节点和后继节点的值替换，删除后继节点即可。

Java代码实现：

/**

* Definition forsingly-linked list.

* struct ListNode {

*int val;

*struct ListNode *next;

* };

*/

void deleteNode(struct ListNode* node) {

struct ListNode *p,*q;

p=q=node;

q=p->next;

p->val=q->val;

p->next=q->next;

free(q);

}

url：https://leetcode.com/submissions/detail/37866400/

8、Numberof Digit One

解题思路：0-9中1的个数为1个，而X99..9的1的个数可以通过公式计算：即Math.pow(10, digit-1)+(10-(9-highestDigit))*Math.pow(10,digit-2)*(digit-1);比如8999：10^3+9*10^2*3。由此可以将输入数字分解，比如9548=9000+548=9000+500+48=9000+500+40+8，如此分布计算即可。

Java代码：

public class Solution {

public intcountDigitOne(int n) {

int count=0;

while(n>0){

if(n/10==0) {

count++;

return count;//大于1的个位数只有一个1，返回

}

intdigit=0;//存储数字位数

int num=n;

while(num/10>0){

digit++;

num=num/10; //num最高位数字

}

digit++;

int highestDigit=num;//最高位数字

num=(int) (num*(Math.pow(10, digit-1)))-1;

if(highestDigit==1) {//1为最高位时，-1数字位数将会发生改变

count++;

count+=n-(num+1);

highestDigit=9;

digit--;

}

else{

highestDigit--;

}

count+=Math.pow(10,digit-1)+(10-(9-highestDigit))*Math.pow(10, digit-2)*(digit-1);//如8999计算1的公式

n=n-(num+1);

}

return count;

}

}

url：https://leetcode.com/submissions/detail/37894024/

9、ImplementQueue using Stacks

解题思路：采用两个栈，实现队列，一个用于进栈S1，一个用于出栈和取头元素S2。进栈时必须将S2中元素全部加入S1中，出栈时必须将S1中的元素加入S2中，才可以保证先进先出。判断为空时，S1，S2均为空。

Java代码实现：

class MyQueue {

private Stack stack1;

private Stack stack2;

MyQueue(){

stack1=newStack();

stack2=newStack();

}

// Push element x tothe back of queue.

public void push(intx) {

if(stack2.isEmpty()) stack1.push(x);

else {

while(!stack2.isEmpty()){

stack1.push(stack2.peek());

stack2.pop();

}

stack1.push(x);

}

}

// Removes the elementfrom in front of queue.

public void pop() {

if(stack1.isEmpty()) {

if(!stack2.isEmpty())

stack2.pop();

}

else {

while(!stack1.isEmpty()){

stack2.push(stack1.peek());

stack1.pop();

}

stack2.pop();

}

}

// Get the frontelement.

public int peek() {

if(stack1.isEmpty()) {

if(!stack2.isEmpty())

return (int) stack2.peek();

return -1;

}

else {

while(!stack1.isEmpty()){

stack2.push(stack1.peek());

stack1.pop();

}

return (int) stack2.peek();

}

}

// Return whether thequeue is empty.

public boolean empty(){

if(stack1.isEmpty()&&stack2.isEmpty())return true;

else return false;

}

}

url：https://leetcode.com/submissions/detail/37897765/

10、Power of Two

解题思路：如果一个数是否是2的次方，即如果其对应的二进制数1的个数如果超过1，不是的2的次方，反之才是。

Java代码实现：

public class Solution {

public booleanisPowerOfTwo(int n) {

int count=0;

if(n==1) return true;

if(n<=0) return false;

while(n>0){

int mod=n%2;

if(mod==1) count++;

if(count>1) return false;

n=n/2;

}

return true;

}

}

url:https://leetcode.com/problems/power-of-two/

11、Kth Smallest Element in aBST

解题思路：按树的中序遍历的方式，利用栈实现，第k个出栈的节点即是所求的。

Java代码实现：

/**

* Definition for a binarytree node.

* public class TreeNode {

*int val;

*TreeNode left;

*TreeNode right;

*TreeNode(int x) { val = x; }

* }

*/

public class Solution {

public intkthSmallest(TreeNode root, int k) {

TreeNode p=newTreeNode(0);

p=root;

Stack sk=newStack();

sk.push(p);

while(p.left!=null){

sk.push(p.left);

p=p.left;

}

int i=0;

while(!sk.isEmpty()){

TreeNode q=newTreeNode(0);

q=(TreeNode)sk.pop();

i++;

if(i==k)return q.val;

if(q.right!=null) {

p=q.right;

sk.push(p);

while(p.left!=null){

sk.push(p.left);

p=p.left;

}

}

}

return 0;

}

}

url:https://leetcode.com/submissions/detail/38221838/

12、Invert Binary Tree

解题思路：利用中序遍历的方式，依次交换所遍历节点的左右子树。

Java代码实现：

/**

* Definition for a binarytree node.

* public class TreeNode {

*int val;

*TreeNode left;

*TreeNode right;

*TreeNode(int x) { val = x; }

* }

*/

public class Solution {

public TreeNodeinvertTree(TreeNode root) {

if(root==null)return root;

Stack stack=newStack();

TreeNode p=newTreeNode(0);

stack.push(root);

p=root;

while(p.left!=null){

p=p.left;

stack.push(p);

}

while(!stack.isEmpty()){

TreeNodeq=(TreeNode)stack.pop();

TreeNodetemp=new TreeNode(0);;

temp=q.left;

q.left=q.right;

q.right=temp;

while(q.left!=null){

stack.push(q.left);

q=q.left;

}

}

return root;

}

}

url：https://leetcode.com/problems/invert-binary-tree/

13、Number of 1 Bits

解题思路：32位有符号整数的表示范围：-2147483648—2147483647。32位无符号整数的表示范围：0—2147483647+2147483648。如果输入的无符号数大于2147483647，则会显示成负数，所以当输入数字小于0时，只需加上2147483647+1，之后按照整数求1的个数，此时需要将1的个数加1.

Java代码实现：

public class Solution {

// you need to treat nas an unsigned value

public inthammingWeight(int n) {

int count=0;

if(n==0) return 0;

if(n<0) {

System.out.print(n);

n+=2147483647+1;

System.out.print(n);

count++;

}

while(n!=0){

int mod=n%2;

if(mod==1)count++;

n=n/2;

}

return count;

}

}

url:https://leetcode.com/problems/number-of-1-bits/

14、Reverse Bits

解题思路：该题与上题类似，如果是负数首先转化成正数（+ 2147483647+1），再处理，然后变成2进制数（如果是负数最高位是1），翻转2进制数，变成十进制数，翻转后如果最后位是1，在十进制数基础上加上2147483647+1。

Java代码实现：

public class Solution {

// you need treat n as an unsigned value

public int reverseBits(int n) {

String str="";

if(n==0) return 0;

if(n==-2147483648) return 1;

System.out.println(n);

int m=n;

if(n<0) {

n+=2147483647+1;

//str+="1";

}System.out.println(n);

while(n!=0){

int mod=n%2;

if(mod==1) str="1"+str;

else str="0"+str;

n=n/2;

}

String revString="";

for(int j=str.length();j<32;j++){

str="0"+str;

}

if(m<0)str="1"+str.substring(1,str.length());

for(int i=0;i<STR.LENGTH();I++){

revString=str.charAt(i)+revString;

}

int num=0;

for(inti=revString.length()-1;i>0;i--){

num+=(Integer.valueOf(revString.charAt(i))-48)*(int)Math.pow(2,revString.length()-1-i);

}

if(revString.charAt(0)=="1") {

return2147483647+1+num;

}

return num;

}

}

url:https://leetcode.com/problems/reverse-bits/



版权声明：本文为博主原创文章，未经博主允许不得转载。