leetcode刷题第二天

最新推荐文章于 2024-09-27 15:30:00 发布

敲个大西瓜

最新推荐文章于 2024-09-27 15:30:00 发布

阅读量912

点赞数

分类专栏： leetcode 文章标签： leetcode java 数据结构

本文链接：https://blog.csdn.net/wangjunlei666/article/details/124813633

版权

leetcode 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

计算特殊奖金

表: Employees

+-------------+---------+
| 列名        | 类型     |
+-------------+---------+
| employee_id | int     |
| name        | varchar |
| salary      | int     |
+-------------+---------+

employee_id 是这个表的主键。
此表的每一行给出了雇员id ，名字和薪水。
写出一个SQL 查询语句，计算每个雇员的奖金。如果一个雇员的id是奇数并且他的名字不是以’M’开头，那么他的奖金是他工资的100%，否则奖金为0。
Return the result table ordered by employee_id.
返回的结果集请按照employee_id排序。

方法一
# Write your MySQL query statement below
SELECT
    employee_id, 
CASE WHEN 
    MOD(employee_id, 2) = 1 AND name not rlike '^M' THEN salary ELSE 0 END AS bonus 
FROM
	Employees 
ORDER BY 
    employee_id;

方法二
select 
    employee_id,
    if (employee_id %2 = 1 and left(name,1)!='M', salary, 0) as bonus
from Employees

变更性别

Salary 表：

+-------------+----------+
| Column Name | Type     |
+-------------+----------+
| id          | int      |
| name        | varchar  |
| sex         | ENUM     |
| salary      | int      |
+-------------+----------+

id 是这个表的主键。
sex 这一列的值是 ENUM 类型，只能从 (‘m’, ‘f’) 中取。
本表包含公司雇员的信息。
请你编写一个 SQL 查询来交换所有的 ‘f’ 和 ‘m’ （即，将所有 ‘f’ 变为 ‘m’ ，反之亦然），仅使用单个 update 语句，且不产生中间临时表。

update Salary
set sex = if(sex="f","m","f")

删除重复的电子邮箱

表: Person

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| email       | varchar |
+-------------+---------+

id是该表的主键列。
该表的每一行包含一封电子邮件。电子邮件将不包含大写字母。
编写一个 SQL 删除语句来删除所有重复的电子邮件，只保留一个id最小的唯一电子邮件。以任意顺序返回结果表。（注意：仅需要写删除语句，将自动对剩余结果进行查询）

DELETE p1 
from Person p1 , Person p2
where p1.email=p2.email and p1.id>p2.id

解题思路：将此表与它自身在电子邮箱列中连接起来，然后需要找到其他记录中具有相同电子邮箱地址的更大的ID，

两数之和

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

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

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

public class Main {

    public static void main(String[] args) {
        solution so = new solution();
        int[] nums = {2, 7, 11, 15};
        int[] ab = so.max( nums, 9 );
        for (int x :
                ab) {
            System.out.println( x );
        }
    }
}
class solution{
    public int[] max(int[] nums,int target){
        Map<Integer,Integer> hash=new Hashtable<>(  );
        for (int i=0;i<nums.length;i++){
            if (hash.containsKey( target-nums[i])){
                return new int[]{hash.get( target-nums[i] ),i};
            }
            hash.put( nums[i],i );
        }
        return new int[0];
    }
    }

合并两个有序数组

给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

方法一
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}
//为了利用这一性质，我们可以使用双指针方法。这一方法将两个数组看作队列，每次从两个数组头部取出比较小的数字放到结果中
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;
        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];
            } else if (p2 == n) {
                cur = nums1[p1++];
            } else if (nums1[p1] < nums2[p2]) {
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;
        }
        for (int i = 0; i != m + n; ++i) {
            nums1[i] = sorted[i];
        }
    }
}

从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

class Solution {
    public ListNode reverseList(ListNode head) {
       return recur(ListNode head,null); //调用递归并返回
    }
    private ListNode recur(ListNode cur,ListNode pre){
        if (cur==null){ //终止条件
            return pre;
        }
        ListNode res=recur( cur.next,cur ); //递归后继节点
        cur.next=pre; //修改节点引用指向
        return res; //返回反转链表的头
    }

复杂链表的复制

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
示例 1：
在这里插入图片描述
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

//疯狂递归
class Solution {
    Map<Node,Node> cacheNode=new HashMap<>(  );
    public Node copyRandomList(Node head) {
        if (head==null) {
        return null;
        }
        if (!cacheNode.containsKey( head )){
            Node headNew=new Node( head.val );
                cacheNode.put( head,headNew );
                headNew.next=copyRandomList( head.next );
                headNew.random=copyRandomList( head.random );
        }
        return cacheNode.get(head);
    }
}

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

class Solution {
    public int search(int[] nums, int target) {
        int low=0,high=nums.length-1;
        while (low<=high){
            int mid=(high-low)/2+low;
            int num=nums[mid];
            if(num==target){
                return mid;
            }else if(num>target){
                high=mid-1;
            }else {
                low=mid+1;
            }
        }
        return -1;
    }
}

搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
这题还多了个额外的条件，即如果不存在数组中的时候需要返回按顺序插入的位置，

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0, right = n - 1, ans = n;
        while (left <= right) {
            int mid = ((right - left) >> 1) + left;
            if (target <= nums[mid]) {
                ans = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
}