2019-12-19 16:55:05 wl1411956542 阅读数 11
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11224 人正在学习 去看看 张丹

集合

简单说一下集合的概念,集合包含一组可区分的对象,称为成员或元素。如果一个对象x是对象S的一个成员,记为xSx\in{S}。如果x不是S的成员,则记为xSx\notin{S}。通过在一对大括号中显式列出集合的所有成员的方式描述一个集合,例如通过S={1,2,3}S = \{1,2,3\}定义一个包含成员1,2,3的集合。如果两个集合A和B包含相同的成员,则称A,B相等(忽略顺序和重复元素)。
常用集合有几种

  • \empty表示空集
  • Z\Z表示整数集
  • R\R表示实数集
  • N\N表示自然数集

如果集合A的所有元素都在集合B中,即如果xAx\in{A}就有xBx\in{B},则可以记为ABA\subseteq{B},集合A是集合B的一个子集。当且仅当ABA\subseteq{B}BAB\subseteq{A}时,有A=B。对于任意三个集合A,B,C,如果ABA\subseteq{B}BCB\subseteq{C},则ACA\subseteq{C}。对于任意集合A,有A\empty\subseteq{A}

集合操作服从下列定律:
空集律
A=A=A A\bigcap{\empty} = \empty \\ A\bigcup{\empty} = A
幂等律
AA=AAA=A A\bigcap{A} = A \\ A\bigcup{A} = A
交换律
AB=BAAB=BA A\bigcap{B} = B\bigcap{A} \\ A\bigcup{B} = B\bigcup{A}
结合律
A(BC)=(AB)CA(BC)=(AB)C A\bigcap({B}\bigcap{C}) = (A\bigcap{B})\bigcap{C} \\ A\bigcup({B}\bigcup{C}) = (A\bigcup{B})\bigcup{C}
分配律
A(BC)=(AB)(AC)A(BC)=(AB)(AC) A\bigcap({B}\bigcup{C}) = (A\bigcap{B})\bigcup(A\bigcap{C}) \\ A\bigcup({B}\bigcap{C}) = (A\bigcup{B})\bigcap(A\bigcup{C})
吸收律
A(AB)=AA(AB)=A A\bigcap({A}\bigcup{B}) = A \\ A\bigcup({A}\bigcap{B}) = A
德·摩根律
A(BC)=(AB)(AC)A(BC)=(AB)(AC) A-({B}\bigcap{C}) = (A-B)\bigcup(A-C) \\ A-({B}\bigcup{C}) = (A-B)\bigcap(A-C)

通常,所有被考虑的集合都是一个全域U的子集,例如,当考虑各种仅有整数组成的集合时,集合Z就是个合适的全域。给定一个全集U,可以定义A的补集为Aˉ=UA\bar{A} = U - A,对于任何集合AUA\subseteq{U},有以下定律:
Aˉˉ=AAAˉ=AAˉ=U \bar{\bar{A}} = A \\ A\bigcap{\bar{A}} = \empty \\ A\bigcup{\bar{A}} = U
德·摩根律可以补集形式表示。对任意两个集合B,CUB,C\subseteq{U},有
BC=BˉCˉBC=BˉCˉ \overline{B\bigcap{C}} = \bar{B}\bigcup{\bar{C}} \\ \overline{B\bigcup{C}} = \bar{B}\bigcap{\bar{C}}
如果集合A和B没有公共的元素,即AB=A\bigcap{B} = \empty,则称两者不相交。如果一个非空集合δ={Si}\delta = \{S_i\}满足条件

  • 集合两两不相交,即对SiSjδS_i,S_j\in{\delta},如果iji \neq{j},则SiSj=S_i\bigcap{S_j} = \empty
  • 他们的并集是S,即
    S=SiδSi S = \bigcup\limits_{S_i\in\delta}S_i
    则称集合δ\delta是集合S的一个划分。换句话说,如果S中的每个元素仅出现在一个SiδS_i\in{\delta},则称δ\delta为集合S的一个划分。
           集合中元素的个数称为j集合的势,记为S\left|S\right|。如果两个集合的元素可以形成一一对应,则称两个集合有相同的势。空集的势为0。如果一个集合的势是自然数,则称集合是有限的,反之,他是无限的。如果一个无限集合可以跟自然数集合N形成一一对应,则称其为可数无限;反之,则称其为不可数。整数集Z是可数的,而实数集R是不可数的。
    一个具有n个元素的有限集合常被称为n维集。一个一维集也成为单元集。一个集合的k个元素的子集称为k子集。
    集合S的所有子集的集合,包括空集和S本身表示为2S2^S,称为S的幂集。例如2{a,b}={,{a},{b},{a,b}}2^{\{a,b\}} = \{\empty,\{a\},\{b\},\{a,b\} \}。有限集S的幂集的势是2S2^{\left|S\right|}
    可以使用组合证明,先找有0个元素的子集,再找有1个元素的子集……最后找有n个元素的子集,他们的个数分别是k=0n(nk)\sum\limits_{k=0}^{n}{ n \choose k},恰好是2n2^n
2015-10-21 13:47:23 CrazyCat8023 阅读数 423
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11224 人正在学习 去看看 张丹
#include <algorithm>
#include <cstdlib>
#include <cstdio>
using namespace std;

typedef  int Status;

typedef  struct Event
{
    int OccurTime; //事件发生时刻 
    int NType; //事件类型,0表示到达事件,1-4表示四个窗口的离开事件 
    struct Event *next;
}Event,ElemType; //事件类型,有序链表LinkList的数据元素类型 

typedef Event LinkList,EventList; //事件链表类型,定义为有序链表 

typedef struct QElemType
{
    int ArrivalTime; //到达时刻 
    int Duration; //办理事务所需时间 
    struct QElemType *next;
}QElemType; //队列的数据元素类型 

typedef struct
{
    QElemType  *head; //队头 
    QElemType  *tail; //队尾 
}LinkQueue;

EventList   Ev; //事件表 
Event       En; //事件 
QElemType   Customer; //客户记录 
int         TotalTime; //总的客户逗留时间 
int         CustomerNum; //总的客户数 
LinkQueue   q[5]; //4个客户队列
 
Status InitList(LinkList *L) //初始化事件表 
{
    L->OccurTime=0;
    L->NType=0;
	L->next=NULL;
    return 1;
}

Status OrderInsert(LinkList *L,Event *evt) //按顺序将事件插入事件表 
{
    Event *L1,*L2;
    L2=(Event *)malloc(sizeof(Event));
    if (L2==NULL) return -2;
    L2->OccurTime=evt->OccurTime;
    L2->NType=evt->NType;
    L2->next=NULL;
    L->NType++;
    if (L->next==NULL)
    {
        L->next=L2;
        L2->next=NULL;
    }
    else
    {
        L1=L;
        while (L1->next!=NULL && L1->next->OccurTime<L2->OccurTime)
        {
            L1=L1->next;
        }
        L2->next=L1->next;
        L1->next=L2;
    }
    return 1;
}

Status ListEmpty(LinkList *L) //检查窗口是否有人 
{
    if (L->next==NULL)  return 1;
    return 0;
}

Status DelFirst(LinkList *L,Event *evt) //取出时间表里面的事件 
{
    Event *L1;
    if (L->next==NULL)   return 0;
    L->NType--;
    L1=L->next;
    evt->OccurTime=L1->OccurTime;
    evt->NType=L1->NType;
    L->next=L1->next;
    free(L1);
    return 1;
}

Status InitQueue(LinkQueue *Q) //初始化事件队列 
{
    QElemType *Q1;
    Q1=(QElemType *)malloc(sizeof(QElemType));
    if (!Q1)    return -2;
    Q1->ArrivalTime=0;
    Q1->Duration=0;
    Q1->next=NULL;
    Q->head=Q1;
    Q->tail=Q1;
    return 1;
}

Status GetHead(LinkQueue *Q,QElemType *cut) //取出事件 
{
    QElemType *Q1;
    if (Q->head==Q->tail)   return 0;
    Q1=(Q->head)->next;
    cut->ArrivalTime=Q1->ArrivalTime;
    cut->Duration=Q1->Duration;
    return 1;
}

Status EnQueue(LinkQueue *Q,QElemType *cut) //插入事件到事件队列
{
    QElemType *Q1,*Q2;
    Q2=(QElemType *)malloc(sizeof(QElemType));
    if (!Q2)   return -2;
    Q2->ArrivalTime=cut->ArrivalTime;
    Q2->Duration=cut->Duration;
    Q2->next=NULL;
    Q1=Q->head;
    Q1->Duration++;
    (Q->tail)->next=Q2;
    Q->tail=Q2;
    return 1;
}
Status DeQueue(LinkQueue *Q,QElemType *cut) //在事件队列里面删除已办完事件
{
    QElemType *Q1,*Q2;
    Q1=Q->head;
    Q1->Duration--;
    Q2=(Q->head)->next;
    if (!Q2)     return 0;
    cut->ArrivalTime=Q2->ArrivalTime;
    cut->Duration=Q2->Duration;
    Q1->next=Q2->next;
    if (Q1->next==NULL)   Q->tail=Q1;
    free(Q2);
    return 1;
}
int MinQueue(LinkQueue Q[],int n) //选出发生最早的事件 
{
    int temp;
    int i,min;
    min=1;
    temp=Q[1].head->Duration;
    for (i=2;i<n;i++)
    {
        if (Q[i].head->Duration<temp)
        {
            temp=Q[i].head->Duration;
            min=i;
        }
    }
    return min;
}
void OpenForDay() //初始化操作 
{
    int i;
    TotalTime=0; //初始化总的时间为0 
    CustomerNum=0; //初始化总的客户数为0 
    InitList(&Ev); //初始化事件链表为空 
    En.OccurTime=0; //设定第一个客户到达事件 
    En.NType=0;     //
    OrderInsert(&Ev,&En); //插入事件表 
    q[0].head=q[0].tail=NULL;
    for (i=1;i<5;i++) //置空队列 
    {
        InitQueue(&q[i]);
    }
}
void CustomerArrived() //处理客户到达事件 
{
    Event      en;
    QElemType  cu;
    double     durtime,intertime;
    int        i,t;
    int        a=1,b=20,x=1,y=5;
    durtime=a+rand()%(b-a+1); //生成随机数 
    intertime=x+rand()%(y-x+1); //生成随机数
    ++CustomerNum;     
    t=En.OccurTime+intertime; //下一个客户到达时间 
    if (t<480)  //银行没关门则插入事件表 
    {
        en.OccurTime=t;
        en.NType=0;
        en.next=NULL;
        OrderInsert(&Ev,&en);
    }
    cu.ArrivalTime=En.OccurTime;
    cu.Duration=durtime;
    i=MinQueue(q,5);  //求长度最短的队列 
    EnQueue(&q[i],&cu); //插入最短的队列 
    if (q[i].head->Duration==1)
    {
        en.OccurTime=cu.ArrivalTime+cu.Duration;
        en.NType=i;
        en.next=NULL;
        OrderInsert(&Ev,&en);
    }
}
void CustomerDeparture() //处理客户离开事件 
{
    Event en;
    int i=0;
    i=En.NType;
    DeQueue(&q[i],&Customer); //删除第i队列的排头客户 
    TotalTime+=En.OccurTime-Customer.ArrivalTime; //累计逗留时间 
    if (q[i].head->Duration!=0) //设定第i队列的一个离开事件并插入事件表 
    {
        GetHead(&q[i],&Customer);
        en.NType=i;
        en.OccurTime=En.OccurTime+Customer.Duration;
        OrderInsert(&Ev,&en);
    }
}
int  main()
{
    OpenForDay();
    while (!ListEmpty(&Ev)) //当事件表不为空 
    {
        DelFirst(&Ev,&En);
        if (En.NType==0) //如果为到达事件则处理到达事件 
        {
            CustomerArrived();
        }
        else
        {
            CustomerDeparture();
        }
    }
    printf("总时间=%d\n总人数=%d\n",TotalTime,CustomerNum);
    printf("平均时间 %.3f\n ",(float)TotalTime/CustomerNum);
    return 0;
}

2018-02-19 17:13:16 rdgfdd 阅读数 101
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11224 人正在学习 去看看 张丹

数据结构-线性结构-离散存储-动态链表

C语言实现:

头文件:

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

结构体构造类型-链表节点类型:

typedef struct node
{
  struct node *next;
  int data;
}Node;

函数接口:

  • 创建链表(头插法)
Node *Creat_List()
{
      Node *phead=(Node *)malloc(sizeof(Node));
      assert(phead!=NULL);
      phead=NULL;
      Node *pnew=NULL;
      int temp;
      while(1)
      {
        printf("Input value:\n");
        scanf("%d",&temp); 
        if(0==temp)
          break;
        pnew=(Node *)malloc(sizeof(Node));
        assert(NULL!=pnew);
        pnew->data=temp;
        pnew->next=phead->next;
        phead=pnew;        
      }
      return phead;
}
  • 创建链表(尾插法)
Node *Creast_List()
{
   Node *phead=(Node *)malloc(sizeof(Node));
   assert(NULL!=phead);
   phead->next=NULL;
   Node *ptemp=phead,*pnew=NULL;
   int data;
   printf("Input value:\n");
   scanf("%d",&data);
   while(data)
   {
      pnew=(Node *)malloc(sizeof(Node));
      pnew->data=data;
      pnew->next=NULL;
      ptemp->next=pnew;
      ptemp=ptemp->next;
      printf("Input value:\n");
      scanf("%d",&data);
   }
   return phead;
}
  • 显示链表
void Show_List(Node *phead)
{
   phead=phead->next;
   while(NULL!=phead)
   {
       printf("%d->",phead->data);
       phead=phead->next;
   }
}
  • 求链表长度
int Lenth_List(Node *phead)
{
    int lenth=0;
    phead=phead->next;
    while(NULL!=phead)
    {
       lenth++;
       phead=phead->next;
    }
    return lenth;
}
  • 头插法(通过参数传地址修改头结点指向)
void Push_Front(Node **phead,int data)
{
   Node *pnew=(Node *)malloc(sizeof(Node));
   assert(NULL!=pnew);
   pnew->data=data;
   pnew->next=(*phead)->next;
   (*phead)->next=pnew;
}
  • 头插法(通过返回值修改头结点指向)
NodePush_Front(Node *phead,int data)
{
   Node *pnew=(Node *)malloc(sizeof(Node));
   assert(NULL!=pnew);
   pnew->data=data;
   pnew->next=phead->next;
   phead->next=pnew;

   return phead;
}
  • 尾插法
void Push_Back(Node *phead,int data)
{
   Node *pend=phead;
   while(NULL=pend->next)
   {
      pend=pend->next;
   }
   Node *pnew=(Node *)malloc(sizeof(Node));
   pnew->data=data;
   pend->next=pnew;
   pnew->next=NULL;
}
  • 按值查找
int Find_Data(Node *phead,int data)
{
   int count=0;
   phead=phead->next;
   while(NULL!=phead)
   {
      count++;
      if(phead->data==data)
      {
          return count;
      }
      phead=phead->next;
   }
   return -1;
}
  • 按位置查找
int Find_Pos(Node *phead,int pos)
{
   while(pos--)
  {
     phead=phead->next;
  }
  return phead->data;
}
  • 头删法
void Del_Front(Node *phead)
{
    phead->next=phead->next->next;
}
  • 尾删法
void Del_Back(Node *phead)
{
   Node *pend=phead;
   while(NULL!=pend->next->next)
   {
      pend=pend->next;
   }
   pend->next=NULL;
}
  • 按位置删除
void Del_Pos(Node *phead,int pos)
{
   while(--pos-1)
   {
       phead=phead->next;
   }
   phead->next=phead->next->next;
}
  • 排序
void Sort_List(Node *phead)
{
   int lenth=Lenth_List(phead);
   Node *ptemp=NULL;
   for(int i=1;i<lenth;++i)
   {
       ptemp=phead->next;
       for(int j=0;j<=lenth-i;++j)
       {    
           if(ptemp->data>ptemp->next->data)
           {
                int temp=ptemp->data;
                ptemp->data=ptemp->next->data;
                ptemp->next->data=temp;
           }
           ptemp=ptemp->next;
       }
   }
}
  • 逆置
Node *Reverse_List(Node *phead)
{
    Node *ptemp=phead->next;
    Node *pend=NULL;
    phead->next=NULL;
    while(NULL!=ptemp)
    {
      pend=ptemp;
      ptemp=ptemp->next;
      pend->next=phead->next;
      phead->next=pend;
    }
}
  • 摧毁
void Destroy_List(Node *phead)
{
  Node *ptemp=phead->next;
  while(NULL!=ptemp)
  {
     phead=phead->next;
     free(ptemp);
     ptemp=phead;
  }
}
2018-01-30 12:33:38 sizaif 阅读数 861
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11224 人正在学习 去看看 张丹

离散化处理数据应用在, 当输入数据超过一般数组定义大小1e7时  1-1e18的数据时,但又需要用数据来记录,

此时可以离散数据.  例如 假设输入数据为 111,1234567891011,995888558266445,25;  数据数组下标开不了这么大的.

离散后用大小关系从1-n个数据 来代表原数据,  111->2 ;1234567891011->3 ; 995888558266445->4; 25->1

两个数组,a[]存原数据,b[]数组存离散化后的, a[b[]]就是原数据

STL中 代码很简洁;

输入,

排序,去重

离散

	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		b[i]=a[i];
	}
	sort(a+1,a+n+1);
	int size=unique(a+1,a+n+1)-a-1;
	//cout<<size<<endl;
	for(int i=1;i<=n;i++)
	{
		//b[i]=lower_bound(a,a+size,b[i])-a;
		b[i]=upper_bound(a+1,a+size+1,b[i])-a-1;
	}
	for(int i=1;i<=n;i++)
		cout<<a[b[i]]<<" "<<b[i]<<endl;
	return 0;

lower_bound 和 upper_bound 的区别在于,  离散后 前面是从0-n-1;   后面是 1-n;


2016-09-21 17:10:09 qq_25428769 阅读数 569
  • R语言知识体系概览

    R语言是一门统计语言,主要用于数学建模、统计计算、数据处理、可视化 等几个方向,R语言天生就不同于其他的编程语言。R语言封装了各种基础学科的计算函数,我们在R语言编程的过程中只需要调用这些计算函数,就可以构建出面向不同领域、不同业务的、复杂的数学模型。掌握R语言的语法,仅仅是学习R语言的第一步,要学好R语言,需要你要具备基础学科能力(初等数学,高等数学,线性代数,离散数学,概率论,统计学) + 业务知识(金融,生物,互联网) + IT技术(R语法,R包,数据库,算法) 的结合。所以把眼光放长点,只有把自己的综合知识水平提升,你才真正地学好R语言。换句话说,一旦你学成了R语言,你将是不可被替代的。

    11224 人正在学习 去看看 张丹

离散数据和连续数据是相对的:

区别在于作用域,连续数据的作用域是连续的。例如1~9;

离散数据的作用域是不连续的。例如1~3   5~7。

线性数据和非线性数据的区别是:

线性数据中的每一个元素都有确定的“前驱”和“后继”(头和尾除外),是一条线下来的,没有分支;

非线性结构的逻辑特征是一个结点元素可能对应多个直接前驱和多个后继。

没有更多推荐了,返回首页