个人头像照片 聚小编

个人介绍

云栖社区聚能聊、问答管理员~发福利、搞怪,八卦我来,论技术、发话题、写博客你上!

  • 最新动态
  • 文章
  • 问答
正在加载, 请稍后...
暂无更多信息
正在加载, 请稍后...
暂无更多信息
  • 回答了问题 2019-07-17

    只有一个开发app的想法,我该怎么办

    别做app了,结合支付宝、微信小程序开发吧。省时省力省钱

    踩0 评论0
  • 回答了问题 2019-07-17

    算法与数据结构中的大O到底是什么..简单明了点

    时间复杂度的表示。
    O(1),你可以理解为y=c(c为常数),这样的复杂度是不随x的变化而改变的。
    O(n)你就理解成y=x咯,复杂度是随着x的增长成线性增加的。
    同理,O(n^2)可以理解成y=x^2,复杂度随着x的增长成二次函数增加。
    当n比较大(在具体的项目中一般都比较大),O(1),o(n),o(n^2)三者的复杂度关系是:
    O(1)<o(n)<o(n^2)
    踩0 评论0
  • 回答了问题 2019-07-17

    rsa加密算法中怎样生成一个大素数

    可以分两步先随机一个数然后判定是否素数如此搞到两个就OK了直接生成大素数的算法不知道有没有
    踩0 评论0
  • 回答了问题 2019-07-17

    软件工程XP模型简介

    XP极限编程时一种敏捷软件开发模型,XP由四部分组成,交流、简化、反馈、勇气。
    http://wenku.baidu.com/view/2b30260ef12d2af90242e6ca.html
    踩0 评论0
  • 回答了问题 2019-07-17

    求RSA密码的C语言实现算法的源程序(可通过运行)(1024位的)

    加密的时候,输入Y,然后输入要加密的文本(大写字母)
    解密的时候,输入N,然后输入一个整数n表示密文的个数,然后n个整数表示加密时候得到的密文。
    /*RSA algorithm */
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #define MM 7081
    #define KK 1789
    #define PHIM 6912
    #define PP 85
    typedef char strtype[10000];
    int len;
    long nume[10000];
    int change[126];
    char antichange[37];

    void initialize()
    { int i;
    char c;
    for (i = 11, c = 'A'; c <= 'Z'; c ++, i ++)
    { change[c] = i;
    antichange[i] = c;
    }
    }
    void changetonum(strtype str)
    { int l = strlen(str), i;
    len = 0;
    memset(nume, 0, sizeof(nume));
    for (i = 0; i < l; i ++)
    { nume[len] = nume[len] * 100 + change[str[i]];
    if (i % 2 == 1) len ++;
    }
    if (i % 2 != 0) len ++;
    }
    long binamod(long numb, long k)
    { if (k == 0) return 1;
    long curr = binamod (numb, k / 2);
    if (k % 2 == 0)
    return curr * curr % MM;
    else return (curr * curr) % MM * numb % MM;
    }
    long encode(long numb)
    { return binamod(numb, KK);
    }
    long decode(long numb)
    { return binamod(numb, PP);
    }
    main()
    { strtype str;
    int i, a1, a2;
    long curr;
    initialize();
    puts("Input 'Y' if encoding, otherwise input 'N':");
    gets(str);
    if (str[0] == 'Y')
    { gets(str);
    changetonum(str);
    printf("encoded: ");
    for (i = 0; i < len; i ++)
    { if (i) putchar('-');
    printf(" %ld ", encode(nume[i]));
    }
    putchar('\n');
    }
    else
    { scanf("%d", &len);
    for (i = 0; i < len; i ++)
    { scanf("%ld", &curr);
    curr = decode(curr);
    a1 = curr / 100;
    a2 = curr % 100;
    printf("decoded: ");
    if (a1 != 0) putchar(antichange[a1]);
    if (a2 != 0) putchar(antichange[a2]);
    }
    putchar('\n');
    }
    putchar('\n');
    system("PAUSE");
    return 0;
    }
    测试:
    输入:
    Y
    FERMAT
    输出:
    encoded: 5192 - 2604 - 4222
    输入
    N
    3 5192 2604 4222
    输出
    decoded: FERMAT
    踩0 评论0
  • 回答了问题 2019-07-17

    建立二叉树的递归算法怎样理解??

    不断地在纸上或脑子里执行每一步,在一点要深刻理解函数的调用和形参和实参的概念,还有return语句。熟能生巧一位牛人说的.
    踩0 评论0
  • 回答了问题 2019-07-17

    快速排序算法有什么作用

    就平均时间而言,快速排序被认为是目前最好的一种内部排序。
    踩0 评论0
  • 回答了问题 2019-07-17

    非对称加密和对称加密的区别

    对称加密算法

    对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。收信方收到密文后,若想解读原文,则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文。在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密,这就要求解密方事先必须知道加密密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。不足之处是,交易双方都使用同样钥匙,安全性得不到保证。此外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的惟一钥匙,这会使得发收信双方所拥有的钥匙数量成几何级数增长,密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难,主要是因为密钥管理困难,使用成本较高。在计算机专网系统中广泛使用的对称加密算法有DES、IDEA和AES。

    传统的DES由于只有56位的密钥,因此已经不适应当今分布式开放网络对数据加密安全性的要求。1997年RSA数据安全公司发起了一项“DES挑战赛”的活动,志愿者四次分别用四个月、41天、56个小时和22个小时破解了其用56位密钥DES算法加密的密文。即DES加密算法在计算机速度提升后的今天被认为是不安全的。

    AES是美国联邦政府采用的商业及政府数据加密标准,预计将在未来几十年里代替DES在各个领域中得到广泛应用。AES提供128位密钥,因此,128位AES的加密强度是56位DES加密强度的1021倍还多。假设可以制造一部可以在1秒内破解DES密码的机器,那么使用这台机器破解一个128位AES密码需要大约149亿万年的时间。(更深一步比较而言,宇宙一般被认为存在了还不到200亿年)因此可以预计,美国国家标准局倡导的AES即将作为新标准取代DES。

    不对称加密算法

    不对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用不对称加密算法加密文件时,只有使用匹配的一对公钥和私钥,才能完成对明文的加密和解密过程。加密明文时采用公钥加密,解密密文时使用私钥才能完成,而且发信方(加密者)知道收信方的公钥,只有收信方(解密者)才是唯一知道自己私钥的人。不对称加密算法的基本原理是,如果发信方想发送只有收信方才能解读的加密信息,发信方必须首先知道收信方的公钥,然后利用收信方的公钥来加密原文;收信方收到加密密文后,使用自己的私钥才能解密密文。显然,采用不对称加密算法,收发信双方在通信之前,收信方必须将自己早已随机生成的公钥送给发信方,而自己保留私钥。由于不对称算法拥有两个密钥,因而特别适用于分布式系统中的数据加密。广泛应用的不对称加密算法有RSA算法和美国国家标准局提出的DSA。以不对称加密算法为基础的加密技术应用非常广泛。

    参考资料: http://www.williamlong.info/archives/500.html
    踩0 评论0
  • 回答了问题 2019-07-17

    如何用C语言程序实现RSA算法?

    http://www.example-code.com/vcpp/rsa_generateKey.asp这里应该有您要的东西,希望能帮助到您
    踩0 评论0
  • 回答了问题 2019-07-17

    求二叉树叶子结点个数的非递归算法(c语言)

    层次遍历用队列
    或者用栈实现中序后序先序的非递归遍历
    踩0 评论0
  • 回答了问题 2019-07-17

    打擂法排序和选择法排序是一回事吗?

    不是一回事吧
    踩0 评论0
  • 回答了问题 2019-07-17

    Java数据结构与算法我刚学java没多久,可以开始吗?

    没必要,刚学的话,就多联系,达到熟练再说
    踩0 评论0
  • 回答了问题 2019-07-17

    快速排序算法原理与实现

    概述
    快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(nlogn)次比较。事实上,快速排序通常明显比其他Ο(nlogn) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来,并且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性。
    快速排序,通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,然后分别对这两部分记录继续进行排序,以达到整个序列有序的目的。
    形象图示:

    步骤
    选择一个基准元素,通常选择第一个元素或者最后一个元素
    通过一趟排序将待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值均比基准值大
    此时基准元素在其排好序后的正确位置
    然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。

    实例
    原始数据:
    3 5 2 6 2
    选择 3 作为基准
    第一轮
    ?

    1234567

    从右往左找比3小的,2符合,将2和3对调2 5 2 6 3对调一次,查找的方向反向,从左向右找比3大的,5符合,对调2 3 2 6 5再从右往左找比3小的,2符合,对调2 2 3 6 5一轮结束

    第二轮
    ?

    12

    对 [2 2] 采用同上的方式进行,得到2 2 3 6 5

    第三轮
    ?

    12

    对 [6 5] 采用同上的方式进行,得到2 2 3 5 6

    最终结果
    2 2 3 5 6
    代码实现(Java)
    ?

    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091

    package com.coder4j.main.arithmetic.sorting; public class Quick { private static int mark = 0; /** * 辅助交换方法 * * @param array * @param a * @param b */ private static void swap(int[] array, int a, int b) { if (a != b) { int temp = array[a]; array[a] = array[b]; array[b] = temp; // 找到符合的,对调 System.out.println("对调" + array[a] + "与" + array[b] + ",得到"); for (int i : array) { System.out.print(i + " "); } System.out.println(); } } /** * 新一轮分隔 * * @param array * @param low * @param high * @return */ private static int partition(int array[], int low, int high) { int base = array[low]; mark++; System.out.println("正在进行第" + mark + "轮分隔,区域:" + low + "-" + high); while (low < high) { while (low < high && array[high] >= base) { high--; System.out.println("从右往左找比" + base + "小的,指针变动:" + low + "-" + high); } swap(array, low, high); while (low < high && array[low] <= base) { low++; System.out.println("从左往右找比" + base + "大的,指针变动:" + low + "-" + high); } swap(array, low, high); } return low; } /** * 对数组进行快速排序,递归调用 * * @param array * @param low * @param heigh * @return */ private static int[] quickSort(int[] array, int low, int heigh) { if (low < heigh) { int division = partition(array, low, heigh); quickSort(array, low, division - 1); quickSort(array, division + 1, heigh); } return array; } /** * 快排序 * * @param array * @return */ public static int[] sort(int[] array) { return quickSort(array, 0, array.length - 1); } public static void main(String[] args) { int[] array = { 3, 5, 2, 6, 2 }; int[] sorted = sort(array); System.out.println("最终结果"); for (int i : sorted) { System.out.print(i + " "); } } }

    测试输出结果:
    ?

    12345678910111213141516171819

    全选复制放进笔记正在进行第1轮分隔,区域:0-4对调2与3,得到2 5 2 6 3从左往右找比3大的,指针变动:1-4对调3与5,得到2 3 2 6 5从右往左找比3小的,指针变动:1-3从右往左找比3小的,指针变动:1-2对调2与3,得到2 2 3 6 5从左往右找比3大的,指针变动:2-2正在进行第2轮分隔,区域:0-1从右往左找比2小的,指针变动:0-0正在进行第3轮分隔,区域:3-4对调5与6,得到2 2 3 5 6从左往右找比6大的,指针变动:4-4最终结果2 2 3 5 6

    经测试,与实例中结果一致。
    踩0 评论0
  • 回答了问题 2019-07-17

    递归算法的执行过程,一般来说,可先后分成哪两个阶段?

    是:“递推和回归”两个阶段
    踩0 评论0
  • 回答了问题 2019-07-17

    冒泡排序与选择排序有什么区别

      冒泡,选择,希尔...等排序算法是前辈们总结出来的经典排序算法,它们各有自己的优缺点,适合不同情况下使用。比如冒泡排序实现起来简单,如果待排序数据量小,并且对效率要求不高时,完全可以满足;希尔排序效率比冒泡高,但是算法实现稍复杂,一般人们不愿意去实现它。
    我认为排序算法的根本区别是它们排序的效率,就是排序消耗的时间和空间。你如果要比较冒泡排序和选择排序的区别,就去分析它们排序时分别占用的时间和空间。老实说,这些内容算法书都有讲解,但是我从来没有认真去研究分析过,也没有真的去计算过一个算法的效率值。如果那位对这方面熟悉,不妨帮 @飞行苏 计算下。 不过根据对算法的理解,冒泡排序的效率不会大于选择排序
    踩0 评论0
  • 回答了问题 2019-07-17

    树的非递归算法

    参考一下
    非递归递归都有

    #include "iostream.h"
    #include "stdlib.h"
    #include "stdio.h"

    typedef char ElemType;//定义二叉树结点值的类型为字符型
    const int MaxLength=10;//结点个数不超过10个

    typedef struct BTNode{
    ElemType data;
    struct BTNode *lchild,*rchild;
    }BTNode,* BiTree;

    void CreateBiTree(BiTree &T){//按先序次序输入,构造二叉链表表示的二叉树T,空格表示空树
    // if(T) return;
    char ch;
    ch=getchar(); //不能用cin来输入,在cin中不能识别空格。
    if(ch==' ') T=NULL;
    else{
    if(!(T=(BTNode *)malloc(sizeof(BTNode)))) cout<<"malloc fail!";
    T->data=ch;
    CreateBiTree(T->lchild);
    CreateBiTree(T->rchild);
    }
    }

    void PreOrderTraverse(BiTree T){//先序遍历
    if(T){
    cout<<T->data<<' ';
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
    }
    }
    void InOrderTraverse(BiTree T){//中序遍历
    if(T){
    InOrderTraverse(T->lchild);
    cout<<T->data<<' ';
    InOrderTraverse(T->rchild);
    }
    }
    void PostOrderTraverse(BiTree T){//后序遍历
    if(T){
    PostOrderTraverse(T->lchild);
    PostOrderTraverse(T->rchild);
    cout<<T->data<<' ';
    }
    }
    void LevelOrderTraverse(BiTree T){//层序遍历

    BiTree Q[MaxLength];
    int front=0,rear=0;
    BiTree p;
    if(T){ //根结点入队
    Q[rear]=T;
    rear=(rear+1)%MaxLength;
    }
    while(front!=rear){
    p=Q[front]; //队头元素出队
    front=(front+1)%MaxLength;
    cout<<p->data<<' ';
    if(p->lchild){ //左孩子不为空,入队
    Q[rear]=p->lchild;
    rear=(rear+1)%MaxLength;
    }
    if(p->rchild){ //右孩子不为空,入队
    Q[rear]=p->rchild;
    rear=(rear+1)%MaxLength;
    }
    }

    }
    //非递归的先序遍历算法
    void NRPreOrder(BiTree bt)
    { BiTree stack[MaxLength],p;
    int top;
    if (bt!=NULL){
    top=0;p=bt;
    while(p!=NULL||top>0)
    { while(p!=NULL)
    {
    cout<<p->data;
    stack[top]=p;
    top++;
    p=p->lchild;
    }
    if (top>0)
    { top--; p=stack[top]; p=p->rchild; }
    }
    }
    }
    //非递归的中序遍历算法
    void NRInOrder(BiTree bt)
    { BiTree stack[MaxLength],p;
    int top;
    if (bt!=NULL){
    top=0;p=bt;
    while(p!=NULL||top>0)
    { while(p!=NULL)
    {

    stack[top]=p;
    top++;
    p=p->lchild;
    }
    if (top>0)
    { top--; p=stack[top];cout<<p->data; p=p->rchild; }
    }
    }
    }
    //非递归的后序遍历算法
    /*bt是要遍历树的根指针,后序遍历要求在遍历完左右子树后,再访问根。
    需要判断根结点的左右子树是否均遍历过。
    可采用标记法,结点入栈时,配一个标志tag一同入栈
    (1:遍历左子树前的现场保护,2:遍历右子树前的现场保护)。
    首先将bt和tag(为1)入栈,遍历左子树;
    返回后,修改栈顶tag为2,遍历右子树;最后访问根结点。*/

    typedef struct
    {
    BiTree ptr;
    int tag;
    }stacknode;

    void NRPostOrder(BiTree bt)
    {
    stacknode s[MaxLength],x;
    BiTree p=bt;
    int top;
    if(bt!=NULL){
    top=0;p=bt;
    do
    {
    while (p!=NULL) //遍历左子树
    {
    s[top].ptr = p;
    s[top].tag = 1; //标记为左子树
    top++;
    p=p->lchild;
    }

    while (top>0 && s[top-1].tag==2)
    {
    x = s[--top];
    p = x.ptr;
    cout<<p->data; //tag为R,表示右子树访问完毕,故访问根结点
    }

    if (top>0)
    {
    s[top-1].tag =2; //遍历右子树
    p=s[top-1].ptr->rchild;
    }
    }while (top>0);}
    }//PostOrderUnrec

    int BTDepth(BiTree T){//求二叉树的深度
    if(!T) return 0;
    else{
    int h1=BTDepth(T->lchild);
    int h2=BTDepth(T->rchild);
    if(h1>h2) return h1+1;
    else return h2+1;
    }
    }

    int Leaf(BiTree T){//求二叉树的叶子数
    if(!T) return 0;
    else if(!T->lchild&&!T->rchild) return 1;
    else return(Leaf(T->lchild)+Leaf(T->rchild));
    }

    int NodeCount(BiTree T){//求二叉树的结点总数
    if(!T) return 0;
    else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
    }

    void main(){
    BiTree T;
    T=NULL;
    int select;
    //cout<<"请按先序次序输入各结点的值,以空格表示空树(输入时可连续输入):"<<endl;
    // CreateBiTree(T);
    while(1){
    cout<<"\n\n请选择要执行的操作:\n";
    cout<<"1.创建二叉树\n";
    cout<<"2.二叉树的递归遍历算法(前、中、后)\n";
    cout<<"3.二叉树的层次遍历算法\n";
    cout<<"4.求二叉树的深度\n";
    cout<<"5.求二叉树的叶子结点\n";
    cout<<"6.求二叉树的结点总数\n";
    cout<<"7.二叉树的非递归遍历算法(前、中、后)\n"; //此项可选做
    cout<<"0.退出\n";
    cin>>select;
    switch(select){
    case 0:return;
    case 1:
    cout<<"请按先序次序输入各结点的值,以空格表示空树(输入时可连续输入):"<<endl;
    CreateBiTree(T);
    break;
    case 2:
    if(!T) cout<<"未建立树,请先建树。";
    else{
    cout<<"\n先序遍历:\n";
    PreOrderTraverse(T);
    cout<<"\n中序遍历:\n";
    InOrderTraverse(T);
    cout<<"\n后序遍历:\n";
    PostOrderTraverse(T);
    }
    break;
    case 3:
    cout<<"\n层序遍历:\n";
    LevelOrderTraverse(T);
    break;
    case 4:
    cout<<"二叉树的深度为:\n";
    cout<<BTDepth(T);
    break;
    case 5:
    cout<<"\n叶子节点数:\n";
    cout<<Leaf(T);
    break;
    case 6:
    cout<<"总节点数:\n";
    cout<<NodeCount(T);
    break;
    case 7:
    if(!T) cout<<"未建立树,请先建树。";
    else{
    cout<<"\n先序遍历:\n";
    NRPreOrder(T);
    cout<<"\n中序遍历:\n";
    NRInOrder(T);
    cout<<"\n后序遍历:\n";
    NRPostOrder(T);
    }
    break;
    default:
    cout<<"请确认选择项:\n";
    }//end switch
    }//end while

    }

    先输入1
    然后输入回车
    再输入123
    再输入一个空格
    再输入4
    再输入三个空格
    再输入56
    再输入三个空格
    再输入输入回车
    一定要照这循序输这输不要乱敲回车和其他键
    踩0 评论0
  • 回答了问题 2019-07-17

    如何评价udacity的人工智能工程师课程

    测试点时候,
    踩0 评论0
  • 回答了问题 2019-07-17

    C#里.如何使用递归算法?什么是递归啊?

    递归就是反复调用函数自身【有条件的调用】,但不满足调用自身的条件时,就返回到上一层【当然是和自己一样的函数,但层次不同】,一直返回到第一次调用的地方
    踩0 评论0
  • 回答了问题 2019-07-17

    为什么数据结构与算法,对前端开发很重要

    前端的技术领域和范围正在飞速演进中,再过3年5年不懂算法和数据结构的前端慢慢就淘汰了。几大互联网公司的已经开始在使用数据挖掘、贝叶斯、3D图形图像等领域算法到前端领域。对浏览器的了解也逐步深入到内部实现机制原理上,从原理上理解渲染。无线端的前端越来越像嵌入式应用开发,这些都更需要有扎实而综合的计算机专业基础。
    踩0 评论0
  • 回答了问题 2019-07-17

    以下排序算法最坏情况下时间复杂度最低的是 A.冒泡排序 B.插入 C.选择 D.快排

    快排
    踩0 评论0
正在加载, 请稍后...
滑动查看更多