精华内容
下载资源
问答
  • 蓝桥杯知识点汇总:基础知识和常用算法

    万次阅读 多人点赞 2020-01-21 14:59:45
    此系列包含蓝桥杯(软件类)所考察的绝大部分知识点,算法,和写算法题必备的JAVA的基础语法,API,对想从C/C++转到JAVA组以及初学算法的同学会有帮助。


    此系列包含蓝桥杯(软件类)所考察的绝大部分知识点。一共分为基础语法常用API算法和数据结构,和往年真题四部分。
    语言以JAVA为主,对想从C/C++转到JAVA组的同学会有帮助,也适合初学者查阅一些算法模板和API。如果读者发现文章有误,请告知我,十分感谢。另外,有什么问题可私信我。

    JAVA基础语法:

    备战蓝桥杯(一):一般输入输出 和 快速输入输出
    备战蓝桥杯(二):java编程规范和常用数据类型
    备战蓝桥杯(三):常用功能符以及循环结构和分支结构
    备战蓝桥杯(四):函数(方法)、类和对象

    算法竞赛常用的JAVA API:

    备战蓝桥杯(五):大数类
    备战蓝桥杯(六):Math类
    备战蓝桥杯(七):String 、StringBuilder、StringBuffer常用方法和区别
    备战蓝桥杯(八):Calendar日期类
    备战蓝桥杯(九):ArrayList(Vector)
    备战蓝桥杯j(十): HashMap 和 TreeMap
    备战蓝桥杯(十一):HashSet 和 TreeSet
    备战蓝桥杯(十二): PriorityQueue(优先队列)
    备战蓝桥杯(十三): sort方法和自定义比较器的写法

    算法和数据结构

    简单算法

    备战蓝桥杯(十四):递归
    备战蓝桥杯(十五):深度优先搜索(DFS)和宽度优先搜索(BFS)
    备战蓝桥杯(十六):位运算
    备战蓝桥杯(十七):二分
    备战蓝桥杯(十八):快速排序
    备战蓝桥杯(十九):归并排序

    简单数据结构

    备战蓝桥杯 (二十):用数组模拟单链表
    备战蓝桥杯 (二十一):用数组模拟栈和对列
    备战蓝桥杯 (二十二):哈希表
    备战蓝桥杯(二十三):并查集
    备战蓝桥杯(二十四):trie树

    图论

    备战蓝桥杯(二十五) :树和图的存储:邻接矩阵和邻接表
    备战蓝桥杯(二十六):最短路问题
    备战蓝桥杯(二十七):最小生成树
    备战蓝桥杯(二十八):二分图

    数学

    贪心

    备战蓝桥杯(三十八):贪心算法

    动态规划

    补充

    图论:拓扑排序

    省赛题解

    第十届蓝桥杯省赛JAVA B组题解

    第六届蓝桥杯省赛JAVA AB题解

    待更:

    1. 递归
    2. 搜索
    3. 位运算
    4. 二分
    5. 排序
    6. 贪心
    7. 动态规划
    8. 图论
    9. 数论
    10. 等

    另附:

    蓝桥杯考察范围
    在这里插入图片描述
    参赛选手机器环境
    在这里插入图片描述

    更详细的可以到蓝桥杯官网查看。祝大家可以公费旅游~。

    展开全文
  • 算法07:常用算法排序

    万次阅读 2020-04-06 21:16:52
    文章目录一、十种排序算法比较二、排序算法的选择三、常用算法代码0. 输入输出函数的封装1. 冒泡排序算法步骤代码2. 插入排序算法步骤代码3. 归并排序算法步骤代码4. 快速排序算法步骤代码 一、十种排序算法比较 ​ ...
    常用排序算法

    一、十种排序算法比较

    ​ 排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。以下为复杂度对比:

    在这里插入图片描述

    ​ 关于稳定性的解释:稳定性为排序后 2 个相等键值的顺序和排序之前它们的顺序相同

    二、排序算法的选择

    ​ 从上图可以明显的看出各种算法的优劣,在时间复杂度和空间复杂度两者之间很难有兼顾,所以只能根据需要选择。因此,不必记下所有算法,下面我用Java写了其中的四种常用的算法。

    三、常用算法代码

    0. 输入输出函数的封装

    ​ 将一行数字读入,并按照空格分开,形成数组的方法抽象,方便其他所有排序算法的调用。同时,输出方法也抽象于此,以备实例化调用。

    import java.util.Scanner;
    
    /**
     * @description: 提供输入和输出方法
     * @author: 宇智波Akali
     * @time: 2020/4/6 15:39
     * @fromProject: 10_sort_Methods
     * @Version: V1.0
     */
    public class In_and_Out {
        public int[] setList(){
            /**
             * @Description: 将序列格式化为数组
             * @auther: 宇智波Akali
             * @date: 15:43 2020/4/6
             * @param: []
             * @return: int[]
             */
            System.out.println("请输出数组:");
            Scanner scanner = new Scanner(System.in);
            String input = scanner.nextLine();  //读入一行字符串
            String[] str_line = input.split(" ");//将字符串按空格分隔成字符串数组
            int[] list = new int[str_line.length];
            for (int i=0;i<list.length;i++){
                list[i] = Integer.parseInt(str_line[i]);
            }
            return list;
        }
        public void printList(int[] list){
            /**
             * @Description: 传入排好序的数组,执行打印
             * @auther: 宇智波Akali
             * @date: 15:52 2020/4/6
             * @param: [list]
             * @return: void
             */
            for (Integer x: list){
                System.out.print(x + " ");
            }
        }
    }
    
    

    1. 冒泡排序

    算法步骤

    • 比较相邻的元素。如果第一个比第二个大,就交换他们两个。

    • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

    • 针对所有的元素重复以上的步骤,除了最后一个。

    • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

    代码

    public class Bubble_Sort_01 {
        public static void main(String[] args) {
            int [] list = new In_and_Out().setList();   //创建匿名对象调用In_and_Out中的setList方法
            new In_and_Out().printList(bubble_Sort(list));//创建匿名对象调用其中的printLis方法
        }
        //****************************算法部分*********************************
        public static int[] bubble_Sort(int[] list){
            boolean trigger = true; //使用trigger判断原始序列是否已经有序
            for (int i=list.length-1 ;i>=0;i--){
                for (int j=0;j<i;j++){
                    if (list[j] > list[j+1]){   //将大于号改为小于则变成从大到小排序
                        int temp;
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        trigger = false;
                    }
                }
                if (trigger) break;
            }
            return list;
        }
    
    }
    

    2. 插入排序

    算法步骤

    • 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。

    • 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)

    代码

    public class Bubble_Sort_01 {
        public static void main(String[] args) {
            int [] list = new In_and_Out().setList();   //创建匿名对象调用In_and_Out中的setList方法
            new In_and_Out().printList(bubble_Sort(list));//创建匿名对象调用其中的printLis方法
        }
        //****************************算法部分*********************************
        public static int[] bubble_Sort(int[] list){
            boolean trigger = true; //使用trigger判断原始序列是否已经有序
            for (int i=list.length-1 ;i>=0;i--){
                for (int j=0;j<i;j++){
                    if (list[j] > list[j+1]){   //将大于号改为小于则变成从大到小排序
                        int temp;
                        temp = list[j+1];
                        list[j+1] = list[j];
                        list[j] = temp;
                        trigger = false;
                    }
                }
                if (trigger) break;
            }
            return list;
        }
    
    }
    

    3. 归并排序

    算法步骤

    • 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列;

    • 设定两个指针,最初位置分别为两个已经排序序列的起始位置;

    • 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置;

    • 重复步骤 3 直到某一指针达到序列尾;

    • 将另一序列剩下的所有元素直接复制到合并序列尾。

    代码

    import java.util.Arrays;
    
    public class Merge_Sort_03 {
        public static void main(String[] args) {
            int[] list = new In_and_Out().setList();//读入并格式化List
            new In_and_Out().printList(merge_sort(list));//打印
        }
        //********************算法部分*********************************
        public static int[] merge_sort(int[] list){
            if (list.length < 2){           //递归边界:数组长度小于2,将数组递归划分为单个元素
                return  list;
            }
            int middle = list.length/2;//定义中间下标
            int[] L_list = Arrays.copyOfRange(list,0,middle);   //定义左数组及内容范围
            int[] R_list = Arrays.copyOfRange(list, middle,list.length);//定义右数组及内容范围
            return merge(merge_sort(L_list), merge_sort(R_list));       //递归调用,进行归并排序
        }
        protected static int[] merge(int[] L, int[] R){
            int[] result = new int[L.length+R.length];
            int i = 0;
            while (L.length>0 && R.length>0){
                if (L[0] <= R[0]){                 //小于改为大于则变成从大到小排序
                    result[i++] = L[0];           //左列的第一项小于右列第一项则向结果数组中填入L[0]
                    L = Arrays.copyOfRange(L,1,L.length);//将L的左边第一个去掉,之前的第二个变成第一个
                }else {
                    result[i++] = R[0];
                    R = Arrays.copyOfRange(R,1,R.length);
                }
                //每次左or右列长度减小1,直到两个的长度其中有一个为0,即有一边数组全部加到result中
                //这时候还剩一个数组,剩余部分必然都大于之前的数组,直接加入即可
            }
            while (L.length > 0) {
                result[i++] = L[0];
                L = Arrays.copyOfRange(L, 1, L.length);
            }
            while (R.length > 0) {
                result[i++] = R[0];
                R = Arrays.copyOfRange(R, 1, R.length);
            }
            return result;
        }
    }
    

    4. 快速排序

    算法步骤

    • 从数列中挑出一个元素,称为 “基准”(pivot);

    • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;

    • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;

    代码

    public class Quick_Sort_04 {
        public static void main(String[] args) {
            int[] list = new In_and_Out().setList();        //输入
            new In_and_Out().printList(quick_sort(list));   //输出
        }
        //*************************算法部分**************************
        private static int[] quick_sort(int[] list){
            return sort(list, 0, list.length-1);
        }
        private static int[] sort(int[] list, int L, int R){
            if (L < R){
                int partitionIndex = partition(list, L, R);         //接收一个已经确定了位置的数的下标,以此为分界线分块递归
                sort(list, L, partitionIndex - 1);
                sort(list, partitionIndex + 1, R);
            }
            return list;
        }
        private static int partition(int[] list, int L, int R){
            int pivot_key = list[L];
            while (L < R){
                //一次外层循环只解决一次交换
                while (L < R && list[R] >= pivot_key){
                    R--;
                }
                //将小于基准的放左边
                list[L] = list[R];
                while (L < R && list[L] <= pivot_key){
                    L++;
                }
                //将大于基准的放右边
                list[R] = list[L];
            }
            list[L] = pivot_key;    //当循环结束时,L=R,两者重合,将pivot_key的值放在此处,就确定了一个数的位置
            //返回基准最后的位置
            return L;
        }
    }
    
    
    展开全文
  • CTR常用算法

    千次阅读 2018-07-25 10:56:59
    广告点击率预估常用算法

    广告点击率预估常用算法
    CTR常用算法

    展开全文
  • c语言常用算法整理

    万次阅读 多人点赞 2019-02-26 10:10:57
    这里整理c语言常用算法,主要有: 交换算法 查找最小值算法 冒泡排序 选择排序 插入排序 shell排序 (希尔排序) 归并排序 快速排序 二分查找算法 查找重复算法 代码如下: //交换 void swap(int *a, int *b){ int ...

    这里整理c语言常用算法,主要有:
    交换算法
    查找最小值算法
    冒泡排序
    选择排序
    插入排序
    shell排序 (希尔排序)
    归并排序
    快速排序
    二分查找算法
    查找重复算法

    代码如下:

    //交换
    void swap(int *a, int *b){
        int tmp=*a;
        *a=*b;
        *b=tmp;
    }
    
    //查找最小
    int min(int x, int y) {
        return x < y ? x : y;
    }
    
    typedef struct _Range {
        int start, end;
    } Range;
    
    Range new_Range(int s, int e) {
        Range r;
        r.start = s;
        r.end = e;
        return r;
    }
    
    
    //冒泡排序
    void looperSort(int *arr, int len){
        int i,j;
        for (i = 0; i < len - 1; ++i) {
            for (j = 0; j < len - 1-i; ++j) {
                if (arr[j]>arr[j+1]){
                    swap(&arr[j], &arr[j+1]);
                }
            }
        }
    }
    
    //选择排序
    void selectSort(int *arr, int num){
        int min, i, j;
        for (i = 0; i < num - 1; ++i) {
            min=i;
            for (j = i+1; j < num; ++j) {
                if (arr[j]<arr[min]){
                    min=j;
                }
            }
            if (min!=i)
                swap(&arr[min], &arr[i]);
        }
    }
    
    //插入排序
    void insertSort(int *arr, int num){
        int i,j, tmp;
        for (i = 1; i < num; ++i) {
            tmp=arr[i];
            for (j = i; j > 0 && arr[j-1] > tmp; --j) {
                arr[j]=arr[j-1];
            }
            arr[j]=tmp;
        }
    }
    
    //希尔排序
    void shellSort(int *arr, int num) {
        int gap, i, j, temp;
        for (gap = num >> 1; gap > 0; gap = gap >>= 1)
            for (i = gap; i < num; i++) {
                temp = arr[i];
                for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap){
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
    }
    
    //归并排序
    void mergeSort(int *arr, int num) {
        int* a = arr;
        int* b = (int*) malloc(num * sizeof(int));
        int seg, start;
        for (seg = 1; seg < num; seg += seg) {
            for (start = 0; start < num; start += seg + seg) {
                int low = start, mid = min(start + seg, num), high = min(start + seg + seg, num);
                int k = low;
                int start1 = low, end1 = mid;
                int start2 = mid, end2 = high;
                while (start1 < end1 && start2 < end2){
                    b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
                }
                while (start1 < end1){
                    b[k++] = a[start1++];
                }
                while (start2 < end2){
                    b[k++] = a[start2++];
                }
            }
            int* temp = a;
            a = b;
            b = temp;
        }
        if (a != arr) {
            int i;
            for (i = 0; i < num; i++)
                b[i] = a[i];
            b = a;
        }
        free(b);
    }
    
    
    void merge_sort_recursive(int arr[], int reg[], int start, int end) {
        if (start >= end)
            return;
        int len = end - start, mid = (len >> 1) + start;
        int start1 = start, end1 = mid;
        int start2 = mid + 1, end2 = end;
        merge_sort_recursive(arr, reg, start1, end1);
        merge_sort_recursive(arr, reg, start2, end2);
        int k = start;
        while (start1 <= end1 && start2 <= end2)
            reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
        while (start1 <= end1)
            reg[k++] = arr[start1++];
        while (start2 <= end2)
            reg[k++] = arr[start2++];
        for (k = start; k <= end; k++)
            arr[k] = reg[k];
    }
    
    //归并排序 递归
    void mergeSort2(int *arr, const int len) {
        int reg[len];
        merge_sort_recursive(arr, reg, 0, len - 1);
    }
    
    
    //快速排序
    void quickSort(int *arr, const int num) {
        if (num <= 0)
            return; // 避免len等於負值時引發段錯誤(Segment Fault)
        // r[]模擬列表,p為數量,r[p++]為push,r[--p]為pop且取得元素
        Range r[num];
        int p = 0;
        r[p++] = new_Range(0, num - 1);
        while (p) {
            Range range = r[--p];
            if (range.start >= range.end)
                continue;
            int mid = arr[(range.start + range.end) / 2]; // 選取中間點為基準點
            int left = range.start, right = range.end;
            do
            {
                while (arr[left] < mid) ++left;   // 檢測基準點左側是否符合要求
                while (arr[right] > mid) --right; //檢測基準點右側是否符合要求
    
                if (left <= right)
                {
                    swap(&arr[left],&arr[right]);
                    left++;right--;               // 移動指針以繼續
                }
            } while (left <= right);
    
            if (range.start < right) r[p++] = new_Range(range.start, right);
            if (range.end > left) r[p++] = new_Range(left, range.end);
        }
    }
    
    void quick_sort_recursive(int arr[], int start, int end) {
        if (start >= end)
            return;
        int mid = arr[end];
        int left = start, right = end - 1;
        while (left < right) {
            while (arr[left] < mid && left < right)
                left++;
            while (arr[right] >= mid && left < right)
                right--;
            swap(&arr[left], &arr[right]);
        }
        if (arr[left] >= arr[end])
            swap(&arr[left], &arr[end]);
        else
            left++;
        if (left)
            quick_sort_recursive(arr, start, left - 1);
        quick_sort_recursive(arr, left + 1, end);
    }
    //快速排序 递归
    void quickSort2(int *arr, int len) {
        quick_sort_recursive(arr, 0, len - 1);
    }
    
    //二分查找
    int halfSearch(int key, int *a, int n) //自定义函数binary_search()
    {
        int start=0;
        int end=n-1;
        while (start<=end){
            int middle=(start+end)/2;
            if (key<a[middle]){
                end=middle-1;
            } else if (key>a[middle]){
                start=middle+1;
            } else{
                return middle;
            }
        }
        return -1;
    }
    
    //查找重复
    void searchRepeat(int *arr, int num, int searchKey){
        for (int i = 0; i < num; ++i) {
            for (int j = i+1; j < num; ++j) {
                if (arr[i]==arr[j]){
                    LOGI("repeat num index:%d", i);
                    break;
                }
            }
        }
    }
    

    如果对你有帮助记得点赞哦!!!

    展开全文
  • 图论常用算法

    千次阅读 2017-08-16 13:44:24
    图论常用算法 最小生成树 Prim算法(普利姆算法) 关键问题 Krustral算法(克鲁斯卡尔算法) 关键问题 最短路径 拓扑排序 关键路径 网络流问题 图论常用算法 最小生成树 首先, 什么是最小生成树 图论...
  • 常用算法策略总结

    万次阅读 2019-05-03 08:49:34
    常用算法策略总结 策略是面向问题的,算法是面向实现的。 一、不同算法策略特点小结 1、贪心策略 ​ 贪心策略一方面是求解过程比较简单的算法,另一方面它又是对能适用问题的条件要求最严格(即适用范围很小)的算法...
  • 0. 常用算法概述1. 常用遍历算法1.1 for_each1.2 transform 0. 常用算法概述 算法主要是由头文件<algorithm>、 <functional> 、<numeric>组成; <algorithm>是所有STL头文件中最大的一个,...
  • 拐点检测常用算法介绍

    千次阅读 多人点赞 2019-09-25 14:14:54
    拐点检测常用算法介绍 最近在学习拐点检测的相关问题, 发现 C.Truong 的论文 对拐点检测的整个流程和目前主流的一些算法介绍的比较清楚,所以在这里进行了一些记录以及总结,并且对 Truong 发布的 ruptures 库做了...
  • 五大常用算法

    万次阅读 多人点赞 2018-10-05 07:13:50
    五大常用算法   分治算法   一、基本概念  在计算机科学中,分治法是一种很重要的算法。字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题...
  • 数学建模十大常用算法

    千次阅读 2019-05-23 00:22:51
    数学建模常用的十大常用算法: 蒙特卡罗算法。 数据拟合、参数估计、插值等数据处理算法。 线性规划、整数规划、多元规划、二次规划等规划类算法。 图论算法。 动态规划、回溯搜索、分治算法、分支定界等...
  • 五大常用算法总结

    万次阅读 多人点赞 2016-06-10 23:26:41
    据说有人归纳了计算机的五大常用算法,它们是贪婪算法,动态规划算法,分治算法,回溯算法以及分支限界算法。虽然不知道为何要将这五个算法归为最常用的算法,但是毫无疑问,这五个算法是有很多应用场景的,最优化...
  • 算法思想有很多,业界公认的常用算法思想有8种,分别是枚举、递推、递归、分治、贪心、试探法、动态迭代和模拟。当然8种只是一个大概的划分,是一个“仁者见仁、智者见智”的问题。 1.1 枚举算法思想 知识点讲解...
  • 目录简介一、监督学习1、决策树(Decision Tree,DT)2、朴素贝叶斯分类器(Naive Bayesian Model,NBM)3、最小二乘法(Least squares)4、逻辑回归(Logistic Regression)5、支持向量机(SVM)6、K最近邻算法...
  • 数学建模教程:建模常用算法

    千次阅读 2021-01-02 01:09:19
    本篇文章,学长列举一部分数学建模常用算法,会陆续更新每个算法的详细实现和使用教程。 建模常用算法 Apriori-关联规则挖掘算法 FPTree-频繁模式树算法 AdaBoost-装袋提升算法 CART-分类回归树算法 ID3-决策树分类...
  • 五大常用算法入门(一)——贪心算法

    万次阅读 多人点赞 2019-02-25 21:48:13
    贪心算法简介1.1 基本定义1.2 贪心算法案例3.贪心算法的基本思路2.贪心算法最优性证明2.1 贪心算法的前提2.2 最优子结构2.3 贪心算法与动态规划的区别3.贪心算法的经典问题3.1 近似解3.2 最优解参考资料 1.贪心算法...
  • 面试常用算法总结——排序算法(java版)
  • 五大常用算法之一:分治算法

    万次阅读 多人点赞 2019-06-18 20:58:55
    分治算法 一、基本概念 在计算机科学中,分治法是一种很重要的算法。字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问题可以简单...
  • 推荐系统常用算法

    千次阅读 2018-06-05 11:41:51
    推荐系统常用算法 还没细看里面的内容,但总体浏览感觉概况总结的不错,先mark一下,算是A Survery of Recommendation System吧。具体算法的细节肯定需要另外找资料进一步研究,但认真看完肯定会对目前常用的推荐...
  • 常用算法稳定性分析

    千次阅读 2019-05-21 17:11:06
    【转】常用算法稳定性分析      排序算法的稳定性大家应该都知道,通俗地讲就是能保证排序前两个相等的数据其在序列中的先后位置顺序与排序后它们两个先后位置顺序相同。即:如,...
  • STL- 常用算法 常用遍历算法 for_each transform 常用查找算法 find find_if adjacent_find binary_search count count_if STL- 常用算法 概述: 算法主要是由头文件<algorithm> <f...
  • 嵌入式系统软件设计中的常用算法(完整版)

    千次下载 热门讨论 2014-01-08 00:38:40
    嵌入式系统软件设计中的常用算法(完整版),嵌入式入门基础教材。
  • 五大常用算法系列

    千次阅读 2014-12-05 11:14:57
    五大常用算法之一:分治算法 五大常用算法之二:动态规划算法 五大常用算法之三:贪心算法 五大常用算法之四:回溯法 五大常用算法之五:分支限界法
  • scala的数组常用算法

    千次阅读 2020-02-09 18:40:08
    数组常用算法 scala中的数组封装了一些常用的计算操作,将来在对数据处理的时候,不需要我们自己再重新实现。以下为常用的几个算法: 求和——sum方法 求最大值——max方法 求最小值——min方法 排序——sorted方法 ...
  • 拼图游戏常用算法

    千次阅读 2018-01-17 18:26:28
    拼图游戏常用算法 1、随机数组生成 //随机矩阵 /** * * @param {Object} arr 要混洗的范围 * @param {Object} count 得到数组的大小 */ function getRandomArrayElements(arr, count) { //拷贝所有数组...
  • 经典常用算法

    千次阅读 2012-04-08 21:18:53
    第一阶段:练经典常用算法,下面的每个算法给我打上十到二十遍,同时自己精简代码,因为太常用,所以要练到写时不用想,10-15分钟内打完,甚至关掉显示器都可以把程序打出来。 1.最短路(Floyd、...
  • Leetcode五大常用算法

    千次阅读 2016-09-07 17:30:05
    Leetcode的5大常用算法
  • Sklearn包含的常用算法

    千次阅读 2018-03-01 17:56:28
    原文传送门:Sklearn包含的常用算法   说明 文章列出了Sklearn模块中常用的算法及调用方法,部分生僻的未列出(对我来说算生僻的),如果有写的不对的地方请指出。  参考资料来自sklearn官方网站:...
  • 大数据常用算法及场景

    万次阅读 2018-03-28 13:09:42
    大数据常用算法及场景 大数据的挖掘是从海量、不完全的、有噪声的、模糊的、随机的大型数据库中发现隐含在其中有价值的、潜在有用的信息和知识的过程,也是一种决策支持过程。其主要基于人工智能,机器学习,模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 688,719
精华内容 275,487
关键字:

常用算法