Leetcode刷题-(16~20)-Java+Python+JavaScript

news2024/9/24 3:27:35

 

算法是程序员的基本功，也是各个大厂必考察的重点，让我们一起坚持写算法题吧。

遇事不决，可问春风，春风不语，即是本心。

我们在我们能力范围内，做好我们该做的事，然后相信一切都事最好的安排就可以啦，慢慢来，会很快，向前走，别回头。

目录

1.最接近三数之和

2.电话号码的字母组合

3.四数之和

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

5.有效的括号

1.最接近三数之和

题目链接：. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/3sum-closest/description/

思路：1.三层循环暴力法。

2.排序+双指针。

Java版：
 

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        int min = Integer.MAX_VALUE ;
        int res = 0 ;
        for(int i=0; i<nums.length; i++){
            for(int j=i+1; j<nums.length; j++){
                for(int k=j+1; k<nums.length; k++){
                    int abs = Math.abs(target -(nums[i] + nums[j] + nums[k]) ) ;
                    if(abs < min){
                        min = abs ;
                        res = nums[i] + nums[j] + nums[k] ;
                    }
                }
            }
        }
        return res ;
    }
}
class Solution {
    public int threeSumClosest(int[] nums, int target) {
        // 排序+双指针
        Arrays.sort(nums) ;
        int res = 0 ;
        int min = Integer.MAX_VALUE ;
        for(int i=0; i<nums.length-1; i++){
            int left = i+1, right = nums.length - 1 ;
            while(left < right){
                int sum = nums[i] + nums[left] + nums[right] ;
                int abs = Math.abs(sum - target) ;
                if(abs < min){
                    min = abs ;
                    res = sum ;
                }
                if(sum == target){
                    return sum ;
                }else if(sum < target){
                    left ++ ;
                }else{
                    right -- ;
                }
            }
        }
        return res ;
    }
}

Python版：

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort() 
        l = len(nums)
        res = 0 
        min = 1000000
        for i in range(l-2):
            left = i+1
            right = l - 1
            while(left < right):
                sum = nums[i] + nums[left] + nums[right]
                sub = abs(sum - target)
                if(sub < min):
                   min = sub
                   res = sum 
                if (sum == target):
                   return sum 
                elif(sum < target):
                   left += 1
                else:
                   right -= 1
            
        return res

Javascript版：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var threeSumClosest = function(nums, target) {
    // JS需要自定义排序规则，因为默认情况是按照字符串进行排序，而不是数值
    nums.sort(function(a,b){
        return a - b
    }) 
    let res = 0 
    let min = 10000000
    for(let i=0; i<nums.length; i++){
        let left = i + 1, right = nums.length - 1
        while(left < right){
            const sum = nums[i] + nums[left] + nums[right] 
            const abs = Math.abs(sum - target)
            if(abs < min){
                min = abs
                res = sum 
            }
            if(sum == target){
                return sum
            }else if(sum > target){
                right -- 
            }else{
                left ++ 
            }
        }
    }
    return res 
};

2.电话号码的字母组合

题目链接：. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/
思路：方法1：条件函数判断+字符串拼接

方法2：hashmap+dfs

Java版：
 

class Solution {
    public List<String> letterCombinations(String digits) {
         List<String> list = new ArrayList<>() ;
         String str = "" ;
         String [] arr = new String[4] ;
         Arrays.fill(arr,"") ;
        for(int i=0; i<digits.length(); i++){
            arr[i] = f(digits.charAt(i)) ;
        }
                        
        for(int i=0; i<arr[0].length(); i++){
            if(arr[1].length()==0){
                 StringBuilder sb = new StringBuilder("") ;
                 sb.append(arr[0].charAt(i)) ;
                 list.add(sb.toString()) ;
            }
            for(int j=0; j<arr[1].length(); j++){
                   if(arr[2].length()==0){
                    StringBuilder sb = new StringBuilder("") ;
                    sb.append(arr[0].charAt(i))
                    .append(arr[1].charAt(j)) ;
                    list.add(sb.toString()) ;     
            }
                for(int k=0;  k<arr[2].length(); k++){
                    if(arr[3].length()==0){
                    StringBuilder sb = new StringBuilder("") ;
                    sb.append(arr[0].charAt(i))
                    .append(arr[1].charAt(j))
                    .append(arr[2].charAt(k)) ;
                    list.add(sb.toString()) ;
                    }
                    for(int l=0;  l<arr[3].length(); l++){
                        StringBuilder sb = new StringBuilder("") ;
                        sb.append(arr[0].charAt(i))
                         .append(arr[1].charAt(j))
                         .append(arr[2].charAt(k))
                         .append(arr[3].charAt(l)) ;
                         list.add(sb.toString()) ;
                    }
                }
            }
           
        }
        return list ;
    
}
public static String f(char c){
    switch(c){
        case '2': return "abc";
        case '3': return "def";
        case '4': return "ghi";
        case '5': return "jkl"; 
        case '6': return "mno";
        case '7': return "pqrs";
        case '8': return "tuv";
        case '9': return "wxyz";
        default : return "";
    }
}
}

class Solution {
    public List<String> letterCombinations(String digits) {
       
        List<String> list = new ArrayList<>() ;
        Map<Character,String> map = new HashMap<>() ;
         if(digits.length() == 0){
            return list ;
        }
        map.put('2',"abc") ;
        map.put('3',"def") ;
        map.put('4',"ghi") ;
        map.put('5',"jkl") ;
        map.put('6',"mno") ;
        map.put('7',"pqrs") ;
        map.put('8',"tuv") ;
        map.put('9',"wxyz") ;
        dfs(map,digits,0,list,new StringBuilder()) ;
        return list ;
}
public void dfs(Map<Character, String> map,String digits, int k, List<String> list, StringBuilder sb){
     
     if(k==digits.length()){
         list.add(sb.toString()) ;
     }else{
         String s = map.get(digits.charAt(k)) ;
         for(int i=0; i<s.length(); i++){
             sb.append(s.charAt(i)) ;
             dfs(map,digits,k+1,list,sb) ;
             sb.deleteCharAt(k) ;
         }
     }
}
}

Python版：

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        list = []
        d = {}
        if len(digits) == 0:
            return list
        d['2'] = "abc"
        d['3'] = "def"
        d['4'] = "ghi"
        d['5'] = "jkl"
        d['6'] = "mno"
        d['7'] = "pqrs"
        d['8'] = "tuv"
        d['9'] = "wxyz"
        self.dfs(list,d,0,"",digits)
        return list 

    def dfs(self, list, d, k, s,digits):
        if k == len(digits):
            list.append(s)
        else:
            tmp = d[digits[k]]
            for i in range(len(tmp)):
                s += tmp[i]
                self.dfs(list,d,k+1,s,digits)
                s = s[:k] + s[k+1:]
3.四数之和

题目链接：. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/4sum/description/
思路：方法1：四层循环

方法2：排序+双指针+三层循环

Java版：
超时版：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>() ;
        for(int i=0; i<nums.length; i++){
            for(int j=i+1; j<nums.length; j++){
                for(int k=j+1; k<nums.length; k++){
                    for(int l=k+1; l<nums.length; l++){
                        if(target == (nums[i] + nums[j] + nums[k] + nums[l])){
                            List<Integer> tmp = new ArrayList<>() ;
                            tmp.add(nums[i]) ;
                            tmp.add(nums[j]) ;
                            tmp.add(nums[k]) ;
                            tmp.add(nums[l]) ;
                            Collections.sort(tmp) ;
                            if(!res.contains(tmp)){
                                res.add(tmp) ;
                            }
                        }
                    }
                }
            }
        }
        return res ;
    }
}

击败5%的Java用户版：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>() ;
        Arrays.sort(nums) ;

        for(int i=0; i<nums.length; i++){
            for(int j=i+1; j<nums.length; j++){
                int left = j+1, right = nums.length - 1 ;
                while(left < right){
                    // 防止超出整型最大范围
                    long sum =  (long)nums[i] + (long)nums[j] + (long)nums[left] + (long)nums[right] ;
                    if(target == sum){
                        List<Integer> tmp = new ArrayList<>() ;
                        tmp.add(nums[i]) ;
                        tmp.add(nums[j]) ;
                        tmp.add(nums[left]) ;
                        tmp.add(nums[right]) ;
                        Collections.sort(tmp) ;
                        if(!res.contains(tmp)){
                            res.add(tmp) ;
                        }
                        right -- ;
                    }else if(target > sum){
                        left ++ ;
                    }else{
                        right -- ;
                    }

                }
            }
        }
        
        return res ;
    }
}

击败50%的Java选手：
 

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>() ;
        Arrays.sort(nums) ;

        for(int i=0; i<nums.length; i++){
            // 去重
            if(i>0 && nums[i] == nums[i-1]){
                continue ;
            }
            for(int j=i+1; j<nums.length; j++){
                // 去重
                if(j>i+1 && nums[j] == nums[j-1]){
                    continue ;
                }
                int left = j+1, right = nums.length - 1 ;
                while(left < right){
                    // 防止超出整型最大范围
                    long sum =  (long)nums[i] + (long)nums[j] + (long)nums[left] + (long)nums[right] ;
                    if(target == sum){
                        while(left < right && nums[left] == nums[left+1]){
                            left ++ ;
                        }
                        while(left < right && nums[right] == nums[right-1]){
                            right -- ;
                        }
                        List<Integer> tmp = new ArrayList<>() ;
                        tmp.add(nums[i]) ;
                        tmp.add(nums[j]) ;
                        tmp.add(nums[left]) ;
                        tmp.add(nums[right]) ;
                        res.add(tmp) ;
                        left ++ ;
                        right -- ;
                    }else if(target > sum){
                        left ++ ;
                    }else{
                        right -- ;
                    }

                }
            }
        }
        
        return res ;
    }
}

Python版：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        nums.sort()
        for i in range(0,len(nums)-2):
            if i>0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1,len(nums)-1):
                if j>i+1 and nums[j] == nums[j-1]:
                    continue
                left = j + 1
                right = len(nums) - 1
                while left < right:
                    sum = nums[i] + nums[j] + nums[left] + nums[right]
                    if(sum == target):
                        while(left < right and nums[left] == nums[left+1]):
                            left += 1
                        while(left < right and nums[right] == nums[right-1]):
                            right -= 1
                        res.append([nums[i],nums[j],nums[left],nums[right]])
                        left  += 1
                        right -= 1
                    elif(sum > target):
                        right -= 1
                    else:
                        left += 1
        return res

Js版：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[][]}
 */
var fourSum = function(nums, target) {
    nums.sort(function(a,b){
        return a - b 
    })
    const res = []
    for(let i=0; i<nums.length; i++){
        if(i>0 && nums[i] == nums[i-1]){
            continue 
        }
        for(let j=i+1; j<nums.length; j++){
            if(j>i+1 && nums[j] == nums[j-1]){
                continue
            }
            let left = j + 1, right = nums.length - 1
            while(left < right){
                const sum = nums[i] + nums[j] + nums[left] + nums[right] 
                if(sum === target){
                    while(left < right && nums[left] == nums[left+1]){
                      left ++
                }
                   while(left < right && nums[right] == nums[right-1]){
                      right -- 
                }
                    res.push([nums[i],nums[j],nums[left],nums[right]])
                    left ++ 
                    right --
                }else if(sum > target){
                    right -- 
                }else{
                    left ++ 
                }
            }
        }
    }
    return res 
};
4.删除链表的倒数第 N 个结点

题目链接：. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

思路：先计算链表长度，然后找到相应的结点位置，修改指针即可。

/**
 * Definition for singly-linked list.
 * 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) {
        // 找到倒数第n个节点，然后修改指针即可
        ListNode p = head ;

        int len = 0 ;
        while(p != null){
            len ++ ;
            p = p.next ;
        }

        if(n > len){
            return head ;
        }
        if(len==n){
            head = head.next ;
            return head ;
        }
        ListNode cur = head.next ;
        ListNode pre = head ;
        ListNode res = pre ;
        for(int i=0; i<len-n-1; i++){
            pre = pre.next ;
            cur = pre.next ;
        }

        pre.next = cur.next ;
        return res ;

    
    }
}

5.有效的括号

题目链接：. - 力扣（LeetCode）. - 备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。icon-default.png?t=N7T8https://leetcode.cn/problems/valid-parentheses/

思路：HashMap存储映射关系，栈模拟匹配括号匹配过程。

class Solution {
    public boolean isValid(String s) {
        Map<Character,Character> map = new HashMap<>() ;
        map.put('{','}') ;
        map.put('(',')') ;
        map.put('[',']') ;
        LinkedList<Character> stack = new LinkedList<>() ;
        for(int i=0; i<s.length(); i++){
            char c = s.charAt(i) ;
            if(c == '{' || c == '(' || c == '['){
                stack.push(c) ;
            }else{
                // 没有匹配的左括号，右括号多
                if(stack.isEmpty()){
                    return false ;
                }
                char top = stack.pop() ;
                if(s.charAt(i) != map.get(top)){
                    return false ;
                }
            }
        }
        // 栈不空，说明左括号多，没匹配
        if(stack.isEmpty() == false){
            return false ;
        }
        return true ;
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1488160.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

企业购物商城官网的作用举足轻重的发展前景分析

企业购物商城官网的作用举足轻重的发展前景分析

互联网时代&#xff0c;信息成为最重要的产品。 一个企业想要进入互联网&#xff0c;就需要一个平台来承载自己的信息。 官网作为企业的对外展示和宣传平台&#xff0c;发挥着重要的作用。 想要一个官方网站&#xff0c;首先要有一个响亮的域名。 中文域名不再是一个新兴产品。…
阅读更多...
数字化转型导师坚鹏：金融机构数字化运营

数字化转型导师坚鹏：金融机构数字化运营

金融机构数字化运营 课程背景&#xff1a; 很多金融机构存在以下问题&#xff1a; 不清楚数字化运营对金融机构发展有什么影响&#xff1f; 不知道如何提升金融机构数字化运营能力&#xff1f; 不知道金融机构如何开展数字化运营工作&#xff1f; 课程特色&#xff1a;…
阅读更多...
低代码中的可视化表单：效率与灵活兼备的设计工具

低代码中的可视化表单：效率与灵活兼备的设计工具

近年来&#xff0c;随着数字化转型的加速推进&#xff0c;企业对于高效率、灵活性和可定制性的软件开发需求不断增长。传统的软件开发过程通常需要耗费大量的时间和资源&#xff0c;而低代码开发平台的出现为企业提供了一种更加快速和灵活的解决方案。在低代码开发平台中&#…
阅读更多...
设计模式（十二）享元模式

设计模式（十二）享元模式

请直接看原文: 原文链接:设计模式&#xff08;十二&#xff09;享元模式-CSDN博客 -------------------------------------------------------------------------------------------------------------------------------- 享元模式定义 享元模式是结构型设计模式的一种&am…
阅读更多...
动态SQL的处理

动态SQL的处理

学习视频&#xff1a;3001 动态SQL中的元素_哔哩哔哩_bilibili 目录 1.1为什么学 1.2动态SQL中的元素 条件查询操作 if 元素 choose、when、otherwise元素 where、trim元素 更新操作 set元素使用场景 复杂查询操作 foreach 元素中的属性 ​编辑 迭代数组 迭代List 迭代Map 1…
阅读更多...
计算机设计大赛 深度学习疲劳检测 驾驶行为检测 - python opencv cnn

计算机设计大赛 深度学习疲劳检测 驾驶行为检测 - python opencv cnn

文章目录 0 前言1 课题背景2 相关技术2.1 Dlib人脸识别库2.2 疲劳检测算法2.3 YOLOV5算法 3 效果展示3.1 眨眼3.2 打哈欠3.3 使用手机检测3.4 抽烟检测3.5 喝水检测 4 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **基于深度学习加…
阅读更多...
网络架构与组网部署——补充

网络架构与组网部署——补充

5G网络架构的演进趋势 &#xff08;1&#xff09; MEC&#xff1a;多接入边缘计算。首先MEC可以实现5GC的功能&#xff0c;因为5GC是集中在机房中&#xff0c;所以当有MEC后&#xff0c;就可以把MEC下发到基站旁边&#xff0c;这样减少端到端的延时。便于实现5G中不同场景的实…
阅读更多...
基于 rk3566 的 uboot 分析 - dts 加载和 dm 模型的本质

基于 rk3566 的 uboot 分析 - dts 加载和 dm 模型的本质

文章目录 一、设备树加载使用1、概述2、第一阶段1) fdtdec_setup2) 总结 3、第二阶段1) kernle dtb 编译打包2) 加载流程2.1) board_init2.2) init_kernel_dtb2.3) rockchip_read_dtb_file2.4) rockchip_read_resource_dtb 3) 总结 二、dm 模型1、树的创建1) device_bind_commo…
阅读更多...
营业执照年报申报

营业执照年报申报

姿势&#xff1a;营业执照年报申报 借鉴文章&#xff1a;个体工商户年报申报流程&#xff08;不要再花冤枉钱&#xff09; 1、国家企业信用信息公示系统 地址&#xff1a;https://www.gsxt.gov.cn/index.html 2、登录&#xff08;重庆的方式二简单&#xff09;
阅读更多...
SpringBoot+Vue实现el-table表头筛选排序（附源码）

SpringBoot+Vue实现el-table表头筛选排序（附源码）

&#x1f468;‍&#x1f4bb;作者简介&#xff1a;在笑大学牲 &#x1f39f;️个人主页&#xff1a;无所谓^_^ ps&#xff1a;点赞是免费的&#xff0c;却可以让写博客的作者开心好几天&#x1f60e; 前言 后台系统对table组件的需求是最常见的&#xff0c;不过element-ui的el…
阅读更多...
SAP PP学习笔记05 - BOM配置（Customize）1 - 修正参数

SAP PP学习笔记05 - BOM配置（Customize）1 - 修正参数

上次学习了BOM相关的内容。 SAP PP学习笔记04 - BOM1 - BOM创建&#xff0c;用途&#xff0c;形式&#xff0c;默认值&#xff0c;群组BOM等_sap销售bom与生产bom-CSDN博客 SAP PP学习笔记04 - BOM2 -通过Serial来做简单的BOM变式配置&#xff0c;副明细&#xff0c;BOM状态&…
阅读更多...
禁用pycharm中解释器的-u选项

禁用pycharm中解释器的-u选项

用pycharm远程连接服务器跑代码的时候&#xff0c;想在配置中设置好入参&#xff0c;可以直接运行如下图。 但是运行之后发现总会在运行脚本前多出来一个参数选项‘-u’&#xff0c;不能被正确识别就走不下去。 ssh://rootxxxxx:22/usr/bin/python -m torch.distributed.laun…
阅读更多...
用边缘计算网关解决离散行业数采问题-天拓四方

用边缘计算网关解决离散行业数采问题-天拓四方

一、引言 随着工业4.0时代的来临&#xff0c;离散制造行业正面临数字化转型的关键节点。离散制造的特点是小批量、多品种、高复杂度&#xff0c;如何实现高效、精准的数据采集与分析&#xff0c;提升生产效率和产品质量&#xff0c;成为行业亟待解决的问题。边缘计算网关作为一…
阅读更多...
MySQL 逗号分隔查询--find_in_set()函数

MySQL 逗号分隔查询--find_in_set()函数

业务场景&#xff1a; 在使用MySQL的时候&#xff0c;可能的某个字段存储的是一个英文逗号分割的字符串&#xff08;这里我们不讨论表设计的合理性&#xff09;&#xff0c;如图所示&#xff1a; 我们在查询的时候需要匹配逗号分割中的某个字符串&#xff0c;该怎么查询呢&am…
阅读更多...
Python爬虫：爬虫基本概念和流程

Python爬虫：爬虫基本概念和流程

前言&#xff1a; 零基础学Python&#xff1a;Python从0到100最新最全教程。 想做这件事情很久了&#xff0c;这次我更新了自己所写过的所有博客&#xff0c;汇集成了Python从0到100&#xff0c;共一百节课&#xff0c;帮助大家一个月时间里从零基础到学习Python基础语法、Pyth…
阅读更多...
Sora爆火，数字人IP如何借助AIGC视频生成软件制作短视频营销？

Sora爆火，数字人IP如何借助AIGC视频生成软件制作短视频营销？

ChatGPT、Sora等大模型的出现&#xff0c;创新了短视频内容创作生产方式。但目前Sora模型无法准确模拟复杂场景的物理特性&#xff0c;并且可能无法理解因果关系导致视频失真。 广州虚拟动力基于用户使用需求&#xff0c;推出了AIGC数字人视频生成平台&#xff0c;企业、品牌可…
阅读更多...
Linux CentOS使用Docker部署Apache Superset并实现远程分析数据

Linux CentOS使用Docker部署Apache Superset并实现远程分析数据

文章目录 前言1. 使用Docker部署Apache Superset1.1 第一步安装docker 、docker compose1.2 克隆superset代码到本地并使用docker compose启动 2. 安装cpolar内网穿透&#xff0c;实现公网访问3. 设置固定连接公网地址 前言 Superset是一款由中国知名科技公司开源的“现代化的…
阅读更多...
GPT-4劲敌来袭！Mistral Large全球第二大模型重磅上线，你准备好体验了吗？

GPT-4劲敌来袭！Mistral Large全球第二大模型重磅上线，你准备好体验了吗？

近日&#xff0c;Mistral刚刚推出了一个新的大模型&#xff0c;叫做Mistral Large。 这个模型在全球的排名是第二&#xff0c;仅次于我们熟知的GPT-4&#xff0c;现在你可以通过API轻松访问到它。 Mistral Large是通过la Plateforme平台提供的&#xff0c;而且还在Azure上进行…
阅读更多...
sparse transformer 常见稀疏注意力

sparse transformer 常见稀疏注意力

参考&#xff1a; https://zhuanlan.zhihu.com/p/259591644 主要就是降低transformer自注意力模块的复杂度 复杂度主要就是 Q K^T影响的&#xff0c;稀疏注意力就是在Q点乘K的转置这模块做文章 下列式一些sparse transformer稀疏注意力方法 a、transformer原始的 &#xff0…
阅读更多...
OpenGL 实现色温、色调、亮度、对比度、饱和度、高光

OpenGL 实现色温、色调、亮度、对比度、饱和度、高光

1.简介 色温&#xff1a;简单理解是色彩的温度&#xff0c;越低越冷如蓝色&#xff0c;约高越暖如红色。 亮度&#xff1a;增加就是给图片所有色彩加白色&#xff0c;减少加黑色。注意是只加黑白两种颜色&#xff0c;不然容易跟纯度弄混。 对比度&#xff1a;增加就是让白的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023