Java练习题

全民简历推广：https://www.qmjianli.com/?tg=H7IHLKZG

---

两数之和

    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。
    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    你可以按任意顺序返回答案。
     
    示例 1：
    输入：nums = [2,7,11,15], target = 9
    输出：[0,1]
    解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
    示例 2：
    输入：nums = [3,2,4], target = 6
    输出：[1,2]
    示例 3：
    输入：nums = [3,3], target = 6
    输出：[0,1]
     
    提示：
    ▪ 2 <= nums.length <= 103
    ▪ -109 <= nums[i] <= 109
    ▪ -109 <= target <= 109
    ▪ 只会存在一个有效答案

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> cache = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int distance = target - nums[i];
            if (cache.containsKey(distance)) {
                return new int[] { cache.get(distance), i };
            } else {
                cache.put(nums[i], i);
            }
        }
        return new int[] {};
    }
}

数组排序

	编写一个JavaApplication程序,将随机生成的无序数组使用冒泡排序,将这个混乱的数组变成一个从小到大排列的有序的数组并输出。

class demo_sort {
    public static void main(String[] args) {
        int[] numbers = new int[] { 1, 5, 8, 2, 3, 9, 4 };
        for (int i = 0; i < numbers.length - 1; i++) {
            for (int j = 0; j < numbers.length - 1 - i; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for (int i = 0; i < numbers.length; i++)
            System.out.print(numbers[i] + " ");
    }
}

插入区间

    给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
    在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
     
    示例 1：
    输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
    输出：[[1,5],[6,9]]
    示例 2：
    输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
    输出：[[1,2],[3,10],[12,16]]
    解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
    示例 3：
    输入：intervals = [], newInterval = [5,7]
    输出：[[5,7]]
    示例 4：
    输入：intervals = [[1,5]], newInterval = [2,3]
    输出：[[1,5]]
    示例 5：
    输入：intervals = [[1,5]], newInterval = [2,7]
    输出：[[1,7]]
     
    提示：
    ▪ 0 <= intervals.length <= 104
    ▪ intervals[i].length == 2
    ▪ 0 <= intervals[i][0] <= intervals[i][1] <= 105
    ▪ intervals 根据 intervals[i][0] 按 升序 排列
    ▪ newInterval.length == 2
    ▪ 0 <= newInterval[0] <= newInterval[1] <= 105

public class Interval {
    int start;
    int end;
    Interval() {
        start = 0;
        end = 0;
    }
    Interval(int s, int e) {
        start = s;
        end = e;
    }
}
class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {
        int[][] newIntervals = new int[intervals.length + 1][];
        System.arraycopy(intervals, 0, newIntervals, 0, intervals.length);
        newIntervals[intervals.length] = newInterval;
        Arrays.sort(newIntervals, (a, b) -> a[0] - b[0]);
        Stack<int[]> stack = new Stack<>();
        for (int[] num : newIntervals) {
            if (stack.isEmpty()) {
                stack.push(num);
                continue;
            }
            int[] arr = stack.peek();
            if (arr[1] >= num[0]) {
                int[] combine = { arr[0], Math.max(arr[1], num[1]) };
                stack.pop();
                stack.push(combine);
            } else {
                stack.push(num);
            }
        }
        return stack.toArray(new int[0][]);
    }
}

删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
 
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
 
提示：
• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

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 {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode v = new ListNode(0, head);
        ListNode handle = v;
        List<ListNode> index = new ArrayList<>();
        while (v != null) {
            index.add(v);
            v = v.next;
        }
        int pre = index.size() - n - 1;
        int next = index.size() - n + 1;
        index.get(pre).next = next >= 0 && next < index.size() ? index.get(next) : null;
        return handle.next;
    }
}

两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
 
提示：
• 每个链表中的节点数在范围 [1, 100] 内
• 0 <= Node.val <= 9
• 题目数据保证列表表示的数字不含前导零

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 {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode lrr = l1;
        while (true) {
            l1.val = l1.val + l2.val;
            if (l1.next == null && l2.next == null && l1.val < 10) {
                break;
            }
            if (l1.next == null) {
                l1.next = new ListNode(0);
            }
            if (l2.next == null) {
                l2.next = new ListNode(0);
            }
            if (l1.val >= 10) {
                l1.val = l1.val - 10;
                l1.next.val += 1;
            }
            l1 = l1.next;
            l2 = l2.next;
        }
        return lrr;
    }
}

定义一个类Generator

定义一个类 Generator（生成器类），它可以在每次调用其 next()方法时，产生由你 最喜欢的电影（如 Snow White 或 Star Wars）的字符构成的名字（作为 String 对象）。在字 符列表中的电影名用完之后，循环到这个字符列表的开始处。使用这个生成器来填充数组、 ArrayList、LinkedList、HashSet，然后打印每一个容器。

import java.util.*;
public class MovieGenerator {
    private String[] movies = new String[] { "SS", "DD", "HH", "FF", "XX", "ZZ" };
    private int i = 0;
    public String next() {
        return movies[i++ % movies.length];
    }
    public String[] getMovies() {
        return movies;
    }
    public Collection<String> fill(Collection<String> collection) {
        for (int i = 0; i < 8; i++) {
            collection.add(next());
        }
        return collection;
    }
    public static void main(String[] args) {
        MovieGenerator generator = new MovieGenerator();
        System.out.println(Arrays.toString(generator.getMovies()));
        System.out.println(generator.fill(new ArrayList<String>()));
        System.out.println(generator.fill(new LinkedList<String>()));
        System.out.println(generator.fill(new HashSet<String>()));
    }
}