努力努力再努力0.0

19版考研数据结构王道课后习题代码-线性表【完】

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define maxSize 101

/*
//设计递归算法，删除不带头节点的单链表中所有值为x的节点 P37 1
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(List &t,int x)
{
    if(t)
    {
        if(t->data==x)
    {
        LNode *p=t;
        t=t->next;
        free(p);
        Delete(t,x);
    }
    Delete(t->next,x);
    }
}
int main()
{
    LNode *t;
    int n,t0;
    cin>>n;
    cin>>t0;
    t=(LNode*)malloc(sizeof(LNode));
    t->data=t0;
    t->next=NULL;
    LNode *q=t;
    for(int i=1;i>t0;
        LNode *s=(LNode*)malloc(sizeof(LNode));
        s->data=t0;
        q->next=s;
        q=s;
        q->next=NULL;
    }

    Delete(t,3);
    while(t)
    {
        cout<data<<" ";
        t=t->next;
    }
}
*/

/*
//删除带头节点的单链表中值为x的节点 P37 2
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Delete(LNode *&t,int x)
{
    LNode *pre=t;
    LNode *p=pre->next;
    while(p)
    {
        if(p->data==x)
        {
            pre->next=p->next;
            p=pre->next;
        }
        else
        {
            pre=pre->next;
            p=pre->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t,3);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}

*/


/*
//从尾到头反向输出单链表的值 P37 3
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Reverse(LNode *t)
{
    int stack[maxSize];
    int top=-1;
    while(t->next)
    {
        stack[++top]=t->next->data;
        t=t->next;
    }
    while(top!=-1)
    {
        cout<next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Reverse(t);
}
5
4 2 1 6 7
7 6 1 2 4
*/


/*
//删除单链表的最小值节点 P37 4
//用minpre和minp来删除节点！！
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(LNode *&t)
{
    LNode *minpre,*minp;
    int min;
    LNode *pre=t;
    LNode *p=t->next;
    minp=p;
    minpre=pre;
    min=p->data;
    while(p)
    {
        if(p->datadata;
            minp=p;
            minpre=pre;
        }
        p=p->next;
        pre=pre->next;
    }
    minpre->next=minp->next;
    free(minp);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}
 */

/*
//将带头节点的单链表就地逆置 P37 5
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Reverse(LNode *&t)
{
    LNode *p=t;
    LNode *q=p->next;
    LNode *r=q->next;
    q->next=NULL;   //易错点!!!一点要让q后面为空！！！
    LNode *s;
    while(r)
    {
        s=r->next;
        r->next=q;
        p->next=r;
        q=r;
        r=s;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Reverse(t);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}
*/


/*
//使带头节点的单链表单增 P37 6  使用直接插入排序
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void SelectSort(LNode *&t)
{
    LNode *prer=t->next;
    LNode *r=t->next->next;
    while(r)
    {
        LNode *pre=t;
        LNode *p=t->next;
        while(p->data<=r->data&&p!=r)  //易错点！！要加上等号且p不能超过r！！
        {
            p=p->next;
            pre=pre->next;
        }
        if(p->data>r->data)
        {
            prer->next=r->next;
            r->next=p;
            pre->next=r;
            r=prer->next;
        }
        else
        {
            r=r->next;
            prer=prer->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    SelectSort(t);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}
//7
//3 1 4 1 2 9 1
//1 1 1 2 3 4 9
*/


/*
//删除介于给定两个值之间的元素 P37 7
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Delete(LNode *t,int a,int b)
{
    LNode *pre=t;
    LNode *p=pre->next;
    while(p)
    {
        if(p->data>=a&&p->data<=b)
        {
            pre->next=p->next;
            p=pre->next;
        }
        else
        {
            pre=pre->next;
            p=p->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t,2,5);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}


7
3 2 1 5 6 7 3
1 6 7
*/


/*
//找出两个链表的公共节点 P37 8  公共节点不只是值相同，而是同一个节点的意思。形状像Y，而不是X，从第一个公共节点到尾节点，这一部分是重合的
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
int strlen(LNode *t)
{
    int cnt=0;
    while(t->next)
    {
        cnt++;
        t=t->next;
    }
    return cnt;
}
LNode *Find(LNode *l1,LNode *l2)
{
    int len1=strlen(l1);
    int len2=strlen(l2);
    LNode *longlist,*shortlist;
    int longlen,shortlen;
    if(len1>len2)
    {
        longlist=l1;
        longlen=len1;
        shortlist=l2;
        shortlen=len2;
    }
    else
    {
        longlist=l2;
        longlen=len2;
        shortlist=l1;
        shortlen=len1;
    }
    int t=longlen-shortlen;
    while(t)
    {
        longlist=longlist->next;
        t--;
    }
    while(longlist&&shortlist)
    {
        if(longlist==shortlist)
        {
            return longlist;
        }
        else
        {
            shortlist=shortlist->next;
            longlist=longlist->next;
           // cout<data<<" "<data<next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t3=(LNode*)malloc(sizeof(LNode));
    t3->next=NULL;
    int n3;
    cin>>n3;
    cin>>t0;
    t3->data=t0;
    LNode *q3=t3;
    for(int i=1;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q3->next=p;
        q3=p;
        q3->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    q->next=t3;
    q2->next=t3;
    
//    while(t->next)
//    {
//        cout<next->data<<" ";
//        t=t->next;
//    }
//    cout<next)
//    {
//        cout<next->data<<" ";
//        t2=t2->next;
//    }
    
    LNode *s=Find(t,t2);
    cout<data;
}
*/


/*
//按递增顺序输出节点元素的数据，并释放节点所占的空间  P37 9  每次找出单链表中最小的元素，输出，删除
typedef struct LNode
{
    int data;
    LNode *next;
}LNode,*List;
void Sort(LNode *head)
{
    while(head->next)
    {
        LNode *p=head->next;
        int min=p->data;
        LNode *minp=p;
        LNode *minpre=head;
        LNode *pre=head;
        while(p)
        {
            if(p->datadata;
                minp=p;
                minpre=pre;
            }
        p=p->next;
        pre=pre->next;
        }
        cout<next=minp->next;
        free(minp);
    }
    free(head);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Sort(t);
}


6
3 6 4 1 2 8
1 2 3 4 6 8
*/

/*
//将单链表A分解为A和B，A含序号为奇数的元素，B含偶数 P37 10
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Split(LNode *a)
{
    int i=0;
    LNode *p=a;
    LNode *ra=(LNode*)malloc(sizeof(LNode));
    ra->next=NULL;
    LNode *b=(LNode*)malloc(sizeof(LNode));
    b->next=NULL;
    LNode *rb;
    rb=b;
    while(p->next)
    {
        i++;
        p=p->next;
        if(i%2==1)
        {
            ra->next=p;
            ra=p;
        }
        else
        {
            rb->next=p;
            rb=p;
        }
    }
    ra->next=NULL;
    rb->next=NULL;
    while(a->next)
    {
        cout<next->data<<" ";
        a=a->next;
    }
    cout<next)
    {
        cout<next->data<<" ";
        b=b->next;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Split(t);
}
*/


/*
//就地算法，拆分单链表 P37 11
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Split(LNode *t)
{
    LNode *p=t->next;
    int i=0;
    LNode *a=(LNode*)malloc(sizeof(LNode));
    a->next=NULL;
    LNode *ra=a;
    LNode *b0=(LNode*)malloc(sizeof(LNode));
    b0->next=NULL;
    LNode *b=b0;
    while(p)
    {
        i++;
        if(i%2==1)
        {
            ra->next=p;
            ra=p;
            p=p->next;   //易错点
            ra->next=NULL;
        }
        else
        {
            LNode *q=p;
            p=p->next;   //注意上下这两个易错点处，改变q会把p也改变，因此p要后移才能保存p的后继节点！！
            q->next=b->next;
            b->next=q;
        }
    }
    
    while(a->next)
    {
        cout<next->data<<" ";
        a=a->next;
    }
    while(b0->next)
    {
        cout<next->data<<" ";
        b0=b0->next;
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Split(t);
}

5
3 2 1 2 4
3 1 4 2 2
*/

/*
//删除表中重复元素 P37 12
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
void Delete(LNode *t)
{
    LNode *p=t->next;
    LNode *q=p->next;
    while(q)
    {
       if(q->data==p->data)
       {
           p->next=q->next;
           q=p->next;
       }
        else
        {
            p=p->next;
            q=q->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}

7
1 2 2 2 2 3 3
1 2 3
*/


/*
//将两个单增链表合并为一个单减链表 P37 13
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Merge(LNode *t1,LNode *t2)
{
    LNode *p=t1->next;
    LNode *q=t2->next;
    LNode *s0=(LNode*)malloc(sizeof(LNode));
    s0->next=NULL;
    LNode *s=s0;
    while(p&&q)
    {
        while(p&&q&&p->datadata)
        {
            LNode *x1=p;
            p=p->next;   //易错点！！注意这一句的顺序！！！p先移动，再改变x1的指针，否则p会被丢失！！
            x1->next=NULL;
            x1->next=s->next;
            s->next=x1;
        }
        while(p&&q&&p->data>=q->data)
        {
            LNode *x2=q;
            q=q->next;
            x2->next=NULL;
            x2->next=s->next;
            s->next=x2;
        }
    }
    while(p)
    {
        LNode *x1=p;
        p=p->next;
        x1->next=NULL;
        x1->next=s->next;
        s->next=x1;
    }
    while(q)
    {
        LNode *x2=q;
        q=q->next;
        x2->next=NULL;
        x2->next=s->next;
        s->next=x2;
    }
    return s;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *s=Merge(t,t2);
    while(s->next)
    {
        cout<next->data<<" ";
        s=s->next;
    }
}

3
1 2 3
4
2 3 4 5
5 4 3 3 2 2 1
*/


/*
//从A，B公共元素中产生单链表C  P37 14
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Common(LNode *a,LNode *b)
{
    LNode *c=(LNode*)malloc(sizeof(LNode));
    c->next=NULL;
    LNode *cc=c;
    LNode *p=a->next;
    LNode *q=b->next;
    while(p&&q)
    {
        while(p&&q&&p->datadata)
        {
            p=p->next;
        }
        while(p&&q&&p->data>q->data)
        {
            q=q->next;
        }
        if(p&&q&&p->data==q->data)  //这一句也要加上p&&q都存在！！！
        {
            LNode *x=(LNode*)malloc(sizeof(LNode));
            x->data=p->data;
            cc->next=x;
            cc=x;
            cc->next=NULL;
            p=p->next;
            q=q->next;
        }
    }
    return c;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    LNode *s=Common(t,t2);
    while(s->next)
    {
        cout<next->data<<" ";
        s=s->next;
    }
}

3
1 3 5
6
1 2 3 4 7 8
1 3

*/


/*
//求交集 P37 15
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
LNode *Common(LNode *a,LNode *b)
{
    LNode *ra=a->next;
    LNode *rb=b->next;
    LNode *r=a;
    LNode *u;
    while(ra&&rb)
    {
        while(ra&&rb&&ra->datadata)
        {
            u=ra;
            ra=ra->next;
            free(u);
        }
        while(ra&&rb&&ra->data>rb->data)
        {
            u=rb;
            rb=rb->next;
            free(u);
        }
        if(ra&&rb&&ra->data==rb->data)
        {
            r->next=ra;
            r=ra;
            ra=ra->next;
            u=rb;
            rb=rb->next;
            free(u);
        }
    }
    while(ra)
    {
        u=ra;
        ra=ra->next;
        free(u);
    }
    while(rb)
    {
        u=rb;
        rb=rb->next;
        free(u);
    }
    r->next=NULL;
    free(b);
    return a;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    LNode *s=Common(t,t2);
    while(s->next)
    {
        cout<next->data<<" ";
        s=s->next;
    }
}

3
2 4 7
5
1 2 3 4 8
2 4
*/


/*
//判断连续子序列  P38  16
typedef struct LNode
{
    int data;
    LNode *next;
}LNode;
int Sequence(LNode *a,LNode *b)
{
    LNode *ra=a->next;
    LNode *rb=b->next;
    while(ra&&rb)
    {
        LNode *s=ra;
        while(ra&&rb&&ra->data==rb->data)
        {
            ra=ra->next;
            rb=rb->next;
        }
        if(rb==NULL)
        {
            return 1;
        }
        else
        {
            ra=s->next;
            rb=b->next;
        }
    }
    return 0;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    int d=Sequence(t,t2);
    cout<next;
    LNode *b=t->prior;
    while(b!=t&&a!=t)
    {
        if(a->data!=b->data)
        {
            return 0;
        }
        a=a->next;
        b=b->prior;
    }
    return 1;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
    }
    q->next=t;
    t->prior=q;
    int d=Judge(t);
    cout<next!=h1)
    {
        a=a->next;
    }
    a->next=h2;
    a=h2;
    while(a->next!=h2)
    {
        a=a->next;
    }
    a->next=h1;
    return h1;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    int n,t0;
    cin>>n;
    cin>>t0;
    t->data=t0;
    LNode *q=t;
    for(int i=1;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
    }
    q->next=t;
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    int n2;
    cin>>n2;
    cin>>t0;
    t2->data=t0;
    LNode *q2=t2;
    for(int i=1;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
    }
    q2->next=t2;
    LNode *s=Merge(t,t2);
    LNode *d=s;   //易错点：记得保留头节点！！
    while(s->next!=d)
    {
        cout<data<<" ";
        s=s->next;
    }
    cout<data;
}

3
4 2 1
4
2 6 3 1
4 2 1 2 6 3 1
*/


/*
//删除循环单链表中的最小值。P38 19
typedef struct LNode
{
    int data;
    LNode *next,*prior;
}LNode;
void Delete(LNode *t)
{
    LNode *p,*pre;
    while(t->next!=t)
    {
        p=t->next;
        pre=t;
        int min=p->data;
        LNode *minp=p;
        LNode *minpre=t;
        while(p!=t)   //易错点！！！注意是p而不是p->next
        {
            if(p->datadata;
                minp=p;
                minpre=pre;
            }
            p=p->next;
            pre=pre->next;
        }
        cout<next=minp->next;
        free(minp);
    }
    free(t);
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
    }
    q->next=t;
    Delete(t);
}


6
1 3 4 3 2 1
1 1 2 3 3 4
*/

/*
//对双向链表进行排序，先按访问频度，再按最近访问时间 P38 20
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
LNode *Locate(LNode *t,int x)
{
    LNode *p=t->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
    }
    p->prior->next=p->next;
    p->next->prior=p->prior;
    p->freq++;
    LNode *q=t->next;
    while(q!=NULL&&q->freq>p->freq)
    {
        q=q->next;
    }
    p->next=q;
    q->prior->next=p;
    p->prior=q->prior;
    q->prior=p;
    return p;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
        q->next=NULL;
    }
    LNode *s=Locate(t,2);
    
}
*/

/*
//查找链表中倒数第k个位置的节点的值 P38 21
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
int Search(LNode *list,int k)
{
    LNode *p=list->next;
    LNode *pre=list->next;
    while(k)
    {
        p=p->next;
        if(p==NULL)
            return 0;
        k--;
    }
    while(p)
    {
        p=p->next;
        pre=pre->next;
    }
    return pre->data;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        p->prior=q;
        q=p;
        q->next=NULL;
    }
    int d=Search(t,3);
    cout<next)
    {
        cnt++;
        t=t->next;
    }
    return cnt;
}
LNode *Find(LNode *a,LNode *b)
{
    int len1=strlen(a);
    int len2=strlen(b);
    LNode *longlist,*shortlist;
    int min1,max2;
    if(len1next;
        t--;   //注意循环控制条件！！！
    }
    while(longlist&&shortlist)
    {
        if(longlist->data==shortlist->data)
        {
            return longlist;
        }
        else
        {
            longlist=longlist->next;
            shortlist=shortlist->next;
        }
    }
    return NULL;
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t2=(LNode*)malloc(sizeof(LNode));
    t2->next=NULL;
    LNode *q2=t2;
    int n2;
    cin>>n2;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q2->next=p;
        q2=p;
        q2->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    
    LNode *t3=(LNode*)malloc(sizeof(LNode));
    t3->next=NULL;
    int n3;
    cin>>n3;
    cin>>t0;
    t3->data=t0;
    LNode *q3=t3;
    for(int i=1;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q3->next=p;
        q3=p;
        q3->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    q->next=t3;
    q2->next=t3;
    
    LNode *s=Find(t,t2);
    while(s)
    {
        cout<data<<" ";
        s=s->next;
    }
}


3
2 4 5
2
6 8
4
2 6 4 3
2 6 4 3
*/


/*
//删除绝对值相同的元素 P38 23
typedef struct LNode
{
    int data,freq;
    LNode *next,*prior;
}LNode;
void Delete(LNode *t)
{
    int map[maxSize];
    LNode *p=t->next;
    LNode *pre=t;
    while(p)
    {
        if(map[abs(p->data)]==0)
        {
            map[abs(p->data)]++;
            p=p->next;
            pre=pre->next;
        }
        else if(map[abs(p->data)]==1)
        {
            pre->next=p->next;
            p=pre->next;
        }
    }
}
int main()
{
    LNode *t=(LNode*)malloc(sizeof(LNode));
    t->next=NULL;
    LNode *q=t;
    int n,t0;
    cin>>n;
    for(int i=0;i>t0;
        LNode *p=(LNode*)malloc(sizeof(LNode));
        p->data=t0;
        q->next=p;
        q=p;
        q->next=NULL;  //!!!易错点，一定要记得置NULL
    }
    Delete(t);
    while(t->next)
    {
        cout<next->data<<" ";
        t=t->next;
    }
}

5
21 -15 -15 -7 15
21 -15 -7
*/

厉国刚：新闻学与传播学到底有何区别微观大道
厉国刚：新闻学与传播学到底有何区别头几天，有人在知乎上问我：新闻学与传播学到底有何区别。他是一位想要跨专业考研的学生，对新闻传播学学科可谓了解甚少，甚至一头雾水，想要让我帮他解释解释。在研究生学硕层面，新闻传播学是一级学科，分成新闻学、传播学这两个二级学科。有些高校，还自设了广告学、出版发行学等其他二级学科，但从官方角度，新闻传播学一级学科下，正统的就是那两个二级学科。招生时，一般会按一级学科招，
女儿考研完报考雅思捡拾流年
是否我过于焦虑？会不会无形间让女儿觉得压力太大了啊。2022年对于我们家来说是不平常的一年。女儿今年大四，为了准备考研，暑假也没回家，年初去了学校到了年末才回家。女儿自己一个人面对考研，没有参加培训，大四学校作业论文等课业也多，她同时也是很努力复习考研的。在疫情开放很多羊的时期，女儿终于顺顺利利参加12月24、25号的考研，我们和家人都觉得女儿回家来要好好休息调养。可女儿回到家，我再查阅考研信息，
童年那些故事教给我们的山川大地日月星辰
同事的女儿二次考研失败，但是仍不气馁还想接着再学再考，得为孩子点个赞，可是同事很矛盾，以她的意见，当初女儿大学毕业就该直接考编，回到家过安稳日子，我问她还记不记得《小马过河》的故事？她说跟小马有啥关系？幼儿园就给孩子讲《小马过河》，当然孩子们除了喜欢故事里的“人物”小松鼠、老牛、小马跟老马，对小马爱劳动喜欢帮助妈妈干活也是有基本认知的，孩子们对为什么老牛说水浅、而松鼠说水深也有一定的常识，到了成人
2019考研 | 西交大软件工程笔者阿蓉
本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
大三成了分手季? 三聿鱼
图片发自App一次玩真心话大冒险的时候，知道漂亮的A学姐原来和社团那个帅帅的学长H原来是彼此的前任。知道时还是惊讶的，知道学长H现在在准备考研，上次从湖边回学校时，他说现在很忙，所以社团那边也没有再去。他想考武汉大学，每天都是泡图书馆。后来和学姐A在假期一次一次合作后，也熟络很多，知道她也将要回老家实习，想考公务员。学姐A大学专业是英语，当时想问更多，觉得不变开口，也没再问。在那次真心话大冒险中，
二战考研失败，焦虑了宇蜃
成绩昨天就出了，由于比预想的能想到的还低，泪眼之后，还是要分析一下促成其的原因1.主要也最表面的原因。考试状态，发烧（特别是晚上）三天考试的后两天都没睡好，考试之后免费给做一次单管核酸，核酸结果是之后的四天半才出（我一度怀疑肯定是阳性了）但最后结果显示是阴性。但无论怎样，疫情一放开的这次考试，阳性学生包围着我的考场，真真切切的影响到了我的考试临场状态。（作为一个还没工作的学生，所处地区一直低风险的
2019-11-29晨间日记麦新
今天是什么日子起床：6:00就寝：23:30天气：晴朗心情：平静纪念日：第二场比赛叫我起床的不是闹钟是梦想年度目标及关键点：国考考研本月重要成果：学习今日三只青蛙/番茄钟点评作业出镜点评夜班成功日志-记录三五件有收获的事务出镜点评点评作业夜班财务检视-1人际的投入来回跑～开卷有益-学习/读书/听书《孔子》健康与饮食今日步数：8000+好习惯打卡早晚打卡阅读打卡听书打卡社群打卡
焦灼解决不了问题臭小妈妈
又到一年考研时。最近心情焦虑不安，一个人想分作几个人使，一个人工作，一个人在家哄孩子做家务，还有一个人努力实现理想，可是现实是，一个人只要工作了就哄不了孩子，做不了家务，理想在一边空置着，无法实现，只能一次次于梦醒时分，空落一阵唏嘘。但心里知道，即使空自唏嘘一年，万年，也实现不了愿望，只能趁着时光还少，还有机会，尽早努一把力，一眼看到头的生活实在是虚度光阴，富不了丢不掉的鸡肋生活要尽早弃掉，不然温
三对角线型行列式的求法 Mr-Apple 笔记线性代数矩阵算法
三对角线型行列式摘要典型例题练习题参考答案摘要笔者在复习高等代数行列式这章时,发现三对角行列式问题是行列式计算中经常出现的一类行列式,部分考研院校也曾直接出过三对角行列式的计算,亦或是三对角行列式的变体问题.本文主要介绍了一种通常情况下三对角行列式的解法,即采用特征根法来求解行列式的通项公式.例1:计算nnn阶行列式(ac≠0)(ac\neq0)(ac=0)Dn=∣bc0…000abc…0000
在职四战考研3day MM加油女孩
今日已完成考研任务：与教务处老师联系，学习怎么正确使用书籍；看333教育综合大纲；日总结：下午下班后与教务处老师联系，老师跟我讲了资料的正确使用方式，心里也有了大概的思路——根据老师提供的教材，我第一轮需要用到的资料就是一本通+网课，书籍只作为辅助对象，倘若网课里的内容听懂了，老师说书籍就可以不看了。第二轮复习：就是网课+自己构建思维导图，并尝试做333教育综合的主观题；第三轮复习：背诵客观题起码
溯源2019，我起起落落落落落的2019年 _楠桑_
写在前面：这段时间我一直在思考自己的方向和其他选择，又回顾了自己的2019总结，希望能对自己有一个更为深入的了解。原文：这两天原本是开学报道的时间，疫情肆虐，多了大半个月的假期。宅在家的二十多天，枯燥无聊，我觉得应该做些更有意义的事情，首先，从记录自己的生活开始。01彼时的2月，春节是2月5日。就像大多数人那样，大三过半，开始思考自己2019年的计划，或是考研升学，或是计划考公，或是实习找工作。由
跟可心在一起的第十八天海子的另一种灵魂
早上可心来接我特别开心，虽然腿有些疼，但是见到可心就特别开心，阳光正好，牵着你也正好。享受我们在一起的每一天，每一个小时，每一分钟，每一秒，对于我来说都有着美好的回忆，快考研了，要好好加油哦，可心，无论你做什么我都陪着你的，因为我来了就从来没想过走，因为一切都是命中注定。永远爱你，照顾你。爱你哦，媳妇儿，超爱的那种哦。大兔子和小兔子一起吃饭.小兔子捧着饭碗,对大兔子说:"想你.""我不就在你身边吗
我们成为不了高手，都是因为这个小墨鱼天天很开心
每个人都希望活出自己的风采，就如同张国荣的一首歌《我》里面写的那样“我就是我，不一样的烟火”。虽然我们都是这样想的，身体却很老实，我们在很多情况下活在别人的评价中。具体表现就是在学生时代我们很多人成了伪学习者，工作中我们成了伪工作者。成甲把这种现象称之为“低勤奋陷阱”。我记得我当年考研时，遇到一个研友，他真的学习特别特别刻苦。我在任何时候都能在考研教室碰到他，不管是早上的7点钟，还是晚上的12点以
月度总结 | 2022年03月 | 考研与就业的抉择 | 确定未来走大数据开发路线「已注销」个人总结 hadoop
一、时间线梳理3月3日，寻找到同专业的就业伙伴3月5日，着手准备Java八股文，决定先走Java后端路线3月8月，申请到了校图书馆的考研专座，决定暂时放弃就业，先准备考研，买了数学和408的资料书3月9日-3月13日，因疫情原因，宿舍区暂封，这段时间在准备考研，发现内容特别多3月13日-3月19日，大部分时间在刷Hadoop、Zookeeper、Kafka的视频，同时在准备实习的项目3月20日，退
基于springboot+vue的“考研资讯平台”程序设计实现【毕业论文，源码】一枚务实的码农毕业设计毕设考研 spring boot 毕业论文系统源码
摘要随着现在网络的快速发展，网络的应用在各行各业当中它很快融入到了许多学校的眼球之中，他们利用网络来做这个电商的服务，随之就产生了“考研资讯平台”，这样就让学生考研资讯平台更加方便简单。对于本考研资讯平台的设计来说，它主要是采用java技术。在整个系统的设计当中它是应用mysql数据库来完成的，具体根据网上考研资讯平台的现状来进行开发的，具体根据学生需求实现网上考研资讯平台网络化的管理，各类信息有
冬至已至，考研正当时青梧_4285
“夏尽秋分日，春生冬至时”，今年的冬至，在考研厚重气氛下显得有那么一点点不一样。冬至已至，考研正当时。图片发自App数九第一天的冬至，汉代便有记载。“冬至前后，君子安身静体，百官绝事，不听政”。《后汉书》里的“冬节”，过的从容而淡定，当真是宛如君子一般。而《晋书》中的“魏晋冬至日受万国及百僚称贺……其仪亚于正旦”让人感到魏晋时期冬至的热闹与欢喜。细究其中，我们不难发现中国传统节日总是被人赋予“团圆
烦躁 jessica3827
下午三点多才起床，今天的心情很怪，有种没办法控制的感觉，心脏很焦躁的比往常跳的更快一些，不想吃饭，就干脆一直坐着发呆。昨晚一直学习到凌晨六点多才睡觉，被考研折磨的作息已经变成了日夜颠倒，所以有时候猛的在下午醒过来，就会被怅然若失的低落感瞬间包围。不小心打开了朋友圈，呵，好热闹，都没能敢多看几眼，怎么回事？感觉这个世界上就我被抛弃了？感觉好饿，微信上问我妈要不要出去吃点什么，很久都不回复我，得，自己
焦虑症又犯了马公子的中场休息
不知道到底因何事，也许是考研失败，也许是工作一次次受挫，也许是棘手的人际关系让人焦头烂额，也许是孩子的哭闹…….我不得不承认，我就是一个很普通很平凡的人，既不能变身奥特曼打怪兽，也不能救死扶伤桃李满天下。曾经的豪言壮语，过去的踌躇满志，都已被埋葬。理想和实力总是隔着一个马里亚纳海沟。时常想，如果有100万存款，我会躺平会摆烂，我会在受了委屈时看看账户里的余额，说下次再惹我我就回家睡觉，睡到自然醒，
2019-1-16晚间日记换一个昵称
今天是什么日子起床：5点58就寝：23点34天气：晴，飘一些小雪心情：还行吧，因为错了五道题有点儿不开心纪念日：叫我起床的不是闹钟是梦想是梦想年度目标及关键点：考研本月重要成果：坚持学习今日三只青蛙/番茄钟番茄钟成功日志-记录三五件有收获的事务背单词，做题，画思维导图
长大了? 四月春酒
晚上，和爹妈如约打视频电话。又到了微信钱包个位数的窘困的时候，恰逢遇上申请预备党员需要高中回函信的盖章，我又要准备考研，就得让我老爹替我跑一趟。我对他们说，怎么去找人盖章。老爹却说我瞎操心。我一笑，“那不是不想让你多操心嘛，觉得很麻烦你。”，“这两天没打电话，你是长大了?说话怎么这么客气”，泪流。高二，有次生病，给我妈打电话，电话那头说“真给我嫌麻烦！”。从小，我受的委屈，很少向父母说，我害怕他们
有没有关于人生的答案雨松溪
这16条职场道理，越早知道越好：1.提高学历。无论专升本，考研，考博。读书是跨越阶层最好的方式。2.圈子要干净，处事要冷静，思考要安静。3.和优秀的人在一起。无论是朋友，师长，还是陌生人。当然我说的在一起是正常社交。4.人脉永远是致胜法宝。5.步入社会后经济独立。6.做好身材管理，形象管理。7.保持身体和心理的清洁明亮。8.空余时间看些简单易懂的医学类书补充自己的医学常识。有病不要百度，尽早接受专
8.23考研日记：一切正常一只支
下午和女朋友聊了一下，她的态度也软了下来，承认其中可能有误会。这是正常的，我们谁不是脾气上来气头上来再怎么冷静也是一头包，说什么也听不进去，她激动，我也激动，我先冷静下来，心平气和的和她谈，她也冷静下来。她让我好好写作，其他等去了学校再说。解决了这个事，写作这件事也没有了负担，下午陆续写了一两千字，数量还算可以，但质量不太满意。和编辑也沟通了一下，分析了一下，自己目前要续写的部分也从四五万字到了两
2022-12-20 虚伪的世界啊
父亲跟我说让考研选个容易考的学校，网上的评论说我考不上，竞争的对手又是去年差0.7分考入的同学，以及中国政法大学等名校的学生，我自己也在怀疑自己到底有没有能力考入了！但是我想证明自己可以！
考研倒计时112天十七同学冲冲冲
今天学习时间比较短，早上姑姑们来我们家送中秋节的礼物，和她们聊得比较久。但是下午晚上整个状态还可以!今日反思:今天早上专业课是第二章看到卷积部分，感觉看的书特别慢，今天早上感觉专业课就只复习了就是齐次解特解，零状态响应零输入响应，感觉复习内容比较少，明天早上得多看一点。然后今天复习了数学的错题，发现还是有好多极限不会做，就还是不知道什么情况下应该把分母上的一些不起主要作用的项给舍去，感觉还是得多积
【保研面试/考研复试】英语口语常见问答（二）九九jiujiu 面试考研保研英语问答保研经验分享
英语口语常见问答FrequentlyAskedQuestionsonSpokenEnglish目录英语口语常见问答FrequentlyAskedQuestionsonSpokenEnglish7.为什么选择跨专业考研？8.讲述一下你的本科专业？（跨专业）9.你最突出的优点是什么？（跨专业）10.当你没听清楚面试官问题时！11.当遇到时间来不及思考或者一时语塞时12.当再次没听懂老师问题时7.为什么
中国股市：最具翻倍潜力的八只低估值优质龙头股，速收藏！青云论
近日，主力资金高低切换明显，低估值板块表现抢眼，以上8只个股是老股弥收盘后精心挑选出来的，具备低估值，量价齐升，主力流入明显的特征，极具爆发潜力，供大家参考研究！1、太极集团：核心题材：中药+养老概念公司以中西成药制造为核心业务,拥有医药工业、医药商业、药材种植等完整的医药产业链。拥有12家制药厂、20多家医药商业公司,是集"工、商、科、贸"一体的大型医药集团,是目前国内医药产业链最为完整的大型企
北京，逃离了却又很想念元气小老虎修炼基地
数了数日子，离毕业不到白天大学的闺蜜，好友，室友，大多去了北京保研，考研或是工作北京真的是一座让人又爱又恨的城市北漂，也确实是一段很甜又很苦涩的日子我和羊，守着13平米的小屋子，度过了半年相互嫌弃，却又相互支持着羊说很想再吃一次我煮的方便面，少放蔬菜我说自北漂之后，再也不想铺床那段日子，没少麻烦阳阳哥和雅茹姐其实还很怀恋李瑞哥的排骨炖豆角还想四个人去楼下吃麻将香锅只要一点点辣还想再和清儿节晶慧丽杨
学生时代三两事小姐姐的书
我还可以说我是学生，至少在我研究生毕业前，我不会被提出学生队伍。毕业前，我一直很焦虑，是的，因为毕业的事情，很多人都知道，毕业必然伴随着一大堆的麻烦，直到那时我才明白，高中的不努力，全都在毕业前被表达了。高考的不如意，让我只能上一所三流的院校，我没有遗憾过，在那之前，甚至一直为自己能上学感到高兴。后来选择了考研，调剂上了一所依然成绩平平的学校。准确的说，在毕业之前，我还愿意去爱我那时的学校，只是，
考研真题）某银行提供了 1 个服务窗口和 10 个供顾客等待时使用的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾不会编程的小孩子 java
（考研真题）某银行提供了1个服务窗口和10个供顾客等待时使用的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾客，并为其服务。顾客和营业员的活动过程描述如下。cobegin{process顾客{从取号机上获得一个号码;等待叫号;获得服务;}process营业员{while(TRUE){叫号;为顾客服务;}}}coe
带爸妈去逛街纳时花
今天终于下定决心给自己放个假，爸妈马上就要回老家了，也难得单独陪他们出门。再三考虑后决定去山师，顺便看看表妹。图片发自App图片发自App高大的银杏树和粗壮的树干把路铺上了一层绿荫，安静的校园，曾经是我向往的学府，那年准备考研到山师，还旁听了半个学期的专业课，最后还是败在了英语和政治上。而表妹没有发挥好竟然轻而易举地考上了化学系。忍不住感叹：智商不如人，情商不如人，如今能比过别人的就只有硬伤了。图
关于旗正规则引擎中的MD5加密问题何必如此 jsp MD5 规则加密
一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
spark sql 访问hive数据的配置详解 daizj spark sql hive thriftserver
spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下： 1、下载源码 2、下载Maven,并配置此配置简单，就略过
HTTP 协议通信周凡杨 java httpclient http 通信
一：简介 HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！二：代码举例测试类： import java
java unix时间戳转换 g21121 java
把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
web报表工具FineReport常用函数的用法总结（报表函数）老A不折腾 web报表 finereport 总结
说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。 CLASS CLASS(object):返回object对象的所属的类。 CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
java jni调用c++ 代码报错墙头上一根草 java C++jni
# # A fatal error has been detected by the Java Runtime Environment: # # EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
Spring中事件处理de小技巧 aijuans spring Spring 教程 Spring 实例 Spring 入门 Spring3
Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
linux shell ls脚本样例 annan211 linux linux ls源码 linux 源码
#! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到则退出码为0 #否则即为找不到的文件个数 #语法 pathfind [--
List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 list set Map遍历方式
List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
解决SimpleDateFormat的线程不安全问题的方法 bijian1013 java thread 线程安全
在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
http请求测试实例（采用fastjson解析） bijian1013 http 测试
在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
RPC异常处理概述 RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
【日志分析】日志分析工具 bit1129 日志分析
1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。　　　来以下优化：　　　
java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
mongoDB 备份与恢复开窍的石头 mongDB备份与恢复
Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host 主机 --port port 端口 -u username 用户名 -p passwd 密码 2: mongoexport 导出json格式的文件
[网络与通讯]椭圆轨道计算的一些问题 comsci 网络
如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
软件专利如何申请 cuiyadll 软件专利申请
软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
Android学习笔记 darrenzhu android
1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序 am start -n package name/.activityName am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
yii2 restful web服务[速率限制] dcj3sjt126com PHP yii2
速率限制为防止滥用，你应该考虑增加速率限制到您的API。例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。如果一个用户同一个时间段内太多的请求被接收，将返回响应状态代码 429 (这意味着过多的请求)。要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
Hadoop2.5.2安装——单机模式 eksliang hadoop hadoop单机部署
转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述 Hadoop有三种模式单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。二、下载地址 Hadoop 网址http:
LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
三道简单的前端HTML/CSS题目 ini html Web 前端 css 题目
使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm 在HTML中加入<table style=”color:red; font-size:10pt”>，此为（）。http://hovertree.com/s
overrided方法编译错误 kane_xie override
问题描述：在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it 当去掉@Over
Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP 代理IP 数据爬虫 JAVA设置代理IP 爬虫封IP
推荐两个代理IP网站： 1. 全网代理IP：http://proxy.goubanjia.com/ 2. 敲代码免费IP：http://ip.qiaodm.com/ Java语言有两种方式使用代理IP访问网址并获取内容，方式一，设置System系统属性 // 设置代理IP System.getProper
Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境 nodejs 纵观千象
当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
C++中三种new的用法 _荆棘鸟_ C++new
转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
Ruby深入研究笔记1 wudixiaotie Ruby
module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end

19版考研数据结构王道课后习题代码-线性表【完】

你可能感兴趣的:(考研)