algorism

已于 2023-02-18 16:58:07 修改
阅读量107 收藏
点赞数
分类专栏： 技术自学笔记博客 文章标签： 算法 java 数据结构 学习 leetcode
于 2023-02-18 16:54:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsp522/article/details/129102027
版权

顺序查找

分治算法

回溯、分治、和动态规划算法可以规划为一类，都会涉及到递归。

动态规划是一类算法问题，

动态规划

递归求x的n次方

package Temp;

import java.util.Scanner;

/*
 * @Author: jun
 * @Date:2023/1/30 0:03
 * @概述：
 */
public class niuke004 {
    //求x的n次方

     static int function01(int x, int n){
        int result = 1;//把结果赋值为1是为了表示所有的数的0次方都是1
        for (int i = 0; i < n; i++) {//循环n次中每次的result都是取了n-1次方的结果
            result = result * x;
        }
        return result;//返回x的n次方
    }

    static int recursive(int x, int n){
         if (n == 0){
             return 1;
         }
         return x*recursive(x,n-1);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //使用普通的for循环计算x的n次方结果
        System.out.println("使用普通的for循环计算x的n次方结果");
        System.out.println("输入x的值：");
        int x = scanner.nextInt();
        System.out.println("输入n的值：");
        int n = scanner.nextInt();

        long start = System.nanoTime();
        System.out.println("result="+function01(x,n));
        long end = System.nanoTime();
        System.out.println("时间消耗"+(end-start));
        System.out.println("_________________");

        //使用递归的算法解决该题
        System.out.println("使用递归的算法解决该题");
        long start02 = System.nanoTime();
        System.out.println("recursive result="+recursive(x,n));
        long end02 = System.nanoTime();
        System.out.println("时间消耗"+(end02-start02));

    }

}

有序数组的平方排列

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 8:32
 * @概述：
 */
public class niuke005 {

    //有序数组的平方排列
    static class solution{
        public int[] sortSquares(int[] nums){
            int right = nums.length-1;//定义右指针
            int left = 0;//定义左指针
            int[] result = new int[nums.length];//新建一个数组用于返回排序后结果，并且大小等于原需排列的数组
            int index = result.length-1;//给新建的数组也定义一个指针，让它从最后一位开始移动，返回比较后的较大值
            while(left<=right){//常规的双指针的条件就是左指针与右指针交错
                //每次比较是用平方后的值来比较
                if (nums[left]*nums[left] > nums[right]*nums[right]){
                    //将大的left添入新数组的右边，
                    result[index--] = nums[left]*nums[left];
                    ++left;//将原数组比较的左指针右移，right不变
                } else {
                    //相反的
                    result[index--] = nums[right]*nums[right];
                    --right;
                }
            }


            return result;
        }
    }

    public static void main(String[] args) {

        int[] arr = {-1,2,3,5,8,17};
        solution solution = new solution();
        int[] ints = solution.sortSquares(arr);
        for (int i:ints
             ) {
            System.out.println(i);
        }
    }

}

前n项和的时间复杂度

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 9:01
 * @概述：
 */
public class temp006 {

    //前n项和的时间复杂度
    //1+2+3+···+100
    static int solution01(int n){
        int sum = 0;
        while(n>0){
            sum+=n;
            n--;
        }
        return sum;
    }

    //设计时间复杂度为O(1)的算法
    static int solution02(int n){
        return n*(n+1)/2;
    }

    //解法三


    public static void main(String[] args){
        long stime = System.nanoTime();
        System.out.println(solution01(100));
        long etime = System.nanoTime();

        long time01 = System.nanoTime();
        System.out.println(solution02(100));
        long time02 = System.nanoTime();

        System.out.println(etime-stime);
        System.out.println(time02-time01);
    }
}

两个数组的交集

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 13:24
 * @概述：
 */

import java.util.HashSet;

/**
 * 两个数组的交集
 * 题意：给定两个数组，编写一个函数来计算它们的交集
 */
public class temp008 {
    public static int[] intersection(int[] nums1,int[] nums2){
        //首先判断这两个数组是否是空的，如果有一方是空的就直接放回一个空数组
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        //新建两个hashset
        HashSet<Object> set1 = new HashSet<>();
        HashSet<Object> resSet = new HashSet<>();
        //遍历数组set1
        for (int i:nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表set1中是否存在该元素
        for ( int i:nums2){
            if (set1.contains(i)){
                resSet.add(i);
            }
        }
        return resSet.stream().mapToInt(x -> (int) x).toArray();
    }

    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,5};
        int[] arr2 = {1,5};

        for (int i: intersection(arr1,arr2)
             ) {
            System.out.println(i);
        }
    }
}

快乐数

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 13:40
 * @概述：
 */

import java.util.HashSet;
import java.util.Set;

/**
 * 快乐数
 * 编写一个算法来判断一个数是否是快乐数
 * 快乐数的定义：对于一个正整数，
 * 每一次将该数替换为它每一个位置上的数字的平方和，
 * 然后重复这个过程直到这个数变为一，也可能是无限循环
 * 但最终变不到一，如果可以变为一，那么这个数就是快乐数。
 */
public class temp009 {


    //获取每位数
    static int getNextNumber(int n){
        int res = 0;//返回值
        while(n>0){
            int temp = n%10;//取得一位数
            res += temp*temp;//每位数都要进行平方求其值
            n = n / 10;//相当于末尾位取出
            System.out.println(temp);
        }
        return res;
    }

    public static void main(String[] args) {
        getNextNumber(113);

        int n = 123;
        Set<Integer> record = new HashSet<>();
        while(n!=1&&!record.contains(n)){
            record.add(n);
            n = getNextNumber(n);
        }
        System.out.println(n);
    }
}

两数之和

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 16:15
 * @概述：
 */

import java.util.HashMap;

/**
 * 两数之和
 *
 */
public class temp010 {

    static int[] twoSum(int[] nums,int target){
        int[] res = new int[2];//返回值为一个两个空间大小的数组
        if (nums == null || nums.length == 0){
            return res;
        }
        HashMap<Integer, Integer> map = new HashMap<>();//新建一个哈希表，键和值都是整型
        for (int i = 0; i < nums.length; i++) {
            int temp = target - nums[i];//遍历当前元素，并在map中寻找是否有匹配的数
            if(map.containsKey(temp)){
                res[1] = i;
                res[0] = map.get(temp);
                break;
            }
            map.put(nums[i],i);//每次循环都把遍历过的数放进map
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int target = 10;
        int[] ints = twoSum(arr, target);
        for (int i :
                ints) {
            System.out.println(i);
        }
    }
}

四数相加

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 16:47
 * @概述：
 */

import java.util.HashMap;
import java.util.Map;

/**
 * 四数相加
 * 给定四个包含整数的数组列表A，B，C，D，计算有多少个元组（i,j,k,l),
 * 使A[i]+B[j]+C[k]+D[I]=0
 */
public class temp011 {
    static int fourSumCount(int[] nums1,int[] nums2,int[] nums3,int[] nums4){
        Map<Integer,Integer> map = new HashMap<>();
        int temp;
        int res = 0;
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for (int i:nums1){
            for (int j :
                    nums2) {
                temp = j + i;
                if (map.containsKey(temp)){
                    map.put(temp,map.get(temp)+1);
                }else{
                    map.put(temp,1);
                }
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i :
                nums3) {
            for (int j :
                    nums4) {
                temp = i + j;
                if (map.containsKey(0-temp)){
                    res += map.get(0 - temp);
                }
            }
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr1 = {-1,2,3,4};
        int[] arr2 = {1,-2,3,4};
        int[] arr3 = {1,2,-3,4};
        int[] arr4 = {1,2,3,-4};

        int i = fourSumCount(arr1, arr2, arr3, arr4);

        System.out.println(i);//i个元组

    }
}

三数之和

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/17 17:30
 * @概述：
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 三数之和
 * 给定一个包含n个整数的数组nums，判断nums中是否存在三个元素a,b,c,使得a+b+c=0
 * 需要找出不可以重复的三元组。
 *
 * 总共三个数：i,left,right
 * i是nums里遍历的元素，重复了的话就直接跳过去
 * 虽然不能有重复的三元组，但三元组内的元素是可以重复
 *
 * left与right的去重
 */
public class temp012 {

    static List<List<Integer>> threeSum(int[] nums){
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);//将数组排序
        //求a + b + c = 0;
        //a = nums[i],b = nums[left], c = nums[right]
        for (int i = 0; i < nums.length; i++) {
            //排序之后如果第一个元素大于零，则说明无论如何组合都不可能三个数和为0
            if (nums[i]>0){
                return result;
            }

            if (i > 0 &&nums[i] == nums[i-1]){
                continue;//去重a
            }

            int left = i+1;//左指针起始位置
            int right = nums.length-1;//右指针至于最右侧
            while(right>left){
                int sum = nums[i] + nums[left] + nums[right];
                if (sum>0){
                    right--;
                }else if (sum < 0){
                    left++;
                }else{
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    //去重逻辑应该放在找到一个三元组之后，对b和c去重
                    while(right>left&&nums[right] == nums[right-1])right--;
                    while(right>left&&nums[right] == nums[left+1])left--;

                    right--;
                    left++;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] arr = {-1,0,1,2,-1,-4};

        List<List<Integer>> lists = threeSum(arr);
        System.out.println(lists);
    }
}

反转字符串

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/18 10:19
 * @概述：
 */

/**
 * 反转字符串
 * 编写一个函数，作用是将输入的字符串反转过来，输入字符串以字符数组char[]的形式给出
 * 要求是不使用额外的数组分配空间，你必须原地修改数组
 *
 */
public class temp013 {

    static char[] reverseString(char[] s){
        int l = 0;
        int r = s.length - 1;
        while(l<r){
            s[l] ^= s[r];//构造a^b,并放在a中
            s[r] ^= s[l];//将a^b 这一结果再^b,此时b = a,a = a^b
            s[l] ^= s[r];//a^b的结果再^a,存入a中，此时b = a,a=b
            //完成交换后移动两个指针
            l++;//左指针右移
            r--;//右指针左移
        }
        return s;
    }

    public static void main(String[] args) {
        char[] arr = {'A','B','C','D'};
        char[] chars = reverseString(arr);
        System.out.println(chars);
    }
}

反转字符串II

package Temp;

/*
 * @Author: jun
 * @Date:2023/2/18 10:50
 * @概述：
 */

/**
 * 反转字符串II
 * 给定一个字符串s和一个整数k，从字符串开头算起，每计数至2k个字符，就反转这2k个字符中的前k个字符
 * 如果剩余字符小于k个，则将剩余字符全部反转
 * 如果剩余字符小于2k但大于或等于k个，则反转前k个字符，其余字符保持原样。
 */
public class temp014 {

    static String reverseStr(String s,int k){
        StringBuffer res = new StringBuffer();
        int length = s.length();
        int start = 0;
        while(start < length){
            //找到每次需要反转得中点k，还有末尾2k
            StringBuffer temp = new StringBuffer();//新建一个可变字符串stringBuffer
            //与length进行判断，如果大于length了，那就将其置为length
            int firstK = (start + k >length)?length : start+k;
            int secondK = (start + (2*k)>length)?length : start +(2*k);

            //无论start所处的位置，至少会反转一次
            temp.append(s.substring(start,firstK));//获取从start到firstK的字符
            res.append(temp.reverse());//使用stringBuffer自带的反转方法反转

            //如果firstK到secondK之间有元素，这些元素直接放入res里即可
            if (firstK < secondK){
                res.append(s.substring(firstK,secondK));
            }
            start += (2*k);//当length足够时，更改start的位置为2k

        }
        return res.toString();
    }

    public static void main(String[] args) {
        int target = 6;
        String chars = "adadsfdsvfbsbsrtgbr";
        String s = reverseStr(chars, target);
        System.out.println(s);
    }
}

代码优质自学平台：代码随想录

LSP522
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Algorism-practice:实践算法
04-02
"Algorism-practice"项目就是这样一个平台，它鼓励用户每天面对一个算法问题，通过实践来提升自己的算法能力。 在Python中，我们可以通过多种方式实现算法。例如，使用内置的数据结构如列表、字典和集合，以及模块...
Algorism
a19576的专栏
07-20 372
二分图的最大匹配、完美匹配和匈牙利算法
SolvePnP OpenCV algorism
boyhoodme的博客
04-18 230
SolvePnP OpenCV algorism link
Peterson‘s Algorism皮特森算法详解
肥叔菌的博客
05-21 670
Peterson算法是实现进程互斥访问临界区的一种方法，避免了单标志法必须交替访问的限制，以及双标志法后检验的“饥饿”问题。 Pi进程: flag[i] = TRUE; turn = j; while(flag[j] && turn == j); // 访问临界区 flag[i] = FALSE; // 剩余区 Pj进程: flag[j] = TRUE; turn = i; while(flag[i] && turn == i); // 访问临界区 flag[j] = FA
peterson算法p0流程图_Peterson's Algorism皮特森算法详解
weixin_36319237的博客
01-17 942
Peterson算法是实现进程互斥访问临界区的一种方法，避免了单标志法必须交替访问的限制，以及双标志法后检验的“饥饿”问题。Peterson算法实现如下：Pi进程:flag[i] = TRUE; turn = j;while(flag[j] && turn == j);// 访问临界区flag[i] = FALSE;// 剩余区Pj进程:flag[j] = TRUE; turn =...
generic algorism.pdf
08-05
【遗传算法的概念与设计】 遗传算法（Genetic Algorithm, GA）是一种模拟自然选择和生物进化过程的搜索启发式算法。这种算法的核心理念是通过模仿生物进化中的遗传、突变、选择等机制，来优化问题的解决方案。...
八数码 算法流程图.vsdx
07-08
八数码问题 算法流程图 visio2016的vsdx流程图文件 算法学习
算法-KMP字符串匹配
xx_xb的博客
07-23 230
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 878
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 277
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
【常微分方程】
qq_74285286的博客
07-24 300
常微分方程笔记
AtCoder Beginner Contest 363(A~D题)
sin1810335764的博客
07-23 220
枚举长度，首先计算出答案回文数的长度。通过枚举和减法可以计算出是当前长度下第k𝑘大的回文数。而前一半就是顺序的，第k𝑘大就是当前长度的数的第k𝑘大，这个很好求。接下来只需要构成回文，直接输出即可。将L𝐿从小往大排序，那么只需要第n−P+1𝑛−𝑃+1大的数满足条件即可，假设这个数是a𝑎。因此，只需要计算T−a𝑇−𝑎即可。注意，如果这个数是负数，意味着初始时就满足条件，此时要输出00。我们只需要找到下一阶段的下限。a / 100 是本阶段+1 变成下一阶段，再 * 100变成下限，再与原来的相减即可。
算法：BFS解决 FloodFill 算法
一名还在努力学习技术的程序员的博客
07-24 1068
本篇博客是关于BFS 解决 FloodFill 算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
三维点云中常用的表面重建算法
Argulo的博客
07-22 1334
表面重建算法起源于计算机视觉和计算几何学领域。早期的研究集中在从二维图像中提取三维信息。然而，随着三维扫描技术的进步，越来越多的研究转向了如何从点云数据中重建表面。三维点云表面重建技术的发展，始于20世纪90年代，主要推动力是激光扫描和结构光扫描的广泛应用。
2024.7.24 作业
最新发布
qq_64434282的博客
07-24 1069
【代码】2024.7.24 作业。
Java实现七大排序（二）
lllsure的博客
07-23 542
冒泡排序、快速排序、归并排序
2024 暑假友谊赛-热身2
qq_42643660的博客
07-24 805
树的直径，N%m=N-(N/m)*m，期望dp..迷，简单线段树
《计算机程序设计艺术》：算法与编程精髓
"Abacist"和"abacus"唤起对早期计算工具的记忆，"algorist"和"algorism"则与算法和数字系统的历史发展相关。"Basin"可能在讨论数据存储或计算环境。"Corrupt"警示了防止代码错误和数据损坏的重要性，"etymological...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值