经典算法（查找与排序）

查找

  1. 顺序查找

顺序查找（Linear Search）是一种在有序数组中查找目标元素的基本算法。它的时间复杂度为 O(n)，适用于查找少量数据。顺序查找的基本思想是从数组的第一个元素开始，逐个与待查找的元素进行比较，直到找到目标元素或遍历完整个数组。

package com.zhx;public class Test {//顺序查找public static int seqSearch(int[] array, int target) {for (int i = 0; i < array.length; i++) {int p = array[i];if (p == target) {System.out.println("sucess to find out "+target+" from array, index="+i);return i;}}System.out.println("fail to find out the target");return -1;}public static void main(String[] args) {int[] data = { 3, 6, 7, 2, 12, 9, 0, 11 };System.out.println(seqSearch(data, 12));}
}
  1. 折半查找
    折半查找（Binary Search）是一种在有序数组中查找目标元素的高效算法。它的时间复杂度为 O(logn)，常用于查找大量数据。折半查找的基本思想是将待查找的范围逐步缩小，每次将范围缩小一半。前提是数组有序。
package com.zhx;public class Test1 {//折半查找public static int seqSearch(int[] array, int target) {int lo = 0;int hi = array.length - 1;while (lo <= hi) {int mid = lo + (hi - lo) / 2;if (target < array[mid]) {hi = mid - 1;} else if (target > array[mid]) {lo = mid + 1;} else {return mid;}}return -1;}public static void main(String[] args) {int[] data = { 10, 11, 12, 16, 18, 23, 29, 33, 48, 54, 57, 68, 77, 84, 98 };System.out.println(seqSearch(data, 23));}
}

排序

  1. 冒泡排序
    冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
import java.util.Arrays;public class Test {public static void bubbleSort(int[] arr) {for (int i = 1; i < arr.length; i++) {// i=1, j=4// i=2, j=3// i=3, j=2// j=arr.length-1-ifor (int j = 0; j <= arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}public static void main(String[] args) {int[] arr = { 9, 8, 5, 4, 2, 0 };bubbleSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 快速排序

快速排序（Quick Sort）是一种分治策略（Divide and Conquer）的排序算法。它通过选取一个基准元素（pivot），将数组分为两个子数组，其中一个子数组的元素都小于基准元素，另一个子数组的元素都大于基准元素。然后对这两个子数组分别进行递归排序。当整个数组所有元素有序时，排序完成。

package com.zhx;import java.util.Arrays;public class QuickSort {public static void quickSort(int[] arr, int low, int high) {if (low < high) {// 1. 定义基准pivot,int pivot = arr[low];// ...... pivot移动到中间，左边都比pivot小，后边都比pivot大, indexint i = low;int j = high;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}// 交换swap(arr, i, j);while (i < j && arr[i] <= pivot) {i++;}// 交换swap(arr, i, j);}// 2. 递归对左右2部分快排quickSort(arr, low, j - 1);quickSort(arr, j + 1, high);}}public static void swap(int arr[], int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}public static void main(String[] args) {int[] arr = { 5, 3, 7, 6, 4, 1, 0, 2, 9, 10, 8 };quickSort(arr, 0, arr.length - 1);System.out.println(Arrays.toString(arr));}
}
  1. 插入排序
    插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是将待排序的元素一个一个地插入到已经排序好的序列中的适当位置。插入排序在实现上，通常采用 in-place 排序（即只需用到 O(1) 的额外空间的排序），因而在从后向前排序的过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
package com.zhx;import java.util.Arrays;public class SortTest {public static void InsertSort(int[] arr) {for (int i = 1; i < arr.length; i++) {for (int j = i; j > 0; j--) {if (arr[j] < arr[j - 1]) {int temp = arr[j];arr[j] = arr[j - 1];arr[j - 1] = temp;} else {break;}}}}public static void main(String[] args) {int[] arr = { 7, 6, 9, 3, 1, 5, 2, 4 };InsertSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 希尔排序

希尔排序（Shell Sort）是一种插入排序的算法，它的主要思想是使数组中任意间隔为 h 的元素都是有序的。这样的数组被称为 h 有序数组。希尔排序会不断减小 h 的值，直到最后 h=1 时，所有元素就都是有序的了。

package com.zhx;import java.util.Arrays;
public class SortTest {public static void shellSort(int[] arr) {// 增量gap, 并逐步的缩小增量for (int gap = arr.length / 2; gap > 0; gap /= 2) {// 从第gap个元素，逐个对其所在的组进行直接插入排序for (int i = gap; i < arr.length; i++) {for (int j = i; j >= gap; j -= gap) {if (arr[j] < arr[j - gap]) {int temp = arr[j];arr[j] = arr[j - gap];arr[j - gap] = temp;} else {break;}}}}}public static void main(String[] args) {int[] arr = { 8, 9, 1, 7, 2, 3, 5, 4, 6, 0 };shellSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 选择排序
    选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，将其与待排序的数据序列的最前面（或最后面）的元素进行交换，然后缩小待排序数据序列的范围，直到全部待排序的数据元素都排好序为止。
package com.zhx;import java.util.Arrays;
public class SortTest {//选择排序public static void selectionSort(int[] arr) {int len = arr.length;int minIndex, temp;for (int i = 0; i < len - 1; i++) { //最后一个数不用排序minIndex = i;for (int j = i + 1; j < len; j++) {if (arr[j] < arr[minIndex]) { // 寻找最小的数minIndex = j; // 将最小数的索引保存}}temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}}public static void main(String[] args) {int[] arr = { 29, 38, 65, 87, 78, 23, 27, 29 };selectionSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 堆排序

堆排序（Heap Sort）是一种基于二叉堆（Binary Heap）的选择排序算法。它的基本思想是：将待排序的序列构造成一个大顶堆（或小顶堆），此时整个序列的最大值（或最小值）就是堆顶的根节点。然后将其与末尾元素进行交换，得到当前最大（或最小）值。接着调整剩余元素，使其满足堆的性质，然后继续重复这个过程，直到所有元素排好序。

大顶堆（Big Heap）和小顶堆（Little Heap）是两种不同的堆结构，它们在计算机科学中有着广泛的应用。
大顶堆：在大顶堆中，每个节点都大于或等于其子节点。换句话说，大顶堆满足以下条件：
对于任意的节点 i，有 arr[i] >= arr[2 * i] 和 arr[i] >= arr[2 * i + 1]。
小顶堆：在小顶堆中，每个节点都小于或等于其子节点。换句话说，小顶堆满足以下条件：
对于任意的节点 i，有 arr[i] <= arr[2 * i] 和 arr[i] <= arr[2 * i + 1]。
大顶堆和小顶堆的主要区别在于节点之间的顺序关系。大顶堆的特点是父节点大于子节点，而小顶堆的特点是父节点小于子节点。
在 Java 编程中，我们可以使用数组来表示堆结构。对于大顶堆，我们可以使用以下方法维护堆性质：

  1. 构造大顶堆：从数组的最后一个元素开始，逐个将元素向上调整，使其满足大顶堆的性质。
  2. 调整大顶堆：对于任意的节点 i，将节点 i 与其子节点进行比较，如果节点 i 的值小于其子节点的值，则交换它们的位置。然后继续调整子节点，使其满足大顶堆的性质。
    类似地，对于小顶堆，我们可以使用以下方法维护堆性质：
  3. 构造小顶堆：从数组的最后一个元素开始，逐个将元素向上调整，使其满足小顶堆的性质。
  4. 调整小顶堆：对于任意的节点 i，将节点 i 与其子节点进行比较，如果节点 i 的值大于其子节点的值，则交换它们的位置。然后继续调整子节点，使其满足小顶堆的性质。
    大顶堆和小顶堆在排序算法、数据结构以及实际应用中都有广泛的应用。例如，在 Java 中的优先队列（PriorityQueue）就是基于大顶堆实现的。
package com.zhx;import java.util.Arrays;public class HeapSort {public static void main(String[] args) {int[] arr = { 27, 46, 12, 33, 49, 27, 36, 40, 42, 50, 51 };heapSort(arr);System.out.println(Arrays.toString(arr));}public static void heapSort(int[] arr) {// 建最大堆（arr数组本身就可以看做是一个二叉堆，下面需要将arr变成一个最大堆）/** 1、第一个非叶子节点的下标为：arr.length/2-1* 2、从第一个非叶子节点开始，遍历每一个非叶子节点，使它们都成为最大堆*/for (int i = arr.length / 2 - 1; i >= 0; i--) {heapify(arr, i, arr.length - 1);}for (int i = arr.length - 1; i > 0; i--) {//将arr数组的第一个元素（因为此元素是最大堆顶点）与数组最后一个元素交换（因为是升序）swap(arr, 0, i);//交换之后arr不是最大堆了（i已经排好序了，不用考虑）heapify(arr, 0, i - 1);}}//将i节点变成一个最大堆public static void heapify(int[] arr, int i, int last_index) {int max = i;if (2 * i + 1 <= last_index && arr[2 * i + 1] > arr[max]) {max = 2 * i + 1;// max记为左节点}if (2 * i + 2 <= last_index && arr[2 * i + 2] > arr[max]) {max = 2 * i + 2;// max记为右节点}if (max != i) {// 将i节点与它的最大子节点进行交换swap(arr, max, i);// 递归对调用的子节点进行heapifyheapify(arr, max, last_index);}}public static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}
  1. 归并排序
    归并排序（Merge Sort）是一种分治算法，它的基本思想是将一个数组（或列表）分成两半，将两半分别排序，然后将排序后的两半合并起来。
package com.zhx;import java.util.Arrays;public class MergeSort {public static void mergeSort(int arr[], int[] temp, int low, int high) {if (low < high) {// 分2部分int mid = (low + high) / 2;// 1. 对左边进行归并排序mergeSort(arr, temp, low, mid);// 2. 对右边进行归并排序mergeSort(arr, temp, mid + 1, high);// 3. 合并左右两个有序集合merge(arr, temp, low, mid, high);}}public static void merge(int[] arr, int[] temp, int low, int mid, int high) {int i = low;        //设置左指针初始位置int j = mid + 1;    //设置右指针初始位置int k = 0;          //临时数组指针while (i <= mid && j <= high) {if (arr[i] <= arr[j]) {temp[k++] = arr[i++];} else {temp[k++] = arr[j++];}}// 左边有剩余，将左边剩余的填入tempwhile (i <= mid) {temp[k++] = arr[i++];}// 右边有剩余，将右边剩余的填入tempwhile (j <= high) {temp[k++] = arr[j++];}// 将临时数组，从头开始拷贝到arr中k = 0;while (low <= high) {arr[low++] = temp[k++];}}public static void main(String[] args) {int[] arr = { 8, 4, 5, 7, 1, 3, 6, 2 };// 辅助数组int[] temp = new int[arr.length];mergeSort(arr, temp, 0, arr.length - 1);System.out.println(Arrays.toString(arr));}
}
  1. 计数排序
    计数排序（Counting Sort）是一种线性时间复杂度的排序算法，适用于处理整数类型的数据。它的工作原理是根据输入数据的值建立一个计数器数组，然后根据计数器数组的值将原始数据重新排列。
package com.zhx;import java.util.Arrays;
public class CountSort {public static void countSort(int[] arr) {// 找到最大值int max = arr[0];for (int i = 0; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}// 找到最小值int min = arr[0];for (int i = 0; i < arr.length; i++) {if (arr[i] < min) {min = arr[i];}}// 创建计数数组int[] count = new int[max - min + 1];for (int i = 0; i < arr.length; i++) {count[arr[i] - min]++;}int k = 0;// 往数组中输出for (int i = 0; i < count.length; i++) {while (count[i] > 0) {arr[k++] = i + min;count[i]--;}}}public static void main(String[] args) {int[] arr = { 108, 109, 106, 101, 107, 102, 103, 102, 104, 106, 101, 110 };countSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 桶排序
    桶排序（Bucket Sort）是一种线性时间复杂度的排序算法，适用于处理整数类型的数据。它的工作原理是将原始数据分成若干个桶，然后对每个桶内的数据进行排序，最后将所有桶内的数据依次取出，得到排序后的序列。
package com.zhx;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;public class BucketSort {public static void bucketSort(int[] arr) {// 找到数组的最大值int max = arr[0];for (int i = 0; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}// 找到数组的最小值int min = arr[0];for (int i = 0; i < arr.length; i++) {if (arr[i] < min) {min = arr[i];}}// 创建桶的容器ArrayList<ArrayList<Integer>> list = new ArrayList<>();// 确定桶的数量int count = (max - min) / arr.length + 1;for (int i = 0; i < count; i++) {list.add(new ArrayList<Integer>());}// 往桶里放for (int i = 0; i < arr.length; i++) {list.get((arr[i] - min) / arr.length).add(arr[i]);}// 给每个桶排序for (int i = 0; i < list.size(); i++) {Collections.sort(list.get(i));}// 把桶里的内容输出int k = 0;for (int i = 0; i < list.size(); i++) {ArrayList<Integer> bucket = list.get(i);for (int j = 0; j < bucket.size(); j++) {arr[k++] = bucket.get(j);}}}public static void main(String[] args) {int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };bucketSort(arr);System.out.println(Arrays.toString(arr));}
}
  1. 基数排序
    基数排序（Radix Sort）是一种非对比排序算法，适用于处理整数和小数。它的工作原理是根据数字的位数进行分组，然后对每组数据进行递归排序。
    方法一：
package com.zhx;import java.util.Arrays;public class RadixSort {public static void main(String[] args) {int[] arr = {26,3,49,556,81,9,863,0};radixSort(arr);System.out.println(Arrays.toString(arr));}private static void radixSort(int[] arr) {//待排序列最大值int max = arr[0];int exp;//指数//计算最大值for (int anArr : arr) {if (anArr > max) {max = anArr;}}//从个位开始，对数组进行排序for (exp = 1; max / exp > 0; exp *= 10) {//存储待排元素的临时数组int[] temp = new int[arr.length];//分桶个数int[] buckets = new int[10];//将数据出现的次数存储在buckets中for (int value : arr) {//(value / exp) % 10 :value的最底位(个位)buckets[(value / exp) % 10]++;}//更改buckets[i]，记录当前位置i的元素累计记数，方便对应到数组temp中的位置for (int i = 1; i < 10; i++) {buckets[i] += buckets[i - 1];}//从后向前，将数据存储到临时数组temp中for (int i = arr.length - 1; i >= 0; i--) {temp[buckets[(arr[i] / exp) % 10] - 1] = arr[i];buckets[(arr[i] / exp) % 10]--;}//将有序元素temp赋给arrSystem.arraycopy(temp, 0, arr, 0, arr.length);}}
}

方法二：

package com.zhx;/** 另一种实现方式:* 数组：[26, 3, 49, 556, 81, 9, 863, 0]* 1、创建桶（下标0~9），并以个位数为下标，从第一个元素开始，依次放入桶中。*    0[0]*    1[81]*    2[]*    3[3，863]*    4[]*    5[]*    6[26，556]*    7[]*    8[]*    9[49，9]*    遍历桶，将元素依次取出，完成第一次排序：[0, 81, 3, 863, 26, 556, 49, 9]* 2、以十位数为下标，将完成第一次排序的数组从第一个元素开始，依次放入桶中。*    0[0，3，9]*    1[]*    2[26]*    3[]*    4[49]*    5[556]*    6[863]*    7[]*    8[81]*    9[]*    遍历桶，将元素依次取出，完成第二次排序：[0, 3, 9, 26, 49, 556, 863, 81]* 3、以百位数为下标，将完成第二次排序的数组从第一个元素开始，依次放入桶中。*    0[0，3，9，26，49，81]*    1[]*    2[]*    3[]*    4[]*    5[556]*    6[]*    7[]*    8[863]*    9[]*    遍历桶，将元素依次取出，完成第三次排序：[0, 3, 9, 26, 49, 81, 556, 863]*/
import java.util.ArrayList;
import java.util.Arrays;
public class Test {private static void radixSort(int[] arr) {//查找最大值，确定排序的次数int max = arr[0];for (int anArr : arr) {if (anArr > max) {max = anArr;}}//从个位开始，对数组进行排序for (int exp=1; max/exp>0; exp*=10) {// 创建桶并初始化（桶的下标 0~9）ArrayList<ArrayList<Integer>> buckets = new ArrayList<ArrayList<Integer>>();for(int i=0;i<10;i++) {buckets.add(i,new ArrayList());}// 将数据存储在buckets中for (int value : arr) {buckets.get((value/exp)%10).add(value);}//将每一次排序的结果复制到arr数组中int k=0;for(ArrayList<Integer> list : buckets) {for(Integer num : list) {arr[k++]=num;}}//System.out.println(Arrays.toString(arr));}}public static void main(String[] args) {int[] arr = { 26, 3, 49, 556, 81, 9, 863, 0 };radixSort(arr);System.out.println(Arrays.toString(arr));}
}

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

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

相关文章

AMD64内存属性详解

AMD64内存属性详解

本文参考文档为AMD64 Architecture Programmer’s Manual Volume 2: System Programming&#xff0c;版本号3.41&#xff0c;这不是对原英文文档的翻译&#xff0c;但是所有内容的排版都是根据原手册的排版来的&#xff0c;如有与官方文档冲突的内容&#xff0c;以官方文档为准…
阅读更多...
Ubuntu 配置 Github 的 SSH keys

Ubuntu 配置 Github 的 SSH keys

先进入已有的 Git 目录或使用新建的一个 Git 仓库下。 设置 Github 用户名和邮箱&#xff1a; $ git config --global user.name [Github用户名] $ git config --global user.email [Github认证邮箱]生成 SSH 密钥文件&#xff1a; $ ssh-keygen -t rsa -C [Github认证邮箱]…
阅读更多...
Jmeter_逻辑控制器

Jmeter_逻辑控制器

逻辑控制器 控制取样器执行顺序的组件实现(分支 循环) 分类 1、如果(if) 控制器 分支实现 2、forEach控制器 循环往复实现 3、循环控制器 循环往复实现 如果(if) 控制器 需求1:测试计划中定义一个 http 请求访问百度&#xff0c;但是该请求不是无条件执行的&#xff0c;…
阅读更多...
基于ssm的校园快递物流管理系统(java+jsp+ssm+javabean+mysql+tomcat)

基于ssm的校园快递物流管理系统(java+jsp+ssm+javabean+mysql+tomcat)

博主24h在线&#xff0c;想要源码文档部署视频直接私聊&#xff0c;9.9拿走&#xff01; 基于javawebmysql的ssm校园快递物流管理系统(javajspssmjavabeanmysqltomcat) 运行环境&#xff1a; Java≥8、MySQL≥5.7、Tomcat≥8 开发工具&#xff1a; eclipse/idea/myeclipse/s…
阅读更多...
2023年云计算发展趋势浅析

2023年云计算发展趋势浅析

​​​​​​​ 云计算的概念 云计算是一种通过互联网提供计算资源和服务的模式。它允许用户通过网络访问和使用共享的计算资源&#xff0c;而无需拥有或管理这些资源的物理设备。云计算的核心理念是将计算能力、存储资源和应用程序提供给用户&#xff0c;以便随时随地根据需要…
阅读更多...
【JS 高级之手写原理系列】学习笔记共 15 篇（完结）

【JS 高级之手写原理系列】学习笔记共 15 篇（完结）

这是我在 b 站上面学习的一门课程&#xff0c;个人学习笔记地址&#xff1a;https://github.com/kaimo313/javascript-advanced-handwriting-principles-series 01 # 手写 new 的原理02 # 手写 instanceof 的原理03 # 手写 call04 # 手写 apply05 # 手写 bind06 # 手写 map 方…
阅读更多...
关于变电站综合自动化系统的案例应用分析-安科瑞 蒋静

关于变电站综合自动化系统的案例应用分析-安科瑞 蒋静

摘 要&#xff1a;变电站综合自动化系统是将变电站内的二次设备经过功能的组合和优化设计&#xff0c;利用先进的计算机技术、通信技术、信号处理技术&#xff0c;实现对全变电站的主要设备和输、配电线路的自动监视、测量、控制、保护、并与上级调度通信的综合性自动化功能。 …
阅读更多...
前端小技巧: TS实现EventBus自定义事件

前端小技巧: TS实现EventBus自定义事件

关于EventBus事件总线 事件总线&#xff0c;实现 on, once, emit, off on, once 是注册函数&#xff0c;存储起来emit时找到对应的函数&#xff0c;执行off找到对应的函数&#xff0c;从对象中删除 注意 区分on和onceon绑定的事件可连续执行&#xff0c;除非offonce绑定的函数…
阅读更多...
POD创建与删除简单描述

POD创建与删除简单描述

创建一个 Pod 的过程可以分为以下几个步骤&#xff1a; 用户使用 kubectl create 命令或 YAML 文件向 API 服务器发送创建 Pod 的请求。API 服务器将请求转换为 Kubernetes 的内部对象&#xff0c;并将 Pod 的状态设置为 Pending。调度器根据 Pod 的资源需求和节点的资源情况&…
阅读更多...
linux 内存查看方法：meminfo\maps\smaps\status 文件解析

linux 内存查看方法：meminfo\maps\smaps\status 文件解析

linux 下面查看内存有多种渠道&#xff0c;比如通过命令 ps ,top,free 等&#xff0c;比如通过/proc系统&#xff0c;一般需要比较详细和精确地知道整机内存/某个进程内存的使用情况&#xff0c;最好通过/proc 系统&#xff0c;下面介绍/proc系统下内存相关的几个文件 单个进程…
阅读更多...
4.4.2 结构可以将 string类作为成员吗

4.4.2 结构可以将 string类作为成员吗

// structure template { }; 4.4.2 结构可以将 string类作为成员吗 可以将成员name指定为string类对象而不是字符数组吗?即可以像下面这样声明结构吗? #include <string> struct inflatable std :: string name; float volume; double price; 大体上说,答案是肯定的。实…
阅读更多...
go语言 ｜ 图解反射（一）

go语言 ｜ 图解反射（一）

反射 反射是指在程序运行期对程序本身进行访问和修改的能力 变量的内在机制 变量包含类型信息和值信息 var arr [10]int arr[0] 10 类型信息&#xff1a;是静态的元信息&#xff0c;是预先定义好的 值信息&#xff1a;是程序运行过程中动态改变的 反射的使用 reflect包封…
阅读更多...
在opencv OpenCV中打开相机摄像头，用分水岭算法实时实现图像的分割与提取

在opencv OpenCV中打开相机摄像头，用分水岭算法实时实现图像的分割与提取

import cv2 import numpy as np# 定义回调函数 def callback(x):pass# 打开摄像头 cap cv2.VideoCapture(0)# 创建窗口和控件 cv2.namedWindow(image) cv2.createTrackbar(threshold, image, 0, 255, callback)# 初始化参数 bgdModel np.zeros((1, 65), np.float64) fgdModel…
阅读更多...
C语言动态规划解决0-1背包问题

C语言动态规划解决0-1背包问题

动态规划&#xff08;Dynamic Programming&#xff0c;简称DP&#xff09;是一种在数学、计算机科学和经济学中使用的&#xff0c;通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题&#xff0c;它能够将问题…
阅读更多...
搭建神经网络（torch.nn的用法）

搭建神经网络（torch.nn的用法）

零零碎碎总结了一些torch框架里面nn模块的用法&#xff0c;尤其是关于搭建神经网络的 nn.ModuleList nn.Module nn.Sequential nn.Linear nn.Dropout nn.Embedding nn.DataParallel() 将模型封装起来&#xff0c;便于在多个gpu上并行计算&#xff0c;训练或者推理 nn.…
阅读更多...
MyBatis-Plus--在xml中使用wrapper的方法

MyBatis-Plus--在xml中使用wrapper的方法

原文网址&#xff1a;MyBatis-Plus--在xml中使用wrapper的方法_IT利刃出鞘的博客-CSDN博客 简介 本文介绍MyBatis-Plus如何在xml中使用wrapper。 Service QueryWrapper<T> wrapper new QueryWrapper<T>(); wrapper.eq("r.room_id", vo.getRoomId())…
阅读更多...
量子计算和量子通信技术：引领潜力无限的未来

量子计算和量子通信技术：引领潜力无限的未来

近年来&#xff0c;随着量子计算和量子通信技术的迅速发展&#xff0c;它们在各个领域的广泛应用前景引起了人们的极大兴趣。本文将深入探讨量子计算和量子通信技术的普遍应用&#xff0c;以及它们预示的未来&#xff0c;同时提出业内人士需要注意的事项。 介绍&#xff1a;量子…
阅读更多...
Delphi TCP服务端监听端口获取客户端RFID网络读卡器上传的刷卡数据

Delphi TCP服务端监听端口获取客户端RFID网络读卡器上传的刷卡数据

本示例使用设备介绍&#xff1a;液显WIFI无线网络HTTP协议RFID云读卡器可编程实时可控开关TTS语-淘宝网 (taobao.com) unit Unit1;interfaceusesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, ComCtrls, ScktComp, StdCtrls, ScktCom…
阅读更多...
《数字图像处理-OpenCV/Python》连载（41）图像的旋转

《数字图像处理-OpenCV/Python》连载（41）图像的旋转

《数字图像处理-OpenCV/Python》连载&#xff08;41&#xff09;图像的旋转 本书京东优惠购书链接&#xff1a;https://item.jd.com/14098452.html 本书CSDN独家连载专栏&#xff1a;https://blog.csdn.net/youcans/category_12418787.html 第 6 章 图像的几何变换 几何变换分…
阅读更多...
WordPress Modown 6.2付费下载资源/付费查看内容 wp主题模板+erphpdown11.7

WordPress Modown 6.2付费下载资源/付费查看内容 wp主题模板+erphpdown11.7

模板简介&#xff1a; 自适应响应式设计&#xff0c;兼容主流浏览器 网格样式与瀑布流样式任意切换 内置SEO优化 自带与主题UI完美兼容搭配的erphpdown前端用户中心页面&#xff08;此功能若单独找我们定制也需要几百&#xff09; 收费付费下载资源、付费查看内容、付费观看…
阅读更多...
最新文章

Copyright @ 2022~2023