手写一些常见算法

news2025/3/14 14:47:24

手写一些常见算法

    • 快速排序
    • 归并排序
    • Dijkstra
    • 自定义排序
    • 交替打印0和1
    • 冒泡排序
    • 插入排序
    • 堆排序

快速排序

public class Main {
    public static void main(String[] args) {
        int nums[] = {1,3,2,5,4,6,8,7,9};
        quickSort(nums,0,nums.length - 1);
    }
    private static void quickSort(int[] nums, int left, int right) {
        if(left >= right)
            return;
        // 划分数组 得到以privot为中心的数组 左小于privot 右大于privot
        int privot = partition(nums, left, right);
        // 递归左边和右边
        quickSort(nums, left, privot - 1);
        quickSort(nums,privot + 1, right);
    }

    private static int partition(int[] nums, int left, int right) {
        // 选基准
        int p = nums[right];
        // 指向大于等于基准元素的前一个位置
        int l = left - 1;
        for(int r = 0; r < right; r++){
            if(nums[r] < p){
                l++;
                int tmp = nums[r];
                nums[r] = nums[l];
                nums[l] = tmp;
            }
        }
        // 再对基准元素放置l+1处，因为l是指向前一个大于等于基准的位置
        nums[right] = nums[l + 1];
        nums[l + 1] = p;
        return l + 1;
    }
}

归并排序

public class QuickAndMerge {
    static int res = 0;
    public static void main(String[] args) {
        int nums[] = {1,3,2,5,4,6,8,7,9};
        int res[] = mergeSort(nums, 0, nums.length - 1);
        quickSort(nums,0,nums.length - 1);
    }
    private static int[] mergeSort(int nums[], int left, int right){
    	// 当排序长度为1，直接返回对应元素
        if(left == right)
            return new int[]{nums[left]};
        // 划分
        int mid = (right - left)/2 + left;
        int l[] = mergeSort(nums, left, mid);
        int r[] = mergeSort(nums, mid + 1, right);
        return mergeTwoArray(l,r);
    }
    private static int[] mergeTwoArray(int l[], int r[]){
        int res[] = new int[l.length + r.length];
        int num = 0;
        int l_num = 0;
        int r_num = 0;
        // 依次选取两数组中较小的元素
        while(l_num < l.length && r_num < r.length){
            res[num++] = l[l_num] < r[r_num] ? l[l_num++]:r[r_num++];
        }
        // 处理剩余元素
        while(l_num < l.length){
            res[num++] = l[l_num++];
        }
        while(r_num < r.length){
            res[num++] = r[r_num++];
        }
        return res;
    }

Dijkstra

public class Main{
    public static void main(String[] args) {
        int n = Integer.MAX_VALUE/2;
        int node[] = {1,2,3,4,5};
        int matrix[][] = new int[node.length + 1][node.length + 1];
        matrix[1] = new int[]{n, 0, 1, n, 3, n};
        matrix[2] = new int[]{n, n, 0, 3, 1, n};
        matrix[3] = new int[]{n, n, n, 0, n, 1};
        matrix[4] = new int[]{n, n, n, 1, 0, n};
        matrix[5] = new int[]{n, n, n, n, n, 0};
        // 求1到其它点的最短距离
        int distance[] = {n, 0, n, n, n, n};
        // 每次从一点开始搜索
        boolean accessed[] = new boolean[node.length + 1];
        // 共node.length个点
        for(int i = 0; i < node.length; i++){
            int curIndex = findMin(distance, accessed);
            accessed[curIndex] = true;
            // 如果有更短路径则更新
            for(int j = 1; j < distance.length; j++){
                if(curIndex != j && distance[j] > matrix[curIndex][j] + distance[curIndex]){
                    distance[j] = matrix[curIndex][j] + distance[curIndex];
                }
            }
        }
        System.out.println(distance[5]);
    }
    // 找最小distance的一个，易得起始节点到此点的距离已最小，可以开始对其邻居进行访问
    private static int findMin(int[] distance, boolean[] accessed) {
        int index = 1;
        int min = Integer.MAX_VALUE;
        for(int i = 1; i < distance.length; i++){
        if(!accessed[i] && min > distance[i]){
            min = distance[i];
            index = i;
        }
        }
        return index;
    }
}

自定义排序

import java.util.Arrays;
import java.util.Comparator;
public class Student{
    int score;
    int age;
    Student(int score, int age){
        this.score = score;
        this.age = age;
    }
    public int getScore() {return score;}
    public void setNum(int score) {
        this.score = score;
    }
    public int getAge() {return age;}
    public void setAge(int age) {
        this.age = age;
    }
    public static void main(String[] args) {
            Student stu[] = new Student[3];
            stu[0] = new Student(1,2);
            stu[1] = new Student(1,0);
            stu[2] = new Student(2,0);
            // 写法1 匿名内部类
            Arrays.sort(stu, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                if(o1.getScore() != o2.getScore())
                    return o2.getScore() - o1.getScore();
                return o1.getAge() - o2.getAge();
            }
            });
            
            // 写法2 lambda
            Arrays.sort(stu, ((o1, o2) -> {
                if(o1.getScore() != o2.getScore())
                    return o2.getScore() - o1.getScore();
                return o1.getAge() - o2.getAge();
            }));
            
            // 写法3
            Arrays.sort(stu, Comparator.comparing(Student::getScore)
                .reversed()
                .thenComparing(Student::getAge));
    }
}

交替打印0和1

public class Main{
    private static final Object lock = new Object();
    private static int count = 0;
    private static final int MAX = 200;
    public static void main(String[] args) {
        // 创建线程 将实现了Runnable接口的printer放入，start启动
        Thread thread1 = new Thread(new Printer(), "线程1");
        Thread thread2 = new Thread(new Printer(), "线程2");
        thread1.start();
        thread2.start();
    }
    static class Printer implements Runnable {
        // 重写Run方法
        @Override
        public void run() {
            while (true) {
                // synchronized
                synchronized (lock) {
                    // 打印完成
                    if (count > MAX) {
                        break;
                    }
                    System.out.println(Thread.currentThread().getName() + "打印数字: " + count++);
                    // 唤醒等待锁的线程
                    lock.notify();
                    try {
                        if (count <= MAX) {
                            lock.wait();
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }
}

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int bubble[] = {8,7,6,5,4,3,2,1};
        //bubbleSort(bubble);
        bubbleSortDesc(bubble);
    }
    private static void bubbleSort(int[] bubble) {
        for(int i = 0; i < bubble.length; i++){
            int flag = 0;
            for(int j = 0; j < bubble.length - i - 1; j++){
                if(bubble[j] < bubble[j + 1]){
                    swap(bubble, j, j + 1);
                    flag = 1;
                }
            }
            if(flag == 0)
                break;
        }
    }
    private static void bubbleSortDesc(int[] bubble) {
        for(int i = 0; i < bubble.length; i++){
            int flag = 0;
            for(int j = 0; j < bubble.length - i - 1; j++){
                if(bubble[j] > bubble[j + 1]){
                    swap(bubble, j, j + 1);
                    flag = 1;
                }
            }
            if(flag == 0)
                break;
        }
    }
    private static void swap(int bubble[], int i, int j){
        int temp = bubble[i];
        bubble[i] = bubble[j];
        bubble[j] = temp;
    }
}

插入排序

public class InsertSort {
    public static void main(String[] args) {
        int insert[] = {1,4,2,6,3,5,8,7};
        insertSort(insert);
    }
    private static void insertSort(int[] insert) {
        for(int i = 1; i < insert.length; i++){
            int i2 = i;
            int temp = insert[i2];
            while (i2 > 0 && temp < insert[i2 - 1]){
                insert[i2] = insert[i2 - 1];
                i2--;
            }
            insert[i2] = temp;
        }
    }
}

堆排序

public class HeapSort {
    public static void main(String[] args) {
        int nums[] = {1,3,4,2,6,5};
        heapSort(nums);
    }
    public static void heapSort(int[] nums) {
        int n = nums.length;
        // 挑整数组位置，使得父节点大于子节点，从最后一个非叶子节点开始
        for (int i = n / 2 - 1; i >= 0; i--) {
            adjust(nums, n, i);
        }
        // 依次从堆中提取元素，
        for (int i = n - 1; i > 0; i--) {
            // 将当前父节点移动到末尾
            int tmp = nums[0];
            nums[0] = nums[i];
            nums[i] = tmp;
            // 移动到末尾后继续调整堆
            adjust(nums, i, 0);
        }
    }
    private static void adjust(int[] nums, int n, int i) {
         // i表示父节点
        int largest = i;
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点
        // 如果左子节点大于根节点
        if (left < n && nums[left] > nums[largest]) {
            largest = left;
        }
        // 如果右子节点大于当前最大值
        if (right < n && nums[right] > nums[largest]) {
            largest = right;
        }
        // 如果最大值不是根节点 交换节点位置，使得较大一方到父节点位置
        if (largest != i) {
            int tmp = nums[i];
            nums[i] = nums[largest];
            nums[largest] = tmp;
            // 调整交换后子节点所在的子树
            adjust(nums, n, largest);
        }
    }
}

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

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

相关文章

使用DeepSeek完成一个简单嵌入式开发

使用DeepSeek完成一个简单嵌入式开发

开启DeepSeek对话 请帮我使用Altium Designer设计原理图、PCB&#xff0c;使用keil完成代码编写&#xff1b;要求&#xff1a;使用stm32F103RCT6为主控芯片&#xff0c;控制3个流水灯的原理图 这里需要注意&#xff0c;每次DeepSeek的回答都不太一样。 DeepSeek回答 以下是使…
阅读更多...
关于我和快速幂的事（）

关于我和快速幂的事（）

我之前只会这样的(dfs&#xff09;&#xff1a; 不懂下面这种写法的具体逻辑&#xff1a; 看完下面的推理&#xff0c;再转转我聪明的小老戴&#xff1a; 法一中&#xff1a;把2^11看成(2^5)^2 法二中&#xff1a;把2^11看成(2^2)^5
阅读更多...
【鸿蒙开发】Hi3861学习笔记- GPIO之直流电机

【鸿蒙开发】Hi3861学习笔记- GPIO之直流电机

00. 目录 文章目录 00. 目录01. GPIO概述02. 直流电机概述03. ULN2003模块概述04. 硬件设计05. 软件设计06. 实验现象07. 附录 01. GPIO概述 GPIO&#xff08;General-purpose input/output&#xff09;即通用型输入输出。通常&#xff0c;GPIO控制器通过分组的方式管理所有GP…
阅读更多...
mapbox高阶，结合threejs（threebox）添加extrusion挤出几何体，并添加侧面窗户贴图和楼顶贴图，同时添加真实光照投影

mapbox高阶，结合threejs（threebox）添加extrusion挤出几何体，并添加侧面窗户贴图和楼顶贴图，同时添加真实光照投影

👨‍⚕️ 主页： gis分享者 👨‍⚕️ 感谢各位大佬 点赞👍 收藏⭐ 留言📝 加关注✅! 👨‍⚕️ 收录于专栏：mapbox 从入门到精通 文章目录 一、🍀前言1.1 ☘️mapboxgl.Map 地图对象1.2 ☘️mapboxgl.Map style属性1.3 ☘️threebox extrusion挤出几何体1.3 ☘️…
阅读更多...
python-leetcode-叶子相似的树

python-leetcode-叶子相似的树

872. 叶子相似的树 - 力扣&#xff08;LeetCode&#xff09; 下面是一个完整的 Python 函数&#xff0c;接收两个二叉树的根节点 root1 和 root2&#xff0c;返回它们是否叶相似。 代码实现 class TreeNode:def __init__(self, val0, leftNone, rightNone):self.val valself…
阅读更多...
＜03.13＞八股文补充知识

＜03.13＞八股文补充知识

import java.lang.reflect.*; public class Main {public static void main(String[] args) throws Exception {// 获取 Class 对象//1. 通过类字面量Class<?> clazz Person.class;//2 通过对象实例化String str "Hello";Class<?> clazz_str str.ge…
阅读更多...
2025探索短剧行业新可能报告40+份汇总解读|附PDF下载

2025探索短剧行业新可能报告40+份汇总解读|附PDF下载

原文链接&#xff1a;https://tecdat.cn/?p41043 近年来&#xff0c;短剧以其紧凑的剧情、碎片化的观看体验&#xff0c;迅速吸引了大量用户。百度作为互联网巨头&#xff0c;在短剧领域积极布局。从早期建立行业专属模型冷启动&#xff0c;到如今构建完整的商业生态&#xf…
阅读更多...
STM32 内置的通讯协议

STM32 内置的通讯协议

数据是以帧为单位发的 USART和UART的区别就是有没有同步功能 同步是两端设备有时钟连接&#xff0c;异步是没时钟连接&#xff0c;靠约定号的频率&#xff08;波特率&#xff09;接收发送数据 RTS和CTS是用来给外界发送已“可接收”或“可发送”信号的&#xff0c;一般用不到…
阅读更多...
信息安全访问控制、抗攻击技术、安全体系和评估（高软42）

信息安全访问控制、抗攻击技术、安全体系和评估（高软42）

系列文章目录 信息安全访问控制、抗攻击技术、安全体系和评估 文章目录 系列文章目录前言一、信息安全技术1.访问控制2.抗攻击技术 二、欺骗技术1.ARP欺骗2.DNS欺骗3.IP欺骗 三、抗攻击技术1.端口扫描2.强化TCP/IP堆栈 四、保证体系和评估1.保证体系2.安全风险管理 五、真题在…
阅读更多...
晋升系列4：学习方法

晋升系列4：学习方法

每一个成功的人&#xff0c;都是从底层开始打怪&#xff0c;不断的总结经验&#xff0c;一步一步打上来的。在这个过程中需要坚持、总结方法论。 对一件事情长久坚持的人其实比较少&#xff0c;在坚持的人中&#xff0c;不断的总结优化的更少&#xff0c;所以最终达到高级别的…
阅读更多...
脑电波控制设备：基于典型相关分析（CCA）的脑机接口频率精准解码方法

脑电波控制设备：基于典型相关分析（CCA）的脑机接口频率精准解码方法

文章目录 前言一、CCA的用途二、频率求解思路三、输入数据结构四、判断方法五、matlab实践1.数据集获取及处理2.matlab代码3.运行及结果 六、参考文献 前言 在脑机接口(BCI)领域&#xff0c;有SSVEP方向&#xff0c;中文叫做稳态视觉诱发电位&#xff0c;当人观看闪烁的视觉刺激…
阅读更多...
Android Spinner总结

Android Spinner总结

文章目录 Android Spinner总结概述简单使用自定义布局自定义Adapter添加分割线源码下载 Android Spinner总结 概述 在 Android 中&#xff0c;Spinner 是一个下拉选择框。 简单使用 xml布局&#xff1a; <Spinnerandroid:id"id/spinner1"android:layout_width&…
阅读更多...
element-ui layout 组件源码分享

element-ui layout 组件源码分享

layout 布局组件源码分享&#xff0c;主要从以下两个方面&#xff1a; 1、row 组件属性。 2、col 组件属性。 一、row 组件属性。 1.1 gutter 栅栏间隔&#xff0c;类型为 number&#xff0c;默认 0。 1.2 type 布局模式&#xff0c;可选 flex&#xff0c;现代浏览器下有效…
阅读更多...
OBJ文件生成PCD文件（python 实现）

OBJ文件生成PCD文件（python 实现）

代码实现 将 .obj 文件转换为 .pcd&#xff08;点云数据&#xff09; 代码文件。 import open3d as o3d# 加载 .obj 文件 mesh o3d.io.read_triangle_mesh("bunny.obj")# 检查是否成功加载 if not mesh.has_vertices():print("无法加载 .obj 文件&#xff0c…
阅读更多...
c++介绍智能指针 十二（1）

c++介绍智能指针 十二（1）

普通指针&#xff1a;指向内存区域的地址变量。使用普通指针容易出现一些程序错误。 如果一个指针所指向的内存区域是动态分配的&#xff0c;那么这个指针变量离开了所在的作用域&#xff0c;这块内存也不会自动销毁。动态内存不进行释放就会导致内存泄露。如果一个指针指向已…
阅读更多...
Appium等待机制--强制等待、隐式等待、显式等待

Appium等待机制--强制等待、隐式等待、显式等待

书接上回&#xff0c;Appium高级操作--其他操作-CSDN博客文章浏览阅读182次&#xff0c;点赞6次&#xff0c;收藏7次。书接上回Appium高级操作--从源码角度解析--模拟复杂手势操作-CSDN博客。https://blog.csdn.net/fantasy_4/article/details/146162851主要讲解了Appium的一些…
阅读更多...
计算机视觉cv2入门之图像的读取,显示,与保存

计算机视觉cv2入门之图像的读取,显示,与保存

在计算机视觉领域&#xff0c;Python的cv2库是一个不可或缺的工具&#xff0c;它提供了丰富的图像处理功能。作为OpenCV的Python接口&#xff0c;cv2使得图像处理的实现变得简单而高效。 示例图片 目录 opencv获取方式 图像基本知识 颜色空间 RGB HSV 图像格式 BMP格式 …
阅读更多...
【QT】事件系统入门——QEvent 基础与示例

【QT】事件系统入门——QEvent 基础与示例

一、事件介绍 事件是 应用程序内部或者外部产生的事情或者动作的统称 在 Qt 中使用一个对象来表示一个事件。所有的 Qt 事件均继承于抽象类 QEvent。事件是由系统或者 Qt 平台本身在不同的时刻发出的。当用户按下鼠标、敲下键盘&#xff0c;或者是窗口需要重新绘制的时候&…
阅读更多...
5-27 临摹大师-IP-Adapter

5-27 临摹大师-IP-Adapter

前言&#xff1a; 前一节我们主要介绍ControlNet中如何对黑白照片进行上色 主要介绍ControlNet中的IP-Adapter。这个也是一种类似的风格借鉴&#xff0c;类似Reference的能力。 当然IP-Adapter有两点或许可以吸引我们&#xff0c;一个是国人腾讯公司制作的。另一个在速度和效…
阅读更多...
Spring MVC面试题（一）

Spring MVC面试题（一）

1.什么是Spring MVC&#xff1f; 全称为Model View Controller&#xff0c;Spring MVC是Spring的一个模块&#xff0c;基于MVC架构模式的一个框架 2.Spring MVC优点&#xff1f; 1.可用各种视图技术&#xff0c;不仅限于JSP 2.支持各种请求资源映射策略 3. Spring MVC工作原…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023