欢乐写数字项目Android项目 欢乐抓数字

202、快乐数

 法一：快慢指针

class Solution {
    public boolean isHappy(int n) {
        int slow=n;
        int fast=getNext(n);
        while(fast!=1&&slow!=fast){
            slow=getNext(slow);
            fast=getNext(getNext(fast));
        }
        return fast==1;
    }

    public int getNext(int n){
        int sum=0;
        while(n>0){
            int unit=n%10;//求出个位数  
            n=n/10;//求出个位数后，直接扔掉
            sum=sum+unit*unit;
        }
        return sum;
        /*
        unit:   116%10=6  
        n:      116/10=11 
        sum:    0+6*6=36

        unit:   11%10=1
        n:      11/10=1
        sum:    36+1*1=37

        unit:   1%10=1
        n:      1/10=0
        sum:    37+1*1=38  
        */
    }
       
}

法二：set集合

思路引导：既然欢乐数最后会变成1，那不是欢乐数一直循环，那么肯定会有停止的条件，来返回它不是欢乐数，所以经过多个数的举例，发现一个数不是欢乐数，那么在每次求出平方和的过程会出现重复的数。

审题：题目中说了会 无限循环——要引起数学规律上的思考，那么也就是说求和的过程中，sum会重复出现。即：一个数如果不是快乐数，那么他就会重复出现sum（2这个数：2—4—16—37—58—89—148—81—65—61—37）

//无限循环,就说明会添加到重复的sum，但是不会是快乐数

 //如果是快乐数，那么在最后，sum一定会变成1

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while(n != 1 && !set.contains(n)){
            //无限循环,就说明会添加到重复的sum，但是不会是快乐数
            //如果是快乐数，那么在最后，sum一定会变成1
            set.add(n);
            n=getNext(n);
        }
        return n==1;//如果是快乐数，那么在最后，sum一定会变成1
    }

    //获取该数的每个位置上的数字的平方和——sum
    public int getNext(int n){
        int sum=0;
        while(n>0){
            int unit=n%10;//求出个位数  
            sum=sum+unit*unit;
            n=n/10;//求出个位数后，直接扔掉
        }
        return sum;
        /*
        unit:   116%10=6
        sum:    0+6*6=36 
        n:      116/10=11 
        
        unit:   11%10=1
        sum:    36+1*1=37
        n:      11/10=1
        
        unit:   1%10=1
        sum:    37+1*1=38  
        n:      1/10=0
       
        */
    }
       
}

203、移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

 添加，删除是需要依靠前面的结点来进行添加和删除的。所以我们要创建空节点（不存放任何东西的结点）为第一个结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    //由于链表的头节点有可能需要被删除,因此创建临时空节点在head前面.
    //链表的增删都是：空节点为第一个结点
    public ListNode removeElements(ListNode head, int val) {
        if(head==null) return head;
        ListNode head1=new ListNode();//创建没有任何信息的结点为第一结点
        head1.next=head;
        ListNode temp=head1;//临时结点
        while(temp.next!=null){
            if(temp.next.val==val){
                temp.next=temp.next.next;
            }else{
                temp=temp.next;
            }
        }
        return head1.next;
    }
}

217、存在重复元素 

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

 法一：排序后暴击解法

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        int len=nums.length;
        int count=1;
        for(int i=0;i<len-1;i++){
            if(nums[i]==nums[i+1]){
                count++;
            }
        }
        if(count>=2){
            return true;
        }else{
            return false;
        }
    }
}

法二：利用set无重复元素的特点进行求解、（也可以使用Map）

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set=new HashSet<>();
        for(int i:nums){
            if(!set.add(i)){//包含重复元素的话，输出true
                return true;
            }
        }
        return false;
    }
}