一些常见的算法或编程题

最新推荐文章于 2022-12-21 13:09:32 发布
最新推荐文章于 2022-12-21 13:09:32 发布
阅读量220 收藏 1
点赞数 1
分类专栏： java人生路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxh13521338301/article/details/110467715
版权

线程死锁

package live.yanxiaohui.test.day20201202;

/**
 * @Description 线程死锁
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-02 08:41<br>
 * @Version 1.0<br>
 */
public class Dead {

    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        new A(o1,o2,false).start();
        new A(o1,o2,true).start();
    }
}

class A extends Thread{
    private Object o1;
    private Object o2;
    private boolean flag;

    public A(Object o1, Object o2, boolean flag) {
        this.o1 = o1;
        this.o2 = o2;
        this.flag = flag;
    }

    public void a(){
        synchronized (o1){
            System.out.println(Thread.currentThread().getName()+":o1");
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+":o2");
            }
        }
    }

    public void b(){
        synchronized (o2){
            System.out.println(Thread.currentThread().getName()+":o2");
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+":o1");
            }
        }
    }

    @Override
    public void run() {
        if(flag){
            while(true){
                a();
            }
        }else {
            while (true){
                b();
            }
        }
    }
}

 

生产者与消费者（交替打印奇偶数） 

package live.yanxiaohui.test.day20201202;

/**
 * @Description todo
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-02 09:15<br>
 * @Version 1.0<br>
 */
public class Demo {

    public static void main(String[] args) {
        Data d = new Data();
        new T1(d).start();
        new T2(d).start();
    }
}

class T1 extends Thread {
    private Data data;

    public T1(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (data) {
                try {
                    Thread.sleep(1000);
                    if (data.count % 2 == 0) {
                        data.wait();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + data.count);
                    data.count++;
                    data.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class T2 extends Thread {
    private Data data;

    public T2(Data data) {
        this.data = data;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (data) {
                try {
                    Thread.sleep(1000);
                    if (data.count % 2 != 0) {
                        data.wait();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + data.count);
                    data.count++;
                    data.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class Data {
    public int count;
}

 

 两个有序数组合并为一个有序数组

package live.yanxiaohui.test.day20201202;

import java.util.Arrays;

/**
 * @Description 两个有序数组排序
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-02 08:49<br>
 * @Version 1.0<br>
 */
public class ArraySort {

    public static void main(String[] args) {
        int[] a = {0, 1, 1, 3, 6};
        int[] b = {1, 2, 4, 5, 6, 7,8,10};
        //int[] c = sort1(a, b);
        int[] c = sort2(a, b);
        for (int i : c) {
            System.out.println(i);
        }
    }

    /**
     * o(a.length+b.length)
     *
     * @param a
     * @param b
     * @return
     */
    public static int[] sort1(int[] a, int[] b) {
        int[] c = new int[a.length + b.length];

        int i = 0, j = 0, index = 0;
        while (i < a.length && j < b.length) {
            if (a[i] <= b[j]) {
                c[index++] = a[i++];
            } else {
                c[index++] = b[j++];
            }
        }
        // a数组先遍历完
        if(i==a.length){
            for(;j<b.length;j++){
                c[index++]=b[j];
            }
        }
        // b数组先遍历完
        if(j==b.length){
            for(;i<a.length;i++){
                c[index++]=a[i];
            }
        }
        return c;
    }


    /**
     * o(a.length+b.length+ c.length^2)
     */
    public static int[] sort2(int[] a, int[] b) {
        int[] c = new int[a.length + b.length];
        int index=0;
        for(int i:a){
            c[index++]=i;
        }
        for(int i:b){
            c[index++]=i;
        }
        Arrays.sort(c);
        return c;
    }
}

 

两个数组找交集

package live.yanxiaohui.test.day20201202;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description todo
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-02 09:20<br>
 * @Version 1.0<br>
 */
public class Same {

    public static void main(String[] args) {
        int[] a = {0, 1, 1, 3, 6};
        int[] b = {1, 2, 4, 5, 6, 7, 8, 10};
        System.out.println(same(a, b));
    }

    private static List<Integer> same(int[] a, int[] b) {
        List<Integer> c = new ArrayList<>(Math.max(a.length, b.length));
        Map<Integer, Object> map = new HashMap<>((int) (Math.ceil(a.length) / 0.75) + 1);
        for (int i : a) {
            map.put(i,null);
        }

        for (int i:b){
            if(map.containsKey(i)){
                c.add(i);
            }
        }
        return c;
    }
}

 

单向链表检测环

package live.yanxiaohui.test.day20201202;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

/**
 * @Description 快慢引用检测环
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-02 09:20<br>
 * @Version 1.0<br>
 */
public class Same {

    public static void main(String[] args) {
        int len = 10;
        List<Node> list = new ArrayList<>(len);
        // 设置环 9->8->7...->0
        IntStream.range(0, len).forEach(i -> {
            Node n = new Node(i + "");
            if (list.size() > 0) {
                n.next = list.get(i - 1);
            }
            list.add(n);
        });

        // 设置环 6->5->4->3->2->1->0->6->5....
        Node node = list.get(0);
        node.next = list.get(6);


        System.out.println(loop(list.get(list.size() - 1)));

    }

    /**
     *
     * @param node 链表头
     * @return
     */
    private static boolean loop(Node node) {
        Node a = node, b = node;
        while (a != null && b != null) {
            if((a = a.next)==null){
                return false;
            }
            if(b.next == null){
                return false;
            }

            if ((b = b.next.next)==null) {
                return false;
            }
            if (a.equals(b)) {
                return true;
            }
        }
        return false;
    }

}

class Node {
    public Node next;
    private String name;

    public Node(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        // todo 不严谨，可优化
        return name.equals(((Node) obj).getName());
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 

反转单向链表

/**
 * @Description 反转单向列表
 * 示例：4->3->2->1->0  变为 0->1->2->3->4
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author： yanxh<br>
 * @Date 2020-12-08 10:59<br>
 * @Version 1.0<br>
 */
public class Demo {
    public static void main(String[] args) {
        // 创建单向列表
        Node first = new Node(0);
        for (int i = 1; i <=4; i++) {
            Node node = new Node(i);
            node.next = first;
            first = node;
        }

        // 反转
        System.out.println("==================================");
        Node swap = swap(first);
        System.out.println(swap);
    }


    public static Node swap(Node node) {
        Node t = null;
        while (node != null) {
            Node next = node.next;
            node.next = t;
            t = node;
            node = next;
        }
        return t;
    }
}

class Node {
    Node next;
    Integer index;

    public Node(Integer index) {
        this.index = index;
    }
}

两个栈实现一个队列

package live.yanxiaohui;

import java.util.Stack;
import java.util.stream.IntStream;

/**
 * @Description 两个栈实现一个队列
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author yanxh<br>
 * @Date 2020/12/11 9:24<br>
 * @Version 1.0<br>
 */
public class Queue<E> {
    private Stack<E> s1 = new Stack<>();
    private Stack<E> s2 = new Stack<>();

    public void offer(E val) {   //入队
        s1.push(val);
    }

    public E poll() {   //出队

        while (!s1.isEmpty()){
            s2.push(s1.pop());
        }
        if(s2.isEmpty()){
            return null;
        }
        E result = s2.pop();
        while(!s2.isEmpty()){
            s1.push(s2.pop());
        }
        return result;
    }


    public static void main(String[] args) {
        Queue<Integer> queue = new Queue<>();
        IntStream.range(0, 10).forEach(i -> queue.offer(i));

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        queue.offer(100);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

    }
}

 两个队列实现一个栈

package live.yanxiaohui;

import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.stream.IntStream;

/**
 * @Description 两个队列实现一个栈 先进后出
 * @CSDN https://blog.csdn.net/yxh13521338301
 * @Author yanxh<br>
 * @Date 2020/12/11 9:24<br>
 * @Version 1.0<br>
 */
public class Stack<E> {
   Queue<E> q1 = new LinkedBlockingQueue<>();
   Queue<E> q2 = new LinkedBlockingQueue<>();

   public void push(E e){
       q1.offer(e);
   }


    public E pop(){
        E result = null;
        while(!q1.isEmpty()){
            E poll = q1.poll();
            if(q1.isEmpty()){
                result = poll;
            }else {
                q2.offer(poll);
            }
        }

        if(q2.isEmpty()){
            return null;
        }


        while(!q2.isEmpty()){
            q1.offer(q2.poll());
        }

        return result;
    }

    public static void main(String[] args) {
        Stack<Integer> s = new Stack<>();
        IntStream.range(0,10).forEach(i->s.push(i));
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        s.push(100);
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
        System.out.println(s.pop());
    }
}

 

yxh13521338301
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试常见算法题
05-17
这是在面试中遇到的一些常见算法题，笔试面试经常遇到，所以总结了一下，方面以后查看，分享给大家。
Java常见算法编程题
chuique6732的博客
08-09 91
题目一： 古典问题：有一对兔子，从出生后每三个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总共有多少对？ 程序分析：每个月的兔子总对数依次为：1,1,2,3,5,8,13.......当前月的兔子数是前两个月兔子数之和 Publiccl...
面试中常考的算法编程题目(会持续更新......)
依然在路上、
10-08 6304
1.找到英文句子中出现次数最多的单词 public class Count { public static void main(String[] args) { long start = System.currentTimeMillis(); String str = "Look to the skies above London and you'll...
常见编程题
造梦先森Kai的专栏
09-04 4060
数组字符串专题 Map存储、遍历、并利用Comparator实现自定义排序(Map按值排序) 排序算法 交换排序：冒泡排序、快速排序 选择排序：简单选择排序、堆排序 插入排序：直接插入排序、二分法插入排序、希尔排序 归并排序、基数排序 总结 二分查找及变形题 全排列 递归和循环：斐波那契数列、跳台阶、矩形覆盖 求最长公共子串和最长公共子序列 求最长回文子串 字符串反转、句子逆序（StringB
程序员必备三十道算法题（11~20题）
weixin_55014779的博客
02-02 1894
程序员必备三十道算法题（11~20题） 11、题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。 程序分析：(a>b)?a:b这是条件运算符的基本例子。 //三元运算符 <script> var sum = prompt('输入成绩'); if(sum<0 || sum>100){ alert('请重新输入') } var m = sum >= 90 ?'A
面试常见的js算法题
10-20
以下是一些面试中常见的JavaScript算法题及其解析： 1. **排序算法**： - **冒泡排序**：这是一种简单的排序算法，通过重复遍历数组，比较相邻元素并交换位置来实现排序。在JavaScript中，冒泡排序的时间复杂度为O...
C#常见算法面试题小结
09-04
在C#面试中，算法题是考察候选人编程基础和逻辑思维能力的重要环节。这里我们将深入探讨几种常见的排序算法，如冒泡排序、选择排序和插入排序，并分析一个递归求斐波那契数列的问题，以及模拟事件处理的简单设计模式...
JAVA算法编程题汇总(50题及答案)
04-13
Java 算法编程题汇总 Java 算法编程题汇总是本文的主题，本文将对 50 道 Java 算法编程题进行汇总，涵盖了 Fibonacci 序列、素数、水仙花数、质因数分解等多个方面的知识点。 Fibonacci 序列 Fibonacci 序列是...
字符串常见的算法题经典
08-03
本节我们将探讨一些常见的字符串算法题，包括字符串反转、将整数转换成字符串、字符串拷贝、字符子串删除等。这些算法题都是IT行业中非常重要的基础知识。 一、字符串反转算法 反转字符串是字符串处理中非常重要的...
计算机常见算法面试题.docx
03-28
【计算机常见算法面试题】涉及的是一些经典的C语言编程和算法问题，这些问题在面试中经常出现，对理解和掌握C语言以及基础算法至关重要。以下是对这些题目及其解法的详细解析： 1. **判断链表中是否有环**： 判断...
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
07-19
JAVA基础编程练习题50题及经典算法90题【含源码及答案】
程序员面试智力、算法题汇总一pdf
07-25
程序员面试智力、算法题汇总一。很好的资源 我自己在用，对面试有很大帮助，涵盖了面试最常见的智力题，算法题，编程题还有大数据处理。
经典算法题目与答案-含代码
03-26
多个经典算法题目，包含java，c++，python解题代码，是您面试，软考的必备书籍。
编程经典笔试面试题集合
10-18
—即使你是个编程高手，你在面试前也应该要看看这套题，她也许会给你带来好运，否则你有可能后悔当初为什么没有看而跳楼自杀，这样我会很内疚的。
西安软件公司java笔试题
09-11
西安各大公司的java笔试题目共享，包括陕西网源电子科技有限公司，西部世纪，新北邦等公司
编程算法集锦
fakerth的博客
12-21 2436
编程算法集锦
一定场景下的C语言编程作业,深入浅出 Qt5 程序设计（配套精准作业题）
weixin_30418751的博客
05-17 116
本课程详细、多面地介绍了 Qt 开发中的各个技术细节，并且额外赠送在嵌入式端编写Qt程序的技巧。整个课程涵盖知识点非常多，知识模块囊括 Qt-Core 组件、QWidgets、多媒体、网络、绘图、数据库，超过200个 C++ 类的分析和使用，学完之后将拥有Qt 图形界面开发的非常坚实的功底。每个知识点不仅仅会通过视频讲解清楚，并且会配以精心安排的实验和作业，用来保证学习过程中切实学习核心技术和概...
面试编程题模式总结
qq_27095007的博客
10-09 141
滑动窗口 应用场景： （1） 输入是线性数据结构，比如链表，数组，字符串 （2） 问题是找到最长或者最短的子串或者找到一个期望值 典型案例： （1） 给定长度为k，求和最大的子数组 （2） 有‘k’个不同字符的最长的子字符串 （3） 字符串回文构词法 双指针 应用场景： （1） 从有序数组（链表）中找到一组满足特定约束的元素 （2） 这一组元素要么是二元组，要么是三元组，甚至多元组 典型案例： ...
情景软工编程题(待更新)
qianggezaici的博客
09-10 389
情景软工编程题(待更新)题目1： 题目2：爬山
列出一些算法常见面试题
最新发布
05-12
以下是一些常见的算法面试题： 1. 反转一个字符串或链表 2. 判断一个字符串是否为回文字符串 3. 查找一个字符串中的最长无重复字符子串 4. 查找两个有序数组的中位数 5. 查找一个数组中的最大子序列和 6. 判断一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值