经典面试题 （二） 最长和谐子序列 Kaki的博客

经典面试题 （二） 最长和谐子序列 Kaki的博客

⚫ 问题描述：
    和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是 1。现给定一个整数数组 nums，请在所有可能的子序列中找到最长的和谐子序列的长度
并输出最长的和谐子序列。数组的子序列是一个由数组派生出来的序列，它可以
通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。
⚫ 要求：

    完成题目对应的程序模板（HarmoniouslySequence）中的方法：
    int maxHarmoniouslySequence(int[] nums);
    该方法的入口参数 nums 为给定的整数数组;
    方法返回值为满足要求的最大和谐子序列的长度。

⚫ 样例：

    ◼ 样例 1
    输入：nums = [1,3,2,2,5,2,3,7]
    输出：5
    解释：最长的和谐子序列是 [3,2,2,2,3]，所以输出该和谐子序列的长度为 5

    ◼ 样例 2
    输入：nums = [1,1,1,1]
    输出：0
    解释：给定的数组中不存在和谐子序列，所以输出结果为 0

解答：

package com.kaki.test;

import java.util.*;

/**
 * @author Kaki Nakajima
 * @date   2020-05-15
 * @desc   最长和谐子序列
 */
public class HarmoniouslySequence {

    /**
     * 最长和谐子序列
     * @param nums
     * @return
     */
    public static int maxHarmoniouslySequence(int[] nums){

        //序列 计数器
        int count=0;

        //第一步对数组进行排序
        for (int i = 0; i < nums.length; i++) {
            int oneElement = nums[i];
            for (int j = 0; j < nums.length-1; j++) {
                int twoElement = nums[j];
                if(oneElement>=twoElement){
                    int temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] =temp;
                }
            }
        }
        System.out.println("第一步 排序："+Arrays.toString(nums));

        //第二步 统计每个数字出现的次数
        HashMap<String, Object> countMap = new HashMap<String, Object>();
        for (int i : nums) {
            if((countMap.get(i+"")) == null){
                countMap.put(i+"",1);
            }else {
                countMap.put(i+"",((Integer) countMap.get(i+""))+1);
            }
        }
        System.out.println("第二步 计数："+ countMap);

        //统计相邻数字的最大值
        Set<Map.Entry<String, Object>> entries = countMap.entrySet();
        ArrayList tempArray = new ArrayList<Integer>();
        for (Map.Entry<String, Object> entry : entries) {
            HashMap hashMap = new HashMap();
            hashMap.put(entry.getKey(), entry.getValue());
            tempArray.add(hashMap);
        }

        //迭代数组进行比较
        for (int i = 0; i < tempArray.size(); i++) {

            for (int j = 1; j < tempArray.size()-1; j++) {
                Map<String,Object> mapi = (Map<String,Object>) tempArray.get(i);
                Map<String,Object> mapj = (Map<String,Object>) tempArray.get(j);
                Set<Map.Entry<String, Object>> entriesi = mapi.entrySet();
                Set<Map.Entry<String, Object>> entriesj = mapj.entrySet();

                int i_key = 0;
                int i_value = 0;
                int j_key = 0;
                int j_value = 0;
                for (Map.Entry<String, Object> entryi : entriesi) {
                    i_key = Integer.valueOf(entryi.getKey()) ;
                    i_value = (Integer)entryi.getValue();
                }

                for (Map.Entry<String, Object> entryj : entriesj) {
                    j_key = Integer.valueOf(entryj.getKey()) ;
                    j_value =(Integer)entryj.getValue();
                }

                //相邻数据
                if(j_key - i_key == 1){
                     if(j_value + i_value > count){
                         count = j_value + i_value;
                     }
                }
            }
        }

        System.out.println("第三步 比较结果，返回最大长度："+count);
        return count;
    }

    public static void main(String[] args) {
        int [] arr = {1,1,2,2,5,2,3,7};
        maxHarmoniouslySequence(arr);
    }
}

此处方法只是实现之一，如有更高效的方法可以在评论区留言哈~

码云地址直通车

欢迎码云，B站，ins 关注Kaki Nakajima