Cloudyun

Yann Cheungの博客

Posted on Edited on In Word count in article: 4.5k Reading time ≈ 4 mins.

一、完美对

有 n n个物品，每个物品有 k k个属性，第 i i件物品的第 j j个属性用一个正整数表示记为ai,ja**i,j，两个不同的物品 i,j i,j被称为是完美对的当且仅当ai,1+aj,1=ai,2+aj,2=⋯=ai,k+aj,ka**i,1+a**j,1=a**i,2+a**j,2=⋯=a**i,k+a**j,k，求完美对的个数。

输入例子：

1
2
3
4
5
6
5 3
2 11 21
19 10 1
20 11 1
6 15 24
18 27 36

输出例子：

1
3
Read more »

Posted on Edited on In Word count in article: 6.3k Reading time ≈ 6 mins.

一、IO流简介

数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出

IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

  • InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
  • OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
Read more »

Posted on Edited on In Word count in article: 5.7k Reading time ≈ 5 mins.

一、集合概览

整体框架：

1、说说 List, Set, Queue, Map 四者的区别？

  • List(对付顺序的好帮手): 存储的元素是有序的、可重复的。
  • Set(注重独一无二的性质): 存储的元素是无序的、不可重复的。
  • Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。
  • Map(用 key 来搜索的专家): 使用键值对（key-value）存储，类似于数学上的函数 y=f(x)，”x” 代表 key，”y” 代表 value，key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。
Read more »

Posted on In Word count in article: 14k Reading time ≈ 12 mins.

一、前言

最近看了一遍JavaGuide网站上的八股文，觉得还是有必要记录一些需要记忆的重要内容～

本章节是对个人觉得很重要的——Java基础部分常见面试题的记录，也可以说是JavaGuide的个人浓缩版。不过学习、理解记忆还是推荐去看原网站，讲解比较细致。

JavaGuide官网：https://javaguide.cn/java/basis/java-basic-questions-01.html

二、基本概念与常识

1、Java 语言有哪些特点?

  1. 面向对象（封装，继承，多态）；
  2. 平台无关性（ Java 虚拟机实现平台无关性）；
  3. 支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
  4. 可靠性、安全性；
  5. 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；
  6. 编译与解释并存；
Read more »

Posted on Edited on In Word count in article: 94k Reading time ≈ 1:26

一、链表

BM1 反转链表

描述

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤10000≤n≤1000

要求：空间复杂度 O(1)，时间复杂度 O(n)。

思路：迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while(curr != null){
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}
Read more »

Posted on Edited on In Word count in article: 10k Reading time ≈ 9 mins.

剑指 Offer 09. 用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

思路：两个栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class CQueue {
    LinkedList<Integer> A,B;
    public CQueue() {
        A = new LinkedList<Integer>();
        B = new LinkedList<Integer>();
    }
    
    public void appendTail(int value) {
        A.addLast(value);
    }
    
    public int deleteHead() {
        if(!B.isEmpty()){
            return B.removeLast();
        }else if(A.isEmpty()){
            return -1;
        }
        while(!A.isEmpty()){
            B.addLast(A.removeLast());
        }
        return B.removeLast();
    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */
Read more »

Posted on Edited on In Word count in article: 1.2k Reading time ≈ 1 mins.

前言

12月份每日一题记录~

1805. 字符串中不同整数的数目

给你一个字符串 word ，该字符串由数字和小写英文字母组成。

请你用空格替换每个不是数字的字符。例如，”a123bc34d8ef34” 将会变成 “ 123 34 8 34” 。注意，剩下的这些整数为（相邻彼此至少有一个空格隔开）：”123”、”34”、”8” 和 “34” 。

返回对 word 完成替换后形成的 不同 整数的数目。

只有当两个整数的 不含前导零 的十进制表示不同， 才认为这两个整数也不同。

1
2
3
输入：word = "a123bc34d8ef34"
输出：3
解释：不同的整数有 "123"、"34" 和 "8" 。注意，"34" 只计数一次。
Read more »

Posted on Edited on In Word count in article: 10k Reading time ≈ 9 mins.

前言

leetcode恢复刷题，十月底之前尽量完成这部分…该部分只简单记录部分关键思路以及代码，帮助回顾～

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

思路：HashMap

由于还需要返回数组下标，所以存的时候肯定还要存数组下标，那就需要存一个键值对。这种情况直接考虑HashMap～

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i = 0 ; i < nums.length ; i++){
            if(map.containsKey(target - nums[i])){
                int j = map.get(target - nums[i]);
                return new int[]{i,j};
            }
            map.put(nums[i],i);
        }
        return new int[]{};
    }
}
Read more »

Posted on Edited on In Word count in article: 20k Reading time ≈ 18 mins.

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

1
2
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

思路1：集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<Integer>();
        Set<Integer> set2 = new HashSet<Integer>();
        for(int num : nums1){
            set1.add(num);
        }
        for(int num: nums2){
            set2.add(num);
        }
        return getIntersection(set1,set2);
    }

    public int[] getIntersection(Set<Integer> set1,Set<Integer> set2){
        if(set1.size() > set2.size()){
            return getIntersection(set2,set1);
        }
        Set<Integer> intersectionSet = new HashSet<Integer>();
        for(int num : set1){
            if(set2.contains(num)){
                intersectionSet.add(num);
            }
        }
        int[] intersection = new int[intersectionSet.size()];
        int index = 0 ;
        for(int num : intersectionSet){
            intersection[index++] = num; 
        }
        return intersection;
    }
}
  • 时间复杂度：O(m+n)
  • 空间复杂度：O(m+n)
Read more »

Posted on Edited on In Word count in article: 331 Reading time ≈ 1 mins.

枚举

枚举类型的特点

  • 值是有限的值
  • 只读，必须要修改

因此，我们可以理解：

  • 枚举是一组常量的集合。
  • 枚举属于一种特殊的类，里面只包含一组有限的特定的对象。
Read more »