常见算法复习

已于 2024-09-25 21:32:27 修改
阅读量177 收藏
点赞数 3
文章标签： 排序算法 算法 java
于 2024-09-25 15:32:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64704029/article/details/142523585
版权

快速排序

时间复杂度：最好情况O(nlong(n)),最坏情况O(n^2)
思路：选择一个基准，将比他小的挪到他的前边，比他大的挪到他的后边

public class Main {
    private static void quickSort(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int i = l - 1;
        int j = r + 1;
        int x = arr[l+r>>1];
        while(i<j){
            do i++;while(arr[i]<x);
            do j--;while(arr[j]>x);
            if(i<j){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        quickSort(arr,l,j);
        quickSort(arr,j+1,r);
    }

    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 9, 1, 5, 8, 6};
        quickSort(arr,0,arr.length-1);
        for(int num : arr){
            System.out.println(num);
        }
    }
}

归并排序

时间复杂度：最佳情况（O(n log n)），平均情况（O(n log n)），最差情况（O(n log n)）
采用分治的思想，先局部有序再整体有序

public class Main {
    private static void mergeSort(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int[] res = new int[arr.length];
        int mid = l + r >> 1;
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        int num = 0;
        int i = l;
        int j = mid + 1;
        while (i <= mid && j <= r) {
            if (arr[i] < arr[j]) res[num++] = arr[i++];
            else res[num++] = arr[j++];
        }
        while (i <= mid) res[num++] = arr[i++];
        while (j <= r) res[num++] = arr[j++];
        for (i = l, j = 0; i <= r; i++, j++) {
            arr[i] = res[j];
        }
    }

    public static void main(String[] args) {
        int[] arr = {3, 1, 4, 2, 5, 6, 0};
        mergeSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.println(num);
        }
    }
}

单例模式

public class Main {
    public static void main(String[] args) {
        // 创建多个线程来获取单例实例
        Runnable task = () -> {
            Singleton singleton = Singleton.getInstance();
            singleton.showMessage();
        };
        // 创建10个线程并启动它们
        for (int i = 0; i < 10; i++) {
            new Thread(task).start();
        }
    }
}
class Singleton {
    // volatile 关键字确保 instance 的可见性和禁止指令重排序
    private static volatile Singleton instance = null;

    // 私有构造函数，防止实例化
    private Singleton() {
        // 可以在这里初始化一些资源
    }
    // 获取单例实例的方法，使用双重检查锁定
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查:如果实例已被创建，就直接返回实例，避免了不必要的加锁操作。
            synchronized (Singleton.class) { // 加锁只有在第一次检查确定 instance 为 null 时，才进入同步块。
                if (instance == null) { // 第二次检查在同步块内再次检查 instance 是否为 null，确保只有一个线程能够创建实例。
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    // 一个简单的方法，用于测试单例类的功能
    public void showMessage() {
        System.out.println("Hello, I am a singleton!");
    }
}

public enum Singleton {
    // 定义枚举实例，这个就是单例对象
    INSTANCE;

    // 单例类的成员方法
    public void showMessage() {
        System.out.println("Hello, I am a singleton using Enum!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 获取单例实例并调用方法
        Singleton singleton = Singleton.INSTANCE;
        singleton.showMessage();
        // 验证多个线程访问是否是同一个实例
        Runnable task = () -> {
            Singleton s = Singleton.INSTANCE;
            System.out.println("Instance: " + s.hashCode());
        };
        // 启动多个线程进行验证
        for (int i = 0; i < 10; i++) {
            new Thread(task).start();
        }
    }
}

多线程交替打印奇偶数

public class Main {
    private static final int max = 10;
    private static final Object lock = new Object();
    private static boolean isOddTurn = true; // 标识当前是否应该打印奇数

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= max; i += 2) {
                synchronized (lock) {
                    while (!isOddTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("奇数:" + i);
                    isOddTurn = false;
                    lock.notify(); // 唤醒偶数线程
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 2; i <= max; i += 2) {
                synchronized (lock) {
                    while (isOddTurn) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("偶数:" + i);
                    isOddTurn = true;
                    lock.notify(); // 唤醒偶数线程
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

信号量机制的实现方法

public class Main {
    private static final int MAX = 10; // 打印的最大数字
    private static final Object lock = new Object();
    private static boolean isOddTurn = true; // 标识当前是否应该打印奇数
    public static void main(String[] args) {
        // 奇数线程
        Thread oddThread = new Thread(() -> {
            for (int i = 1; i <= MAX; i += 2) {
                synchronized (lock) {
                    while (!isOddTurn) { // 如果不是奇数线程的执行时机，则等待
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("奇数: " + i);
                    isOddTurn = false; // 该偶数线程执行了
                    lock.notify(); // 唤醒偶数线程
                }
            }
        });
        // 偶数线程
        Thread evenThread = new Thread(() -> {
            for (int i = 2; i <= MAX; i += 2) {
                synchronized (lock) {
                    while (isOddTurn) { // 如果不是偶数线程的执行时机，则等待
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("偶数: " + i);
                    isOddTurn = true; // 该奇数线程执行了
                    lock.notify(); // 唤醒奇数线程
                }
            }
        });
        // 启动两个线程
        oddThread.start();
        evenThread.start();
    }
}

三个线程交替打印

public class ThreeThreadPrinter {
    private static final int MAX = 9; // 每个线程打印的最大数字
    private static final Object lock = new Object();
    private static int current = 1; // 当前应该由哪个线程打印，1表示线程1，2表示线程2，3表示线程3

    public static void main(String[] args) {
        // 线程1，打印1, 4, 7
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= MAX; i += 3) {
                synchronized (lock) { // 获取锁
                    while (current != 1) { // 如果不是线程1的执行时机，则等待
                        try {
                            lock.wait(); // 进入等待状态
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("Thread 1: " + i); // 打印数字
                    current = 2; // 设置为线程2的执行时机
                    lock.notifyAll(); // 唤醒其他线程
                }
            }
        });

        // 线程2，打印2, 5, 8
        Thread t2 = new Thread(() -> {
            for (int i = 2; i <= MAX; i += 3) {
                synchronized (lock) { // 获取锁
                    while (current != 2) { // 如果不是线程2的执行时机，则等待
                        try {
                            lock.wait(); // 进入等待状态
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("Thread 2: " + i); // 打印数字
                    current = 3; // 设置为线程3的执行时机
                    lock.notifyAll(); // 唤醒其他线程
                }
            }
        });

        // 线程3，打印3, 6, 9
        Thread t3 = new Thread(() -> {
            for (int i = 3; i <= MAX; i += 3) {
                synchronized (lock) { // 获取锁
                    while (current != 3) { // 如果不是线程3的执行时机，则等待
                        try {
                            lock.wait(); // 进入等待状态
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("Thread 3: " + i); // 打印数字
                    current = 1; // 设置为线程1的执行时机
                    lock.notifyAll(); // 唤醒其他线程
                }
            }
        });

        // 启动三个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

0-1背包

public class Main {

    // 0-1背包问题的解决方法
    public static int bagValue(int[] weights, int[] values, int capacity) {
        int n = weights.length;
        // 创建一个二维数组dp，其中dp[i][j]表示前i件物品在总容量为j的条件下的最大价值
        int[][] dp = new int[n + 1][capacity + 1];
        // 遍历每一个物品
        for (int i = 1; i <= n; i++) {
            // 遍历每一个可能的容量值
            for (int j = 1; j <= capacity; j++) {
                // 如果当前物品的重量大于当前的背包容量，那么当前物品不能放入背包
                if (weights[i - 1] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    // 当前物品可以放入背包，我们选择放入或不放入的最大值
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]);
                }
            }
        }
        // 返回最大值，即dp[n][capacity]
        return dp[n][capacity];
    }

    public static void main(String[] args) {
        int[] weights = {2, 3, 4, 5}; // 每个物品的重量
        int[] values = {3, 4, 5, 6};  // 每个物品的价值
        int capacity = 5;  // 背包的容量
        int maxValue = bagValue(weights, values, capacity);
        System.out.println("背包可以获得的最大价值是: " + maxValue);
    }
}
米兰的小铁匠~
关注
【搞定算法】常见算法题分类总览
Java学习
07-26 2万+
博主秋招提前批已拿百度、字节跳动、拼多多、顺丰等公司的offer，可加微信：pcwl_Java 一起交流秋招面试经验，可获得博主的秋招简历和复习笔记。 完善中...... 由于本人平时刷题比较零散，有时候找起来不是很方便，所以统一将题目记录于此。主要的题目来源自：剑指 Offer、LeetCode、左神算法、面试、笔试、面经等等。下面按照分类记录： 说明（个人见解）： 一、标注说明 ...
##智能优化算法复习--遗传算法
m0_59324264的博客
11-19 2007
智能优化算法
算法设计与分析复习
steven_ysh的博客
12-15 3351
算法设计与分析课程复习，包含算法的基本概念、递归与分治、动态规划、贪心算法、随机算法、回溯法与分支限界法、NP 完全性、近似算法
算法复习——6种排序方法的简单回顾
weixin_47723114的博客
12-07 1155
常见排序方法：冒泡排序、选择排序、插入排序、堆排序、归并排序、快速排序的简单回顾
大学课程数据结构与算法复习
学无止境！
09-03 1349
参考链接 数据结构之数组和链表的区别 算法的时间与空间复杂度 1、前言 数据结构与算法是计算机专业必修的一门课 在工作中，免不了要面对一些复杂的业务逻辑，可能有多种方法实现，每种方式的运行效率也可能都不一样，好的数据结构与算法能提升效率，具体体现在时间和空间上 比如，现在有一万个人，要找出姓名叫张三的人，最简单的方式是从头到尾遍历，如果张三是最后一位，则要遍历10000次 如果按字母首字母去查找的话，则首先在10000个人当中找到首字母为Z的人，假如是100个人，那最快的情况也只用遍历1.
算法设计与分析期末复习
weixin_44019380的博客
11-27 2062
算法分析与设计 期末复习
算法设计与分析期末复习题（史上最详细）
热门推荐
weixin_43474701的博客
06-07 8万+
算法设计与分析期末复习题（一） 1、二分搜索算法是利用（ A ）实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 2、下列不是动态规划算法基本步骤的是（ A ）。 A、找出最优解的性质 B、构造最优解 C、算出最优解 D、定义最优解 3、最大效益优先是（ A ）的一搜索方式。 A、分支界限法 B、动态规划法 C、贪心法 D、回溯法 4、最长公共子序列算法利用的算法是（ B ）。 A、
机器学习常见算法
一个小白
09-30 2102
机器学习常见算法 先说算法，其实算法是个很大的概念，除了机器学习算法，还有很多非机器学习算法，如编程里解决排序的快排、堆排、冒泡，也是算法。只是机器学习太火了，一提算法，多想到的是机器学习算法。 1.决策树 决策树，一种预测模型，代表的是对象属性与对象值之间的一种映射关系。 一般来讲通过学习样本得到一个决策树，这个决策树能够对新的数据给出正确的分类。 这里举一个简单的例子：比如说，样本...
算法设计与分析期末复习题汇总
qq_44231797的博客
05-11 4386
算法期末复习
《算法分析与设计》复习笔记
qq_46485137的博客
01-13 5989
算法是由若干条指令组成的有穷序列，具有5个特性：确定性、能行性、输入、输出、有穷性●P类问题是多项式时间内可解的●NP类问题是多项式时间内可验证●存在这样一个NP问题，所有的NP问题都可以约化成它。这种问题不只一个，它有很多个，它是一类问题。这一类问题就是NPC 问题。其定义要满足2个条件：➢它是一个NP问题；➢所有NP问题都能规约到它。●满足NPC问题定义的第二条而不满足第一条。即所有的NP问题都能约化到它，但是他不一定是一个NP问题。问题A可以规约为B（记作A≤pB）
算法复习1
08-08
总的来说，算法复习涵盖了许多基本和高级的算法概念，从基础的排序和搜索算法到复杂的数据结构和问题解决策略。掌握这些算法及其应用场景，对于理解和解决实际问题至关重要。通过深入学习和实践，我们可以更有效地...
面试算法必刷题-算法复习.pdf
04-05
本文件中提到的“面试算法必刷题-算法复习.pdf”强调了几个关键的数据结构和算法知识点，下面我将详细解释这些内容。 首先，数组和链表是数据结构存储方式的两种基本形态。数组是顺序存储的结构，其优点在于可以...
内部资料——算法复习整理.doc
11-26
递归在算法设计中非常常见，如阶乘、斐波那契数列、 Ackermann 函数、全排列和整数划分等。然而，递归算法可能导致效率低下，因为它们可能需要重复计算相同的子问题，消耗更多时间和空间。为提高效率，可以将递归...
山东大学算法复习资料合集
12-10
【算法复习资料合集概述】 本压缩包"山东大学算法复习资料合集"是一份针对山东大学算法课程的全面复习资源，旨在帮助学生系统性地掌握和复习算法知识。资料内容丰富，包括了历年试题、复习笔记以及课后习题答案，是...
算法复习提纲
07-23
算法复习提纲中的知识点涵盖了算法设计与分析的核心概念，具体知识点如下： 1. 基本概念与时间复杂度 - 渐进上界（Big O Notation）：描述算法时间复杂度的上限，用于表示算法运行时间的增长上限。 - 渐进下界...
考研数据结构——C语言实现小顶堆
weixin_58879477的博客
09-24 332
C语言实现小顶堆
java 冒泡排序
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
09-25 335
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。这个算法的名字由来是因为越小（或越大）的元素会经由交换慢慢“浮”到数列的顶端。作为参数，并对其进行排序。排序是通过两层嵌套的循环实现的：外层循环控制排序的总轮数，内层循环负责在每一轮中进行实际的比较和交换操作。每完成一轮冒泡，最大的元素就被放到了它应该在的位置，因此下一轮冒泡时可以少比较一次。注意，冒泡排序的平均时间复杂度和最坏时间复杂度都是 O(n^2)，其中 n 是数组的长度。
【C语言零基础入门篇 - 17】：排序算法
Oh_Python的博客
09-23 598
插入排序的规则是：第一轮开始时默认序列中第一个数据是有序的，之后各个数据以此为基准，判断是插入在此数据的前面还是后面，之后的数据依次向后移动，腾出位置，让数据插入，以此类推，直到整个序列有序为止。如果在一组需要排序的数据序列中，数据ki和kj的值相同，即ki= =kj，且在排序前ki在序列中的位置领先于kj，那么当排序后，如果ki和kj的相对前后次序保持不变，即ki仍然领先于kj，则称此类排序算法。递增排序（升序）后 0、1、2、3、4、5、6、7、8、9。原始数据：8、6、5、4、9、7、1、2、3。
Java：插入排序
最新发布
xiaochuan_bsj的博客
09-28 327
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳 定的；直接插入排序是稳定的，由上面图片能看到它是具有稳定性的，但如果是代码部分的 arr[j] > tmp 改为：arr[j] >= tmp，以上面的2a和2b为例，它们的顺序就会发生变化。所谓的排序，就是使一串记录，按照某个或某些关键字的大小，递增或递减的排列起来的操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值