笔试算法练习

最新推荐文章于 2024-04-12 16:37:16 发布
最新推荐文章于 2024-04-12 16:37:16 发布
阅读量129 收藏
点赞数 1
分类专栏： 笔记 文章标签： 算法 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dhxy1030/article/details/120390515
版权

1.分糖果
在这里插入图片描述
2.出现一次的数字
在这里插入图片描述
3.重排链表
在这里插入图片描述

public class Solution {
    public void reorderList(ListNode head) {
        if(head==null||head.next==null) return;
             ListNode mid = middleNode(head);
        ListNode l1 = head;
        ListNode l2 = mid.next;
        mid.next = null;
        // 链表逆序
        l2 = reverseList(l2);
        // 合并链表
        mergeList(l1, l2);
    }
        public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next!= null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
        }
 
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
 
    public void mergeList(ListNode l1, ListNode l2) {
        ListNode l1_tmp;
        ListNode l2_tmp;
        while (l1 != null && l2 != null) {
            l1_tmp = l1.next;
            l2_tmp = l2.next;
 
            l1.next = l2;
            l1 = l1_tmp;
 
            l2.next = l1;
            l2 = l2_tmp;
        }
    }
    
}

4.后序遍历
在这里插入图片描述

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型ArrayList
     */
   public ArrayList<Integer> postorderTraversal (TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        postOrder(root,res);
        return res;
        // write code here
    }
    public void postOrder(TreeNode root,ArrayList<Integer> res){
        if(root==null) return;
        postOrder(root.left,res);
        postOrder(root.right,res);
        res.add(root.val);
    }
}

5.后缀表达式求值
在这里插入图片描述

import java.util.*;


public class Solution {
    /**
     * 
     * @param tokens string字符串一维数组 
     * @return int整型
     */
    public int evalRPN (String[] tokens) {
        // write code here
        Stack<Integer> stack = new Stack();
            for(String token: tokens){
                switch (token){
                    case "+": {
                        stack.push(stack.pop()+stack.pop());
                        break;
                    }
                    case "-": {
                        stack.push(-stack.pop()+stack.pop());
                        break;
                    }
                    case "*": {
                        stack.push(stack.pop()*stack.pop());
                        break;
                    }
                    case "/": {
                        Integer pop = stack.pop();
                        stack.push(stack.pop()/pop);
                        break;
                    }
                    default:{
                        stack.push(Integer.parseInt(token));
                    }
                }
            }
            return stack.pop();
    }
}

6.链表反转

package pratice;
public class reverseList {
    static class ListNode {
        int val;
        ListNode next;
        public ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
    //    迭代 head 第一个节点
    public static ListNode iterate(ListNode head) {
        ListNode pre = null, next;
        ListNode curr = head;
        while (curr!= null) {
//            保存指针
            next = curr.next;
//            让其指向前一个，head的前一个为null
            curr.next = pre;
//            将当前节点保存在pre
            pre=curr;
//            让当前节点变为下一个
            curr = next;
        }
        return pre;
    }
    //递归
    public static ListNode recursion(ListNode head) {
        //        找到最后一个节点
        if (head == null || head.next == null) {
            return head;
        }
//      最后一个元素
        ListNode node = recursion(head.next);
        head.next.next = head;
        head.next = null;
        return node;
    }
    public static void main(String[] args) {
        ListNode node5 = new ListNode(5, null);
        ListNode node4 = new ListNode(4, node5);
        ListNode node3 = new ListNode(3, node4);
        ListNode node2 = new ListNode(2, node3);
        ListNode node1 = new ListNode(1, node2);
        ListNode pre = iterate(node1);
        System.out.println(pre);
    }
}

7.找到数组的中心下标，即该数左右两边和相等

public class centerIndex {
    public static void main(String[] args) {
        System.out.println(pivotIndex(new int[]{1, 7, 3, 6, 5, 6}));
    }

    private static int pivotIndex(int[] nums) {
        int total = Arrays.stream(nums).sum();
        int left = 0;
        for (int i = 0; i < nums.length; i++) {
            left = left + nums[i];
            if (left == total) {
                return i;
            }
            total = total - nums[i];
        }
        return -1;
    }
}

8.求数组中最大乘积的三个数

public class MaxProduct {
    public static void main(String[] args) {
        System.out.println(sort(new int[]{-3,-2,-1, 1, 2, 3, 4, 5, 6}));
        System.out.println(getMaxMin(new int[]{-3,-2,-1, 1, 2, 3, 4, 5, 6}));
    }

    public static int sort(int[] nums) {
        Arrays.sort(nums);
//        Arrays.asList(nums).stream().forEach(System.out::print);
        int length = nums.length;
        return Math.max(nums[length-1]*nums[length-2]*nums[length-3],nums[0]*nums[1]*nums[length-1]);
    }
//    线性扫描
    public static int getMaxMin(int nums[]){
        int min1=Integer.MAX_VALUE;
        int min2=Integer.MAX_VALUE;
        int max1=Integer.MIN_VALUE;
        int max2=Integer.MIN_VALUE;
        int max3=Integer.MIN_VALUE;
        for (int num : nums) {
          if(num<min1){
              min1=num;
              min2=min1;
          }else if(num<min2){
              min2=num;
          }
          if(num>max1){
             max3=max2;
             max2=max1;
             max1=num;
          }else if(num>max2){
             max3=max2;
             max2=num;
          }else if(num>max3){
              max3=num;
          }
        }
        return Math.max(min1*min2*max1,max1*max2*max3);
    }
}

9.删除数组中重复的数并返回新的数组长度

public class shuzuchongfu {

    public static void main(String[] args) {

        System.out.println(removeDuplicates(new int[]{0, 1, 2, 2, 3, 3, 4}));
    }

    private static int removeDuplicates(int[] nums) {

        if (nums == null || nums.length == 0) return 0;

        int slow = 0;

        for (int fast = 1; fast < nums.length; fast++) {

            if (nums[slow] != nums[fast]) {

                slow++;

                nums[slow] = nums[fast];
            }
        }
        return slow + 1;
    }
}

9.求整数的平方根

public class sqrtX {
    public static void main(String[] args) {
        System.out.println(binarySearch(24));
        System.out.println(newton(24));
    }

    public static int binarySearch(int x) {
        int index = -1, left = 0, right = x;

        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (mid * mid <= x) {
                index = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return index;
    }

    public static int newton(int x) {
        return (int) sqrt(x, x);
    }

    public static double sqrt(double i, int x) {
        double mid=(i+x/i)/2;
        if(mid==i){
            return i;
        }else{
            return sqrt(mid,x);
        }
    }

10.n以内素数

public class sushu {
    public static int sushuNum(int num) {

        int i, j, k,count=0;
        for (i = 2; i < num; i++) {
            k = (int) Math.sqrt(i);
            for (j = 2; j <= k; j++) {
                if(i%j==0){
                    break;
                }
            }
            if (j>k) {
               count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int n = sc.nextInt();
        System.out.println(sushuNum(n));
    }
}

11.数组中两个数相加等于给定的target，求这两个数的下标，两个坐标不能相等(无序)

public class twoNumsAdd {
//   无序数组
    public static void main(String[] args) {
        System.out.println(Arrays.toString(solution(new int[]{1, 2, 3, 4, 5, 6}, 10)));
        System.out.println(Arrays.toString(solution2(new int[]{1, 2, 3, 4, 5, 6}, 10)));
    }

    private static int[] solution2(int[] nums, int target) {
        Map<Integer, Integer> mp = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (mp.containsKey(target - nums[i])) {
                return new int[]{mp.get(target - nums[i]), i};
            } else {
                mp.put(nums[i], i);
            }
        }
        return new int[0];
    }

    private static int[] solution(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }

}

12.数组中两个数相加等于给定的target，求这两个数的下标，两个坐标不能相等(有序)

public class twoNumsAdd2 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(twoPoint(new int[]{0, 1, 2, 3, 4, 5, 6}, 10)));
        System.out.println(Arrays.toString(twoSearch(new int[]{0, 1, 2, 3, 4, 5, 6}, 10)));
    }

    public static int[] twoSearch(int nums[], int target) {
        for (int i = 0; i < nums.length; i++) {
            int low = i, high = nums.length - 1;
            while (low <= high) {
                int mid = low + (high - low) / 2;
                if (nums[mid] == target - nums[low]) {
                    return new int[]{i, mid};
                } else if (nums[mid] > target - nums[low]) {
                    high = mid - 1;
                } else if (nums[mid] < target - nums[low]) {
                    low = mid + 1;
                }
            }
        }
        return new int[0];
    }

    public static int[] twoPoint(int nums[], int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            if (nums[low] + nums[high] == target) {
                return new int[]{low, high};
            } else if (nums[low] + nums[high] < target) {
                low++;
            } else if (nums[low] + nums[high] > target) {
                high--;
            }
        }
        return new int[0];
    }
}

13.斐波那契数列，求某个位置的值

public class feibonaqie {
    public static void main(String[] args) {
        System.out.println(result(10));
        System.out.println(result2(10));
        System.out.println(iterate(10));
    }
//递归
    public static int result(int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }
        return result(num - 1) + result(num - 2);
    }
//
    public static int result2(int num) {
        int[] arr = new int[num + 1];

        return recurse(arr, num);
    }
递归优化
    public static int recurse(int[] arr, int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }
        if (arr[num] != 0) {
            return arr[num];
        }
        arr[num] = recurse(arr, num - 1) + recurse(arr, num - 2);
        return arr[num];
    }
//牛顿递归
    public static int iterate(int num) {
        if (num == 0) {
            return 0;
        }
        if (num == 1) {
            return 1;
        }
        int low = 0, high = 1;
        for (int i = 2; i <= num; i++) {
            int sum = low + high;
            low = high;
            high = sum;
        }
        return high;
    }
}

14.排列硬币 第几行就放几个硬币，总共可放多少行？

public class coin {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数N");
        int n = sc.nextInt();
        System.out.println(arrangeCoin(n));
        System.out.println(arrangeCoin2(n));
        System.out.println(newton(n));
    }

    public static int arrangeCoin(int n) {
        for (int i = 1; i <= n; i++) {
            n = n - i;
            if (n <= i) {
                return i;
            }
        }
        return 0;
    }

    public static int arrangeCoin2(int n) {
        int low = 0, high = n;
        while (low <= high) {
            //找到中间行
            int mid = low + (high - low) / 2;
//            mid行之前的总数
            int cost = (mid * (mid + 1)) / 2;
            if (cost == n) {
                return mid;
            } else if (cost > n) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return high;
    }

    public static int newton(int n) {
        return (int) sqrt(n, n);
    }

    public static double sqrt(double x, int n) {
        double mid = (x + (2 * n - x) / x) / 2;
        if (mid == x) {
            return x;
        } else {
            return sqrt(mid, n);
        }
    }
}
winkooxx
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【牛客】华为笔试算法题练习（简单篇）JavaScript V8 实现
倏存的博客
09-02 1002
牛客网华为面试题链接 本文都是自己写的从牛客上直接截图下来的，因为牛客的输入输出与常规写的优点不同，这点可以自己百度。 我自己摸索出来的，在Java Script V8 模式下，点开ACM模式，里面有说明，可以把代码复制下来，然后其中的line就表示你要用到的变量。本文只有牛客上归类为简单的算法题。 简单篇1. 输出逆序的字符串2.求最小公倍数3. 四舍五入4.字符串反转5. 颠倒整数6. 统计每个月兔子的总数7.未完待续。。。。 1. 输出逆序的字符串 牛客网-点击链接进入该题目 -描述：将一个字符.
用JS解基础前端笔试算法练习题
weixin_53919192的博客
09-03 332
本文是本人练习JS的一些算法题，希望对你有帮助~~
c语言笔试经典算法,C语言中常见的笔试题
weixin_42581003的博客
05-18 621
一、计数、求和、求阶乘等简单算法此类问题都要使用循环，要注意根据问题确定循环变量的初值、终值或结束条件，更要注意用来表示计数、和、阶乘的变量的初值。例：用随机函数产生 100 个[0， 99]范围内的随机整数，统计个位上的数字分别为 1， 2， 3， 4，5， 6， 7， 8， 9， 0 的数的个数并打印出来。本题使用数组来处理，用数组 a[100]存放产生的确 100 个随机整数，数组 x[10...
【算法练习】小红书240317暑期实习笔试
最新发布
Delicacy__的博客
04-12 1815
如果塔子哥使用两张致命射击恰好消灭了敌方最左边和最右边的随从(恰好造成了一张碾压墙的效果)，就会有人在评论区发布“碾压墙”，注意:两张致命射击的结算有先后顺序，即两张致命射击不会消灭同一个敌方随从。该算法的核心思想如下，首先给定一个商品清单，其中有每个商品所包含的关键词属性，然后给出用户最近搜索过的一些关键词，请你将包含用户搜索过的更多的关键词的商品排在用户目录的前面。
【算法练习】校招研发工程师笔试题
老马的程序人生
09-09 372
请留言，说出你的解题思路和答案。稍后，我会把参考答案发到留言区。不定期整理相关的问题答案分享。 01、下列代码的运行结果是（） static void Main(string[] args) { int x = 1235321; bool flag = true; int bit = 1; while (x / bit >= 10) { bit = bit * 10; } while (x > 0) {
分享一些算法练习的网站
xDarkSoulsIIIx的博客
05-26 2755
算法练习的网站 推荐一些个人觉得还不错的算法练习网站 一、leetcode(力扣)   地址：https://leetcode-cn.com/   里面有各个企业（包括腾讯、阿里、蚂蚁、shopee等一些名企的算法面试题）、收集了校招时候遇到的面试题以及由网站自创的面试题，能够满足你对算法练习的需求并且可以观摩大佬的写法及官方出示写法来学习。   里面还有社区可以进行学术交流，也许可以结识到这方面专业的大佬。   还时不时会举办一些竞赛可以和全国各地的程序员进行比赛（里面也有名企参与）取得好成绩还可能被名
18个笔试考试算法 C语言
qq_25837497的博客
12-04 1680
目录 1收集雨水 2 直方图矩形面积 3 数组中的最长连续子序列 4排列组合 5两数之和 6 上中位数 7 三个数最大乘积 8 数组中逆序对 9 数字在升序数组中出现的次数（二分查找） 10 旋转数组中最小的数字 12 岛屿数量 13 数组中出现一次的两个数字 14 数组中出现次数超过一半的数字 15字符串旋转 16字符串最长无重复子串 17最长重复子串 18三色旗问题 参考了许多前辈的成果，感谢，此次备考中作为练习，问题描述和思路写得比较简单，如有不解，......
理想汽车(算法笔试)
lft_happiness的博客
02-24 4743
理想汽车算法笔试题-
笔试算法训练day3
wyhplus的博客
07-11 2756
今天是算法小学徒分享自己在Acwing&leetcode平台准备笔试面试刷题过程中觉得质量高的题目的第三天,下面配有作者的讲解,希望能够帮助到大家。 滚动数组 滚动数组是一种能够在动态规划中降低空间复杂度的方法,是动态规划（Dynamic Programming，DP）中的一种编程思想,简单地理解就是让数组滚动起来,每次都使用固定的几个存储空间。来达到压缩,节省存储空间的作用。可起到起到优化突间的作用,主要应用在递推或动态规划中(如01背包问题)。.........
【算法】面试笔试中的贪心算法
每天更新大数据面经和技术
04-11 1159
  贪心算法是面试中的常考问题。它是在考虑局部最优解的情况下来得到全局最优解，即一个问题的最优解可以由它的子问题的最优解构造出来，一般使用反证法和数学归纳法来证明。贪心算法没有固定的模板，是一种思想。通常贪心算法都需要对原始数据进行排序，或者问题本身已经是一个序列，只需要在这个序列上对每一步做出决策。下面通过几个问题来体会贪心策略的思想。 1.力扣 179.最大数[1] 题目描述：   给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。 注意：输出结果可能非常大，所以
java经典算法练习题
11-02
java经典算法练习题 适合初学者 内含有大量代码 包含答案 保你学完有很大的长进！
Algorithm:算法练习
05-07
Algorithm个人算法练习项目说明最近在忙着做实习，做项目，找工作，想系统的刷刷Leetcode只能各种挤时间。大抵是上班偷偷做点，反正开着黑色的IDEA也没人仔细看我在写啥代码。晚上回宿舍刷点，每天下班都九十点钟了...
复试笔试1
08-08
具体可以参照《编译原理》张素琴那本书第7章练习题中第6、14、15题。三（4道小题，关于代码优化部分）第一个是填表，第二个第三个是关于ud链和du链的，第四个应
高级java笔试题-algorithm:算法
06-03
这个专栏是Hollis知识星球的朋友们练习算法的地方 欢迎广大网友参与分享算法学习经验 项目目前分为两部分 solutions 目录 算法题解，格式是 md 格式文件，方便阅读 包括 算法平台的题解，如 Leetcode 等 算法书籍的...
java笔试题算法-eatiht:无监督机器学习练习：在HTml文档中提取文章的文本
06-03
java笔试题算法关于这个回购的一句话 我正在重新构想网络数据提取：. 它不仅支持文章提取，还支持表格数据提取！ 也就是说，我不太可能将任何更新推送到这个分支，但我会继续接受拉取请求。 希望在， :) 饮食 Python...
mybatis注解开发配置及注意事项
winkooxx
06-15 1638
mybatis注解开发配置及注意事项 1.注解及配置： 注解： @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与@Result 一起使用，封装多个结果集 @ResultMap:实现引用@Results 定义的封装 @One:实现一对一结果集封装 @Many:实现一对多结果集封装 @SelectProvider: 实现动态 SQL 映射 @CacheNamespace:实现注解二级缓存的使用 在m
springboot+mybatisplus+vue+elementui前后端分离
winkooxx
07-11 1088
前后端分离 前后端分离就是将⼀个应⽤的前端代码和后端代码分开写，为什么要这样做？ 如果不使⽤前后端分离的⽅式，会有哪些问题？ 传统的 Java Web 开发中，前端使⽤ JSP 开发，JSP 不是由后端开发者来独⽴完成的。前端—》HTML 静态⻚⾯ —〉后端 —》JSP 这种开发⽅式效率极低，可以使⽤前后端分离的⽅式进⾏开发，就可以完美地解决这⼀问题。 前端只需要独⽴编写客户端代码，后端也只需要独⽴编写服务端代码提供数据接⼝即可。 前端通过 Ajax 请求来访问后端的数据接⼝，将 Model
JAVA之多线程
winkooxx
08-20 400
JAVA之多线程 并发与并行 并发（concurrency）和并行（parallellism）是： 解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。 解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。 解释三：并行是在一台处理器上“同时”处理多个任务，并发是在多台处理器上同时处理多个任务。如 hadoop 分布式集群。 并行：是逻辑上同时发生，指在某一个时间内同时运行多个程序。 并发：是物理上同时发生，指在某一个时间点同时运行多个程序。
Vue入门学习
winkooxx
06-26 365
Vue入门学习 Vue基础指令与案例演示 1.v-text与v-html v-text只会发数据渲染到标签，不会对html标签进行解析、 v-html会对html标签进行解析 <div id="box"> <!-- vue的指令：vue提供的一种行间属性，你可以加在标签上，对这个DOM元素应用一些行为。 --> <h1>{{msg}}</h1> <!-- v-text 把数据渲染到标签 --> <h1 v-text="
多益网络 算法岗 笔试
07-27
2. 练习编写代码，特别是与算法和数据结构相关的代码。您可以通过刷LeetCode、参加在线编程比赛或解决一些编程题目来提高编程能力。 3. 关注软件工程的最佳实践，了解如何编写可读性好、可维护性强的代码。 4. 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值