leetcode刷题第一天

最新推荐文章于 2024-06-08 12:47:51 发布

敲个大西瓜

最新推荐文章于 2024-06-08 12:47:51 发布

阅读量284

点赞数

CC 4.0 BY-SA版权

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

本文链接：https://blog.youkuaiyun.com/wangjunlei666/article/details/124793236

leetcode 专栏收录该内容

8 篇文章

订阅专栏

本文探讨如何使用两个栈实现队列，详细解析了`CQueue`类的`appendTail`和`deleteHead`方法。同时介绍了最小栈`MinStack`的实现，确保`min()`、`push()`和`pop()`操作的时间复杂度为O(1)。此外，还讲解了查找数组中重复元素的方法，以及如何通过贪心、动态规划和分治法解决最大子数组和问题。最后，展示了SQL查询技巧，如使用UNION查询和NOT IN操作符筛选数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.用两个栈实现队列

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

public class Main {

    public static void main(String[] args) {
      CQueue sta=new CQueue();
      sta.ApppendTail( 2 );
      sta.ApppendTail( 3 );
      sta.ApppendTail( 4 );
        System.out.println(sta.deleteHead());
        System.out.println(sta.deleteHead());
        System.out.println(sta.deleteHead());
    }
}

class CQueue {
   private Stack<Integer> inStack;
   private Stack<Integer> outStack;
    public CQueue() {
          inStack=new Stack<Integer>();
          outStack=new Stack<Integer>();
    }
    public void ApppendTail(int value){
        inStack.push( value );
    }
    public int deleteHead() {
           if(!outStack.isEmpty()){
               return outStack.pop();
           }else {
               while (!inStack.isEmpty()){
                   outStack.push( inStack.pop() );
               }
           }
           return !inStack.isEmpty()?-1:outStack.pop();
    }
}

补充：
isempty（）：判断栈是否为空，
peek（）：查看栈顶元素，
pop（）：返回栈顶元素，
push（）：在栈顶添加元素
search（）：返回对象在栈中的位置

包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.

public class Main {

    public static void main(String[] args) {
        MinStack sta=new MinStack();
        sta.push( 5 );
        sta.push( 6 );
        sta.push( 4 );
        System.out.println(sta.top());
        System.out.println(sta.min());
        sta.pop();
        System.out.println(sta.min());
        System.out.println(sta.top());

    }}

class MinStack{
    Stack<Integer> A,B;

    public MinStack() {
        A=new Stack<>();
        B=new Stack<>();
    }
    public void push(Integer value){
        A.push( value );
        if(B.isEmpty()||B.peek()>=value){
            B.push( value );
        }
    }
    public void pop(){
        if (A.pop().equals( B.peek() )){
            B.pop();
        }
    }
    public int top(){
       return A.peek();
    }
    public int min(){
        return B.peek();
    }
}

查找重复元素

给你一个整数数组 nums 。如果任一值在数组中出现至少两次，返回 true ；如果数组中每个元素互不相同，返回 false 。
解题思路：
1.排序，然后查找相邻元素是否相同，
2.使用hashset，一个一个投入，投入过程中判断是否已经存在

方法一
class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
}
方法二
class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int x : nums) {
            if (!set.add(x)) {
                return true;
            }
        }
        return false;
    }
}

补充：set的常用方法
add（）：添加元素
contains（）：查询是否包含该元素
remove（）：移除该元素
size（）：返回set中元素个数
toarray（）：返回一个包含set中所有元素的数组

贪心，动态规划，分治法实现最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组是数组中的一个连续部分。
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

贪心算法
-2，1，-3，4，-1，2，1，-5，4
当前值：
之前和：
当前和：
最大和：

class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        }
        int maxSubArray = nums[0];
        int sum = nums[0];
        for(int i = 1; i < nums.length; i++){
            //sum要想有资格继续壮大 就必须大于 0 否则还不如恢复0
            sum = Math.max(sum,0);
            sum += nums[i];
            //maxSubArray始终取最大值
            maxSubArray = Math.max(sum,maxSubArray);
        }
        return maxSubArray;
    }
}

动态qianyi规划
若前一个元素大于0，则将其加到当前元素上，最后取数组中最大的元素为结果
在这里插入图片描述


class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

分治法介绍
分治分治，即分而治之。分治，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，
分治法略难适当考虑要不要做，

public int toMaxSubarray(int []arr,int left,int right) {
	if(left >= right) {		  //递归出口
		return arr[left];
	}
	int mid = (left+right)/2;
	int leftMax = toMaxSubarray(arr, left, mid);			//左半段最大值
	int rightMax = toMaxSubarray(arr, mid+1, right);		//右半段最大值
	int mergeMax = addMaxSubarray(arr,left,mid,right);      //合并的最大值
	//返回三个数中最大的数
	return (leftMax=leftMax>rightMax?leftMax:rightMax)>mergeMax?leftMax:mergeMax; 
}
public int addMaxSubarray(int []arr,int left,int mid,int right) {
	int leftMax = (int) Double.NEGATIVE_INFINITY;
	int rightMax = (int) Double.NEGATIVE_INFINITY;
	for(int i = mid,sum = 0;i >= 0;i--) {	//左半边包含左半边右边元素的最大值
		sum = sum + arr[i];
		if(sum >= leftMax)
			leftMax = sum;
	}
	for(int j = mid+1,sum = 0;j <= right;j++) {
		sum = sum + arr[j];
		if(sum>rightMax)
			rightMax = sum;
	}
	int mergeMax = leftMax+rightMax;
	return mergeMax;
}

or,union查询

World 表：

+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| name        | varchar |
| continent   | varchar |
| area        | int     |
| population  | int     |
| gdp         | int     |
+-------------+---------+

name 是这张表的主键。
这张表的每一行提供：国家名称、所属大陆、面积、人口和 GDP 值。

如果一个国家满足下述两个条件之一，则认为该国是大国：

面积至少为 300 平方公里（即，3000000 km2），或者
人口至少为 2500 万（即 25000000）
编写一个 SQL 查询以报告大国的国家名称、人口和面积。

方法一：
SELECT
    name, population, area
FROM
    world
WHERE
    area >= 3000000

UNION

SELECT
    name, population, area
FROM
    world
WHERE
    population >= 25000000

方法二：
SELECT
    name, population, area
FROM
    world
WHERE
    area >= 3000000 OR population >= 25000000

这里注意联合查询之间的区别

使用 <> (!=) 和 IS NULL [Accepted]查询

给定表 customer ，里面保存了所有客户信息和他们的推荐人。

+------+------+-----------+
| id   | name | referee_id|
+------+------+-----------+
|    1 | Will |      NULL |
|    2 | Jane |      NULL |
|    3 | Alex |         2 |
|    4 | Bill |      NULL |
|    5 | Zack |         1 |
|    6 | Mark |         2 |
+------+------+-----------+

写一个查询语句，返回一个客户列表，列表中客户的推荐人的编号都不是 2。

SELECT name FROM customer WHERE referee_id <> 2 OR referee_id IS NULL;

mysql使用三值逻辑—true，false，unknown，任何与null值进行的比较都会与第三种值unknown做比较，这个任何值包括null本身，这就是为什么mysql提供is null，is not null两种操作对null特殊判断

not in查询

某网站包含两个表，Customers 表和 Orders 表。编写一个 SQL 查询，找出所有从不订购任何东西的客户。

Customers 表：

+----+-------+
| Id | Name  |
+----+-------+
| 1  | Joe   |
| 2  | Henry |
| 3  | Sam   |
| 4  | Max   |
+----+-------+
Orders 表：

+----+------------+
| Id | CustomerId |
+----+------------+
| 1  | 3          |
| 2  | 1          |
+----+------------+

select customers.name as 'Customers'
from customers
where customers.id not in
(
    select customerid from orders
);