浅析常用算法(代码演示)

最新推荐文章于 2020-10-26 20:03:22 发布
最新推荐文章于 2020-10-26 20:03:22 发布
阅读量275 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/S_mengyong/article/details/106962614
版权
本文主要介绍了Java中常见的排序算法，包括二分查找、冒泡排序、插入排序、快速排序、希尔排序、归并排序、桶排序和基数排序。通过解析算法原理并提供代码示例，帮助Java工程师更好地理解和应用这些算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

常见算法浅析

针对Java工程师职位，介绍几种常见的算法

1、二分查找

解析：

要求待查的序列有序，每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查到为止，否则序列中没该关键字！

代码演示：
package com.my.day02;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 14:45
 * 二分查找算法演示
 */
public class Demo01 {
    public static void main(String[] args) {
        int arr[]={1,3,4,5,6,7,9,10};
        int a=9;
        int search = search(arr, a);//查询出的数组下标+1
        System.out.println(search);//打印出该关键字所在位置
        System.out.println(arr[6]);//验证是否是下标+1
    }

    public static int search(int [] arr,int a){

        int left=0;//定义为0d的变量，便于后面判断
        int right=arr.rightgth-1;//数组一半的长度
        int mid;//用于更新每次数组的中间长度

        while (left<=right){//开始循环 条件rightgth>=0
            mid=(left+right)/2;//取中间长度
            if(arr[mid]==a){//取中间数 判断是否是关键字
                return mid+1;//
            }else if(arr[mid]<a){//若中间数小于关键字，则向后半部分查询
                left=mid+1;//长度更改为中间数+1
            }else if(arr[mid]>a){//若中间数大于关键字则向前半部分查询
                right=mid-1;//长度更改为中间数-1
            }
        }
        return -1;//未找到为-1
    }
}

2、冒泡排序算法

步骤：
  • 比较前后相邻的两个数据，如果前面数据大于后面的，就将这两个数据互换
  • 照此方法，对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就落在数组的第N-1位置
  • N=N+1，如果N不为0，则重复上面两个步骤，否则排序完成
代码演示：
package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 15:24
 *
 * 冒泡排序算法
 */
public class Demo02 {


    public static void main(String[] args) {

        int arr[]={2,3,5,1,9,8,6,22,21,10};//定义无序数组
        int b=arr.length;//获取数组长度
        bubbleSort(arr,b);//执行冒泡排序方法
        System.out.println(Arrays.toString(arr));//打印出数组
    }
    public static void bubbleSort(int[]arr,int b){
        int m, n;
        for (m=0;m<b;m++){
            for(n=1;n<b-m;n++){
                if(arr[n-1]>arr[n]){
                    int temp;
                    temp=arr[n-1];
                    arr[n-1]=arr[n];
                    arr[n]=temp;
                }
            }
        }
    }
}

3、插入排序算法

解析：

对未排序数据，在已排序序列中从后向前扫描，找到相应位置插入。插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着， 一次从桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。 为了找到这张牌的正确位置，要将它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。

代码演示：
package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 15:42
 */
public class Demo03 {

    public static void main(String[] args) {
        int arr[] = {2, 4, 5, 1, 6, 8, 0, 9};//构建无序序列
        sort(arr);//执行插入排序
        System.out.println(Arrays.toString(arr));//打印
    }
        public static void sort(int arr[]){
            for (int i = 1; i < arr.length; i++) {
                //插入的数
                int insertVal = arr[i];
                //被插入的位置(准备和前一个数比较)
                int index = i - 1;
                //如果插入的数比被插入的数小
                while (index >= 0 && insertVal < arr[index]) {
                    //将把 arr[index] 向后移动
                    arr[index + 1] = arr[index];
                    // 让 index 向前移动
                    index--;
                }
                // 把插入的数放入合适位置
                arr[index + 1] = insertVal;
            }
        }
    }

4、快速排序算法

解析：

选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的），一般选择序列的第一个元素。开始循环后，从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，这样左右两边就是有序的

代码演示：
package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 16:06
 *
 * 快速排序算法
 */
public class Demo04 {
    public static void main(String[] args) {
    int arr[]={1,5,2,4,3,23,99,88,33,11,0,42,67,63,87,98,101,92,114};//定义无序序列
    int high=arr.length-1;//获取序列最大长度
    sort(arr,0,high);//执行快速排序方法
    System.out.println(Arrays.toString(arr));//打印排序后的序列
    }
    public static  void sort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];
        while(end>start) {
            //从后往前比较
            while (end > start && a[end] >= key)
                // 如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if (a[end] <= key) {
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //从前往后比较
            while (end > start && a[start] <= key) {
                //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
                if (a[start] >= key) {
                    int temp = a[start];
                    a[start] = a[end];
                    a[end] = temp;
                }
                //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
            }
            //递归
            if (start > low) sort(a, low, start - 1);//左边序列。第一个索引位置到关键值索引-1
            if (end < high) sort(a, end + 1, high);//右边序列。从关键值索引+1 到最后一个
        }
    }
}

5、希尔排序算法

解析：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序” 时，再对全体记录进行依次直接插入排序

步骤：

  1. 操作方法：选择一个增量序列 t1， t2， …， tk，其中 ti>tj， tk=1；

  2. 按增量序列个数 k，对序列进行 k 趟排序；

  3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

代码演示：
package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 16:44
 * 希尔排序算法
 */
public class Demo05 {
    public static void main(String[] args) {
        int arr[]={4,2,0,5,1,3};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void shellSort(int[] a) {
        int dk = a.length/2;
        while( dk >= 1 ){
        ShellInsertSort(a, dk); dk = dk/2;
        }
    }
    private static  void ShellInsertSort(int[] a, int dk) {
        //类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了
        for (int i = dk; i < a.length; i++) {
            if (a[i] < a[i - dk]) {
                int j;
                int x = a[i];//x 为待插入元素
                a[i] = a[i - dk];
                for (j = i - dk; j >= 0 && x < a[j]; j = j - dk) {
                    //通过循环，逐个后移一位找到要插入的位置。
                    a[j + dk] = a[j];
                }
                a[j + dk] = x;//插入
            }
        }
    }
}

6、归并排序算法

解析：

将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列

代码演示：
package com.my.day02;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 16:51
 * 归并排序算法
 */
public class Demo06 {
    public static void main(String[] args) {
        int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 };
        print(data);
        mergeSort(data);
        System.out.println("排序后的数组： ");
        print(data);
    }
    public static void mergeSort(int[] data) {
        sort(data, 0, data.length - 1);
    }
    public static void sort(int[] data, int left, int right) {
        if (left >= right)
            return; // 找出中间索引
            int center = (left + right) / 2;
             // 对左边数组进行递归
            sort(data, left, center);
            // 对右边数组进行递归
            sort(data, center + 1, right);
            // 合并
            merge(data, left, center, right);
            print(data);
    }
    /**
     * 将两个数组进行归并，归并前面 2 个数组已有序，归并后依然有序 *
     * @param data
     * 数组对象
     * @param left
     * 左数组的第一个元素的索引
     * @param center
     * 左数组的最后一个元素的索引， center+1 是右数组第一个元素的索引
     * @param right * 右数组最后一个元素的索引
     * */
     public static void merge(int[] data, int left, int center, int right) {
                // 临时数组
                int[] tmpArr = new int[data.length];
                // 右数组第一个元素索引
                int mid = center + 1;
                // third 记录临时数组的索引
                int third = left;
                // 缓存左数组第一个元素的索引
                int tmp = left;
                while (left <= center && mid <= right) {
                    // 从两个数组中取出最小的放入临时数组
                    if (data[left] <= data[mid]) {
                        tmpArr[third++] = data[left++];
                    } else {
                        tmpArr[third++] = data[mid++];
                    }
                }
                // 剩余部分依次放入临时数组（实际上两个 while 只会执行其中一个）
                while (mid <= right) {
                    tmpArr[third++] = data[mid++];
                }
                while (left <= center){
                tmpArr[third++] = data[left++];
                }
                // 将临时数组中的内容拷贝回原数组中
                 // （原 left-right 范围的内容被复制回原数组）
                while (tmp <= right) {
               data[tmp] = tmpArr[tmp++];
           }
     }
     public static void print(int[] data) {
                for (int i = 0; i < data.length; i++) {
                    System.out.print(data[i] + "\t");
                }
                System.out.println();
     }
}

7、桶排序算法

解析：

把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最后合并，计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况

1.找出待排序数组中的最大值 max、最小值 min

2.我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量(maxmin)/arr.length+1

3.遍历数组 arr，计算每个元素 arr[i] 放的桶

4.每个桶各自排序

package com.my.day02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 19:53
 * 桶排序算法
 */
public class Demo07 {


    public static void main(String[] args) {
        int arr[]={2,3,1,5,0};
        int[] ints = bucketSort(arr, 3);
        System.out.println(Arrays.toString(ints));
    }

    public static int[] bucketSort(int arr[], int bucketCount) {

        int len = arr.length;
        int[] result = new int[len];
        int min = arr[0];
        int max = arr[0];
        //找到最大值和最小值
        for (int i = 1; i < len; i++) {
            min = min <= arr[i] ? min: arr[i];
            max = max >= arr[i] ? max: arr[i];
        }
        //求出每一个桶的数值范围
        int space = (max - min + 1) / bucketCount;
        //先创建好每一个桶的空间,这里使用了泛型数组
        ArrayList <Integer> [] arrList = new ArrayList[bucketCount];
        //把arr中的数均匀的的分布到[0,1)上，每个桶是一个list，存放落在此桶上的元素
        for (int i = 0; i < len; i++) {
            int index = (int) Math.floor((arr[i] - min) / space);
            if (arrList[index] == null) {
                //如果链表里没有东西
                arrList[index] = new ArrayList <Integer> ();
                arrList[index].add(arr[i]);
            } else {
                //排序
                int k = arrList[index].size() - 1;
                while (k >= 0 && (int) arrList[index].get(k) > arr[i]) {
                    if (k + 1 > arrList[index].size() - 1) {
                        arrList[index].add(arrList[index].get(k));
                    } else {
                        arrList[index].set(k + 1, arrList[index].get(k));
                    }
                    k--;
                }
                if (k + 1 > arrList[index].size() - 1) {
                    arrList[index].add(arr[i]);
                } else {
                    arrList[index].set(k + 1, arr[i]);
                }
            }

        }

        //把各个桶的排序结果合并  ,count是当前的数组下标
        int count = 0;

        for (int i = 0; i < bucketCount; i++) {
            if (null != arrList[i] && arrList[i].size() > 0) {
                Iterator<Integer> iter = arrList[i].iterator();
                while (iter.hasNext()) {
                    int d = (int) iter.next();
                    result[count] = d;
                    count++;
                }
            }
        }
        return result;
    }

}

8、基数排序算法

解析：

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列

代码演示：
package com.my.day02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 20:29
 * 基数排序算法
 */
public class Demo08 {


    public static void main(String[] args) {
        radixSort();
    }
    public static  void radixSort(){
        int a[]={49,38,65,97,76,13,27,49,78};//定义未排序数组
        sort(a);//执行基数排序算法
        System.out.println(Arrays.toString(a));//打印
    }
    public static void sort(int[] array){
        //首先确定排序的趟数;
        int max=array[0];
        for(int i=1;i<array.length;i++){
            if(array[i]>max){ max=array[i];
            }
        }
        int time=0;
        //判断位数;
        while(max>0){
            max/=10;
            time++;
        }
        //建立 10 个队列;
        List<ArrayList> queue=new ArrayList<ArrayList>();
        for(int i=0;i<10;i++){
            ArrayList<Integer>queue1=new ArrayList<Integer>();
            queue.add(queue1);
        }
        //进行 time 次分配和收集;
        for(int i=0;i<time;i++){
            //分配数组元素;
            for(int j=0;j<array.length;j++){
                //得到数字的第 time+1 位数;
                int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
                ArrayList<Integer>queue2=queue.get(x);
                queue2.add(array[j]);
                queue.set(x, queue2);
            }
            int count=0;//元素计数器;// 收集队列元素;
             for(int k=0;k<10;k++){
                 while(queue.get(k).size()>0){
                     ArrayList<Integer>queue3=queue.get(k);
                     array[count]=queue3.get(0);
                     queue3.remove(0); count++;
                 }
             }
        }
    }
}

9、算法题

题目一：

假设今日是2015年3月1日，星期日，请算出13个月零6天后是星期几，距离现在多少天？

请用代码实现，谢绝调用API方法

代码实现：
package com.my.day02;

import java.util.Scanner;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 20:57
 * 算法题
 */
public class Demo09 {
    public static String[] week =
            {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
    public static int i = 0;
    public static int[] monthday1 =
            {0,31,28,31,30,31,30,31,31,30,31,30,31};
    public static int[] monthday2 =
            {0,31,29,31,30,31,30,31,31,30,31,30,31};
    //查看距离当前天数的差值
    public static String distance(int year,int month,int day,int newMonth,int newDay) {
        int sum = 0;
        //设定初始距离天数
        if (month + newMonth >= 12) {
            if (((year + 1) % 4 == 0 && (year + 1) % 100 != 0)||(year + 1) % 400 == 0) {
                sum += 366 + newDay;
                for(int i = 0;i < newMonth - 12;i++) {
                    sum += monthday1[month + i];
                }
            } else {
                sum += 365 + newDay;
                for(int i = 0;i < newMonth - 12;i++) {
                    sum += monthday1[month + i];
                }
            }
        }else{
            for(int i = 0;i < newMonth;i++) {
                sum += monthday1[month + i];
            }
            sum += newDay;
        }
        return week[sum%7];
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入当前年份");
        int year = scanner.nextInt();
        System.out.println("请输入当前月份");
        int month = scanner.nextInt();
        System.out.println("请输入当前天数");
        int day = scanner.nextInt();
        System.out.println("请输入当前是星期几：以数字表示，如：星期天 为 0");
        int index = scanner.nextInt();
        System.out.println("今天是：" + year + "-" + month + "-" + day + " " + week[index]);
        System.err.println("请输入相隔月份");
        int newMonth = scanner.nextInt();
        System.out.println("请输入剩余天数");
        int newDay = scanner.nextInt();
        System.out.println("经过" + newMonth + "月" + newDay + "天后，是" + distance(year,month,day,newMonth,newDay)); }
}
题目二：

数据里有{1,2,3,4,5,6,7,8,9}，请随机打乱顺序，生成一个新的数组，再把新数组已某种排序算法排序

比如希尔排序算法

代码实现：
package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 21:02
 * 算法题
 */
public class Demo10 {
    public static void main(String[] args) {
       //定义有序数组
        int[] arr = {0,1,2,3,4,5,6,7};
        int length = arr.length;
        for(int i=0;i<length;i++){//随机数组下标调换位置
            int iRandNum = (int)(Math.random() * length);
            int temp = arr[iRandNum];
            arr[iRandNum] = arr[i];
            arr[i] = temp;
        }
        //打印这个无序数组，验证是否成功
        System.out.println(Arrays.toString(arr));
        System.out.println("---------------------------------");
         shellSort(arr);
        System.out.println(Arrays.toString(arr));//采用希尔排序后打印这个无序数组，验证是否成功


    }


    /**
     *对全体记录进行依次直接插入排序
     * @param a
     */
    private static void shellSort(int[] a) {
        int dk = a.length/2;
        while( dk >= 1 ){
            ShellInsertSort(a, dk); dk = dk/2;
        }
    }

    /**
     * 整个待排序的记录序列分割成为若干子序列分别进行直接插入排序
     * @param a
     * @param dk
     */
    private static  void ShellInsertSort(int[] a, int dk) {
        //类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了
        for (int i = dk; i < a.length; i++) {
            if (a[i] < a[i - dk]) {
                int j;
                int x = a[i];//x 为待插入元素
                a[i] = a[i - dk];
                for (j = i - dk; j >= 0 && x < a[j]; j = j - dk) {
                    //通过循环，逐个后移一位找到要插入的位置。
                    a[j + dk] = a[j];
                }
                a[j + dk] = x;//插入
            }
        }
    }
}
C语言常用算法代码
weixin_50072751的博客
08-13 909
//1-100的奇数的个数 # include <stdio.h> int main (void) { int i ; int cnt = 0;//个数一般用途cnt表示（ count ） for(i=1; i<101;++i) { if (i%2 == 1) ++cnt; } printf("cnt=%d\n",cnt); return 0; }
常用数据结构和算法总结
Web前端开发工程师
09-26 2847
算法知识总结 本部分主要是笔者在学习算法知识和一些相关面试题所做的笔记，如果出现错误，希望大家指出！ 目录 常用算法和数据结构总结 排序 冒泡排序 选择排序 插入排序 希尔排序 归并排序 快速排序 堆排序 基数排序 快速排序相对于其他排序效率更高的原因 系统自带排序实现 稳定性 排序面试题目总结 树 二叉树相关性质 满二叉树 完全二叉树 平衡二叉查找树（AVL） B-树 B 树 数据库索引 红黑树 Huffman 树 二叉查找树 求解二叉树中两个节点的最近公共祖先节点 链表 反转单向链表
常用算法代码
09-11
目录 目录 1 Graph 图论 3 | DAG 的深度优先搜索标记 3 | 无向图找桥 3 | 无向图连通度(割) 3 | 最大团问题 DP + DFS 3 | 欧拉路径 O(E) 3 | DIJKSTRA 数组实现 O（N^2） 3 | DIJKSTRA O(E * LOG E) 4 | BELLMANFORD 单源最短路 O(VE) 4 | SPFA(SHORTEST PATH FASTER ALGORITHM) 4 | 第 K 短路（DIJKSTRA） 5 | 第 K 短路（A*） 5 | PRIM 求 MST 6 | 次小生成树 O(V^2) 6 | 最小生成森林问题(K 颗树)O(MLOGM). 6 | 有向图最小树形图 6 | MINIMAL STEINER TREE 6 | TARJAN 强连通分量 7 | 弦图判断 7 | 弦图的 PERFECT ELIMINATION 点排列 7 | 稳定婚姻问题 O(N^2) 7 | 拓扑排序 8 | 无向图连通分支(DFS/BFS 邻接阵) 8 | 有向图强连通分支(DFS/BFS 邻接阵)O(N^2) 8 | 有向图最小点基(邻接阵)O(N^2) 9 | FLOYD 求最小环 9 | 2-SAT 问题 9 Network 网络流 11 | 二分图匹配（匈牙利算法 DFS 实现） 11 | 二分图匹配（匈牙利算法 BFS 实现） 11 | 二分图匹配（HOPCROFT－CARP 的算法） 11 | 二分图最佳匹配（KUHN MUNKRAS 算法 O(M*M*N)） 11 | 无向图最小割 O(N^3) 12 | 有上下界的最小(最大)流 12 | DINIC 最大流 O(V^2 * E) 12 | HLPP 最大流 O(V^3) 13 | 最小费用流 O(V * E * F) 13 | 最小费用流 O(V^2 * F) 14 | 最佳边割集 15 | 最佳点割集 15 | 最小边割集 15 | 最小点割集（点连通度） 16 | 最小路径覆盖 O(N^3) 16 | 最小点集覆盖 16 Structure 数据结构 17 | 求某天是星期几 17 | 左偏树 合并复杂度 O(LOG N) 17 | 树状数组 17 | 二维树状数组 17 | TRIE 树(K 叉) 17 | TRIE 树(左儿子又兄弟) 18 | 后缀数组 O(N * LOG N) 18 | 后缀数组 O(N) 18 | RMQ 离线算法 O(N*LOGN)+O(1) 19 | RMQ(RANGE MINIMUM/MAXIMUM QUERY)-ST 算法 (O(NLOGN + Q)) 19 | RMQ 离线算法 O(N*LOGN)+O(1)求解 LCA 19 | LCA 离线算法 O(E)+O(1) 20 | 带权值的并查集 20 | 快速排序 20 | 2 台机器工作调度 20 | 比较高效的大数 20 | 普通的大数运算 21 | 最长公共递增子序列 O(N^2) 22 | 0-1 分数规划 22 | 最长有序子序列（递增/递减/非递增/非递减） 22 | 最长公共子序列 23 | 最少找硬币问题（贪心策略-深搜实现） 23 | 棋盘分割 23 | 汉诺塔 23 | STL 中的 PRIORITY_QUEUE 24 | 堆栈 24 | 区间最大频率 24 | 取第 K 个元素 25 | 归并排序求逆序数 25 | 逆序数推排列数 25 | 二分查找 25 | 二分查找（大于等于 V 的第一个值） 25 | 所有数位相加 25 Number 数论 26 1 |递推求欧拉函数 PHI(I) 26 |单独求欧拉函数 PHI(X) 26 | GCD 最大公约数 26 | 快速 GCD 26 | 扩展 GCD 26 | 模线性方程 A * X = B (% N) 26 | 模线性方程组 26 | 筛素数 [1..N] 26 | 高效求小范围素数 [1..N] 26 | 随机素数测试(伪素数原理) 26 | 组合数学相关 26 | POLYA 计数 27 | 组合数 C(N, R) 27 | 最大 1 矩阵 27 | 约瑟夫环问题（数学方法） 27 | 约瑟夫环问题（数组模拟） 27 | 取石子游戏 1 27 | 集合划分问题 27 | 大数平方根（字符串数组表示） 28 | 大数取模的二进制方法 28 | 线性方程组 A[][]X[]=B[] 28 | 追赶法解周期性方程 28 | 阶乘最后非零位,复杂度 O(NLOGN) 29 递归方法求解排列组合问题 30 | 类循环排列 30 | 全排列 30 | 不重复排列 30 | 全组合 31 | 不重复组合 31 | 应用 31 模式串匹配问题总结 32 | 字符串 HASH 32 | KMP 匹配算法 O(M+N) 32 | KARP-RABIN 字符串匹配 32 | 基于 KARP-RABIN 的字符块匹配 32 | 函数名: STRSTR 32 | BM 算法的改进的算法 SUNDAY ALGORITHM 32 | 最短公共祖先（两个长字符串） 33 | 最短公共祖先（多个短字符串） 33 Geometry 计算几何 34 | GRAHAM 求凸包 O(N * LOGN) 34 | 判断线段相交 34 | 求多边形重心 34 | 三角形几个重要的点 34 | 平面最近点对 O(N * LOGN) 34 | LIUCTIC 的计算几何库 35 | 求平面上两点之间的距离 35 | (P1-P0)*(P2-P0)的叉积 35 | 确定两条线段是否相交 35 | 判断点 P 是否在线段 L 上 35 | 判断两个点是否相等 35 | 线段相交判断函数 35 | 判断点 Q 是否在多边形内 35 | 计算多边形的面积 35 | 解二次方程 AX^2+BX+C=0 36 | 计算直线的一般式 AX+BY+C=0 36 | 点到直线距离 36 | 直线与圆的交点，已知直线与圆相交 36 | 点是否在射线的正向 36 | 射线与圆的第一个交点 36 | 求点 P1 关于直线 LN 的对称点 P2 36 | 两直线夹角（弧度） 36 ACM/ICPC 竞赛之 STL 37 ACM/ICPC 竞赛之 STL 简介 37 ACM/ICPC 竞赛之 STL--PAIR 37 ACM/ICPC 竞赛之 STL--VECTOR 37 ACM/ICPC 竞赛之 STL--ITERATOR 简介 38 ACM/ICPC 竞赛之 STL--STRING 38 ACM/ICPC 竞赛之 STL--STACK/QUEUE 38 ACM/ICPC 竞赛之 STL--MAP 40 ACM/ICPC 竞赛之 STL--ALGORITHM 40 STL IN ACM 41 头文件 42 线段树 43 求矩形并的面积（线段树+离散化+扫描线） 43 求矩形并的周长（线段树+离散化+扫描线） 44
常见算法演示及源码
09-14
常见数据结构演示和源代码学习，帮助更好的理解常见算法
常用算法可视化演示系统
05-13
在数据结构中 常用的算法 可视化的演示
数据结构常见算法演示
08-10
数据结构常见算法演示 包括二叉树、链表、串、栈、广义表、图等 是数据结构学习的好帮手！生动形象，易以学习操作
关键词提取算法浅析与应用场景分析
本文旨在对关键词提取算法进行深入浅析，探讨不同算法之间的优缺点，以及在实际应用场景中的表现。通过对关键词提取算法的分析和研究，旨在帮助读者更好地理解和应用这一技术，提升信息处理的效率和质量。 ## 1.3 ...
【常见人脸识别算法浅析】： 从LBPH到CNN的算法简介
![【常见人脸识别算法浅析】： 从LBPH到CNN的算法简介]...# 1. 人脸识别技术概述 人脸识别技术作为当今热门的人工智能应用之一，其应用领域涵盖安防、金融、社交等多个领域。通过对人脸图像进行采集、检测、提取特征...
HuskyLens摄像头系列 | 写给小学生看的视觉PID巡线算法
铁熊玩创客
12-16 8454
Hello，大家好，光天化日之下我又来撸狗了。距离上次撸狗已经过去了个把月时间了，那么这次又有什么新惊喜呢？ 先来看一下本期的演示视频吧。 https://www.bilibili.com/video/av79068760/ 什么？巡线？这也太简单了吧。不要急，听我慢慢道来。 哈士奇图形模块来了 上次视频里说了，DF 只给我提供了 HuskyLens （中文名：哈士奇）人工智能摄像头的通信协议，所...
算法竞赛资料整理分享
BIT`S WORLD
06-11 2037
算法竞赛资料分享????????‍♀️ 因为准备实习????，今天早上整理了一下算法的课件、书籍、论文、习题 不管是准备校招，进BAT????； 还是自学算法竞赛????； 或者单纯的课外拓展????； 对程序员????而言，算法学习都是有必要的，只是可能要求深浅不同，所以，开始学起来吧????～ 仓库在这里，感谢您的star！ 全面收集、整理了从高中参加竞赛到现在的算法竞赛课件、论文集、书籍、习题等，并分类如下????： 欢迎大家贡献你的资料丰富这个Repo 文件很多，目录很长，所以分为文件夹目录
常用排序算法java演示
06-10
关于各种排序算法的图形演示，做得很不错
算法源代码
11-26
算法源码和ppt，很好的学习资料，欢迎有需要的朋友下载
全面的算法代码库
04-08
Algorithms   本次README修订为算法仓库Algorithms的第100次commit，首先我们庆祝自2016年8月4日本仓库建立以来Dev-XYS在算法学习方面取得的显著进步！   这里有各种算法的C++代码，任何人可以在自己的任何程序中使用，欢迎大家指出代码中的错误以及有待改进的地方。   本仓库内所有代码的授权方式为Unlicense，大家如果使用我的代码开发自己的软件挣了大钱，或是参考我的代码在NOI中得了金牌，我都会很高兴的。使用这里的代码之后，你可以自主选择是否公开源代码。总而言之，你可以把这里的代码当作你自己写的一样，无论怎样使用都是被允许的。但是，我不对本仓库内代码的正确性负责。大家要是使用我的代码开发软件而导致程序崩溃，或是参考我的代码在考试时出错，请不要向我抱怨。如果你愿意，遇到问题可以在Issues中提出来，我们共同解决。我们不赞成Pull Request，因为本仓库主要储存作者已经学习的算法，全部代码均由作者本人负责维护与更新。   以下索引提供了本仓库内算法的中文名，方便大家查找。更新可能有很长时间的延迟，不保证所有算法的名称都在列表中出现。 Index --------------------------Contents-------------------------- --------------------------FileName-------------------------- AC自动机 Aho-Corasick-Automation 单源最短路径（SPFA） Bellman-Ford(Queue-Optimised) 单源最短路径（Bellman-Ford） Bellman-Ford 使用Edmonds-Karp进行二分图匹配 Bigrpah-Matching(Edmonds-Karp) 普通的二叉搜索树 Binary-Search-Tree 广度优先搜索 Breadth-First-Search 冒泡排序 Bubble-Sort 桶排序 Bucket-Sort 组合数的递推求解 Combination(Recursion) 枚举组合 Combination 基本的复数类 Complex-Number 割点 Cut-Vertex 深度优先搜索 Depth-First-Search 堆优化的Dijkstra算法 Dijkstra(Heap-Optimised) 并查集 Disjoint-Set-Union 最大流Edmonds-Karp算法 Edmonds-Karp 欧拉函数 Euler's-Totient-Function 有向图的欧拉回路 Eulerian-Tour(Digraph) 拓展欧几里得算法 Extended-Euclid 简单的快速幂 Fast-Exponentiation 树状数组 Fenwick-Tree 所有结点对之间的最短路径（Floyd） Floyd-Warshall 凸包算法（Graham扫描法） Graham-Scan 辗转相除法求最大公约数 Greatest-Common-Divisor 堆排序 Heap-Sort ISAP算法 Improved-Shortest-Augmenting-Path(Naive) 插入排序 Insertion-Sort 字符串匹配（KMP） Knuth-Morris-Pratt 最小生成树（Kruskal） Kruskal 最近公共祖先（Tarjan） Least-Common-Ancestor(Tarjan) 使用后缀数组求解最长公共子串 Longest-Common-Substring 最长上升子序列（n·log(n)） Longest-Increasing-Subsequence(n·log(n)) 倍增法求最近公共祖先 Lowest-Common-Ancestor(Doubling) 朴素的矩阵乘法 Matrix-Multiplication(Naive) 归并排序 Merge-Sort 最小堆 Min-Heap 乘法逆元 Modular-Multiplicative-Inverse 仅支持单点修改的可持久化线段树(维护区间和值） Persistent-Segment-Tree(Sum) 试除法素数测试 Prime-Check(Naive) 线性的素数筛法 Prime-Sieve(Linear) 队列的基本操作 Queue 快速排序的优化版本 Quick-Sort(Extra-Optimised) 快速排序的随机化版本 Quick-Sort(Randomized) 快速排序 Quick-Sort 使用向量叉积判断两个有向线段的时针关系 Segment-Direction 线段树维护区间最大值 Segment-Tree(Maximum) 线段树维护区间最小值 Segment-Tree(Minimum) 线段树维护区间和值 Segment-Tree(Sum) 普通的选择算法 Selection Eratosthenes素数筛法 Sieve-of-Erotosthenes 指针版的单向链表 Singly-Linked-List(Pointer) 跳表 Skip-List ST表 Sparse-Table 伸展树 Splay 博弈论SG函数 Sprague-Grundy 栈的基本操作 Stack 递推法求解无符号第一类斯特林数 Stirling-Number(Cycle,Unsigned,Recursion) 递推法求解第二类斯特林数 Stirling-Number(Subset,Recursion) 倍增法求解后缀数组 Suffix-Array(Doubling) 倍增法求解后缀数组（附带Height数组） Suffix-Array-with-Height(Doubling) 使用Tarjan算法求解强连通分量 Tarjan(Strongly-Connected-Components) 数组版的字典树 Trie(Array) 指针版的字典树 Trie(Pointer)
常见算法代码（全）.docx
05-20
本文件是一个Word文档，包含常见的算法代码，比如欧拉回路，深搜广搜等模板。
一些常用算法的代码（2）
Never give in.
07-14 403
主席树void build(int lst,int now,int l,int r,int v) { if(l==r) { tr[now].sm=tr[lst].sm+1; return; } int mid=(l+r)/2,lts=tr[lst].ls,rts=tr[lst].rs; if (v<=mid) tr[now].
常用算法经典代码
in_han 的专栏
04-02 536
一、快速排序 二、冒泡排序 三、桶排序 四、归并排序
常见算法
业余敲代码
08-26 535
本篇概要：1. 算法的概念；2. 时间复杂度和空间复杂度；3. 常见排序算法：4. 常见查找算法。 1. 算法的概念； 解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。 一个问题可以有多种算法，每种算法都有不同的效率。比如：1 + 2 + 3 + 4 + … + n 的值是多少，可以一个数字一个数字加，也可以用公式 (1 + n) * n / 2 一个...
图论常见算法代码
weixin_43823255的博客
10-26 477
bfs import java.util.HashSet; import java.util.LinkedList; import java.util.Queue; //广度优先搜索 public class BFS { public static void bfs(Node node) { if (node == null) { return; } //利用队列 Queue<Node> queue = new
算法代码
qq_40983361的博客
04-27 223
冒泡int arr[]={1,5,6,8,3}; for(int i=0;i&lt;arr.length;i++){ for (int j=0;j&lt;arr.length-1;j++){ if(arr[j]&gt;arr[j+1]){ int temp; temp=arr[j]; arr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值