锐格系统数据结构相关习题

最新推荐文章于 2021-10-24 19:05:33 发布
最新推荐文章于 2021-10-24 19:05:33 发布
阅读量1.3k 收藏 10
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47469819/article/details/108356741
版权
线性表題目內容:采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。输入输出说明:输入：2x^2 3x^3 5x^5 7x^7#-2x^2 2x^3 4x^4 5x^7 9x^9#输出：5x^3 4x^4 5x^5 12x^7 9x^9#include<iostream>#include <stdio.h>struct node{ int co; int exp; struct node * next;};node*
摘要由CSDN通过智能技术生成

线性表

題目內容:
采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。

输入输出说明:
输入：
2x^2 3x^3 5x^5 7x^7#
-2x^2 2x^3 4x^4 5x^7 9x^9#
输出：
5x^3 4x^4 5x^5 12x^7 9x^9


#include<iostream>
#include <stdio.h>
struct node
{
   
    int co;    
	int exp;  
	struct node * next;
};

node* Creat()
{
   
	node* head;
	node* s, *p;
	int c, e;
	char a;
	head=new node;
	head->next=NULL;
do
{
   
    scanf("%d*x^%d%c",&c,&e,&a);
    s=new node;
		s->co = c;
		s->exp = e;
		p=head;
		while(p->next!=NULL)
		{
   
			p=p->next;
		}
		p->next = s;
		s->next = NULL;

}while(a!='#');
	return  head;
}

void Display(node * head)
{
   
	if(head==NULL)
	{
   

		return ;
	}
	node* p;
	p=head->next;
	while(p!=NULL)
	{
   
	    printf("%d*x^%d ",p->co,p->exp);
		p=p->next;
	}
	printf("\n");

}

node* Add(node * A, node * B)
{
   
	node * C=new node;
	C->next=NULL;
	node * p1=A->next;
	node * p2=B->next;
	node * p3;
	node * pC=C;
	while(p1!=NULL && p2!=NULL)
	{
   
		if(p1->exp < p2->exp)
		{
   
			p3=new node;
			p3->co=p1->co;
			p3->exp=p1->exp;
			p3->next=NULL;
			pC->next=p3;
			pC=p3;
			p1=p1->next;
		}
		else if (p1->exp > p2->exp)
		{
   
			p3=new node;
			p3->co=p2->co;
			p3->exp=p2->exp;
			p3->next=NULL;
			pC->next=p3;
			pC=p3;
			p2=p2->next;
		}
		else //p1->exp == p2->exp
		{
   
			if((p1->co + p2->co) != 0)
			{
   
				p3=new node;
				p3->co = p1->co + p2->co;
				p3->exp= p1->exp;
				p3->next=NULL;
				pC->next=p3;
				pC=p3;
			}
			p1=p1->next;
			p2=p2->next;
		}
	}
	if(p1==NULL)
	{
   
		while(p2!=NULL)
		{
   
			p3=new node;
			p3->co=p2->co;
			p3->exp=p2->exp;
			p3->next=NULL;
			pC->next=p3;
			pC=p3;
			p2=p2->next;
		}
	}
	else //p2==NULL
	{
   
		while(p1!=NULL)
		{
   
			p3=new node;
			p3->co=p1->co;
			p3->exp=p1->exp;
			p3->next=NULL;
			pC->next=p3;
			pC=p3;
			p1=p1->next;
		}
	}
	return C;
}
int main()
{
   

	node * p1;
	p1=Creat();
	node * p2;
	p2=Creat();
	node * p3;
	//Display(p1);
	//Display(p2);
	p3=Add(p1,p2);
	Display(p3);

	return 0;
}

題目內容:
随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。

遍历单向链表。

输入输出说明:
输入：
1 2 3 5 7 8 0
输出：
1 2 3 5 7 8

#include <stdio.h>
#include <stdlib.h>
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}Lnode;
void create(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        p->next=q;
        p=q;
        scanf("%d",&data);
    }
}
void output(Lnode* phead)
{
   
    phead=phead->next;
    while(phead!=NULL)
    {
   
        printf("%d ",phead->data);
        phead=phead->next;
    }
}
int main()
{
   
    Lnode *phead=(Lnode *)malloc(sizeof(Lnode));
    phead->next=NULL;
    create(phead);
    output(phead);
    return 0;
}

題目內容:
试编写算法，把单向链表中元素逆置（不允许申请新的结点空间）。

输入输出说明:
输入：
1 2 4 6 8 9 0
输出：
9 8 6 4 2 1

#include <stdio.h>
#include <stdlib.h>
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}Lnode;
void create(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        p->next=q;
        p=q;
        scanf("%d",&data);
    }
}
void output(Lnode* phead)
{
   
    phead=phead->next;
    while(phead!=NULL)
    {
   
        printf("%d ",phead->data);
        phead=phead->next;
    }
}
void reverse(Lnode *phead)
{
   
    Lnode *p=phead,*q;
    p=phead->next;
    phead->next=NULL;
    while(p!=NULL)
    {
   
        q=p;
        p=p->next;
        q->next=NULL;
        q->next=phead->next;
        phead->next=q;
    }
}

int main()
{
   
    Lnode *phead=(Lnode *)malloc(sizeof(Lnode));
    phead->next=NULL;
    create(phead);
    reverse(phead);
    output(phead);
    return 0;
}

題目內容:
编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。

输入输出说明:
输入：
1 6 4 3 5 8 7 9 0
输出：
1 3 4 5 6 7 8 9

#include <stdio.h>
#include <stdlib.h>
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}Lnode;
void create(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        p->next=q;
        p=q;
        scanf("%d",&data);
    }
}
void output(Lnode* phead)
{
   
    phead=phead->next;
    while(phead!=NULL)
    {
   
        printf("%d ",phead->data);
        phead=phead->next;
    }
}
void reverse(Lnode *phead)
{
   
    Lnode *p=phead,*q;
    p=phead->next;
    phead->next=NULL;
    while(p!=NULL)
    {
   
        q=p;
        p=p->next;
        q->next=NULL;
        q->next=phead->next;
        phead->next=q;
    }
}
void deletee(Lnode *phead)
{
   
    Lnode *p,*q;
    p=phead;
    q=phead->next;
    while(q!=NULL)
    {
   
        if(q->data%2==0)
        {
   
            p->next=q->next;
            free(q);
            q=p->next;
        }
        else
        {
   
            p=q;
            q=q->next;
        }
    }
}
elemtype length(Lnode *phead)
{
   
    Lnode *p;
    p=phead->next;
    int a=0;
    while(p!=NULL)
    {
   
        p=p->next;
        a++;
    }
    return a;
}
Lnode *sortlist (Lnode *phead)
{
   
    Lnode *p;
    if(phead->next==NULL)
    {
   
        return phead;
    }
    int n,i,j;
    n=length(phead);
    for(i=1;i<n;i++)
    {
   
        p=phead->next;
        for(j=0;j<n-1;j++)
        {
   
            if(p->data > p->next->data)
            {
   
                elemtype t=p->data;
                p->data=p->next->data;
                p->next->data=t;
            }
            p=p->next;
        }
    }
    return phead;
}
int main()
{
   
    Lnode *phead=(Lnode *)malloc(sizeof(Lnode));
    phead->next=NULL;
    create(phead);
   Lnode *p=sortlist(phead);
    output(p);
    return 0;
}

題目內容:
试编写算法，在单向链表中删除所有的偶数元素结点。

输入输出说明:
输入：
1 2 3 4 6 7 9 0
输出：
1 3 7 9

#include <stdio.h>
#include <stdlib.h>
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}Lnode;
void create(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        p->next=q;
        p=q;
        scanf("%d",&data);
    }
}
void output(Lnode* phead)
{
   
    phead=phead->next;
    while(phead!=NULL)
    {
   
        printf("%d ",phead->data);
        phead=phead->next;
    }
}
void reverse(Lnode *phead)
{
   
    Lnode *p=phead,*q;
    p=phead->next;
    phead->next=NULL;
    while(p!=NULL)
    {
   
        q=p;
        p=p->next;
        q->next=NULL;
        q->next=phead->next;
        phead->next=q;
    }
}
void deletee(Lnode *phead)
{
   
    Lnode *p,*q;
    p=phead;
    q=phead->next;
    while(q!=NULL)
    {
   
        if(q->data%2==0)
        {
   
            p->next=q->next;
            free(q);
            q=p->next;
        }
        else
        {
   
            p=q;
            q=q->next;
        }
    }
}

int main()
{
   
    Lnode *phead=(Lnode *)malloc(sizeof(Lnode));
    phead->next=NULL;
    create(phead);
    deletee(phead);
    output(phead);
    return 0;
}

題目內容:
建立两个非递减有序单向链表，然后合并成一个非递增链表。

输入输出说明:
输入：
1 9 5 7 3 0
2 8 4 6 0
输出：
9 8 7 6 5 4 3 2 1

#include <iostream>
#include<stdio.h>
#include <stdlib.h>
using namespace std;
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}lnode,*linklist;
 void createhead(linklist &l)
{
   
    l=new lnode;
    l->next=NULL;
    int x;
    linklist p,r;
    p=new lnode;
    r=l;
    scanf("%d",&x);
    while(x!=0)
    {
   
         p=new lnode;
        p->data=x;
        p->next=NULL;
       r->next=p;
       r=p;
        scanf("%d",&x);
    }
}
void output(linklist l)
{
   
    linklist p=l->next;
    while(p!=NULL)
    {
   
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
void mergelist(linklist &la,linklist &lb,linklist &lc)
{
   
    linklist pa=la->next;
    linklist pb=lb->next;
    linklist pre;
  lc=la;
  la->next=NULL;

    while(pa&&pb)
    {
   
        if(pa->data <= pb->data)
        {
   
            pre=pa->next;
           pa->next=la->next;
           la->next=pa;
            pa=pre;
        }
        else
        {
   
             pre=pb->next;
           pb->next=la->next;
           la->next=pb;
            pb=pre;
        }
    }
   while(pa)
   {
   
        pre=pa->next;
           pa->next=la->next;
           la->next=pa;
            pa=pre;
   }
   while(pb)
   {
   
       pre=pb->next;
           pb->next=la->next;
           la->next=pb;
            pb=pre;
   }
    free(lb);}
/*void mergelist(linklist &la,linklist &lb,linklist &lc)
{
    linklist pa=la->next;
    linklist pb=lb->next;
    linklist pc;
    pc=lc=la;
    lc->next=NULL;
    while(pa||pb)
    {
        if(!pa)
        {
            pc=pb;
            pb=pb->next;
        }
        if(!pb)
        {
            pc=pa;
            pa=pa->next;
        }
        else if(pa->data <= pb->data)
        {
            pc=pa;
            pa=pa->next;
        }
        else
        {
            pc=pb;
            pb=pb->next;
        }
        pc->next=lc->next;
        lc->next=pc;
    }
    delete lb;
}*/
int length(linklist l)
{
   
    int n=0;
    linklist p=l->next;
    while(p)
    {
   
        p=p->next;
        n++;
    }
    return n;
}
lnode *sortlist (lnode *phead)
{
   
   lnode *p;
    if(phead->next==NULL)
    {
   
        return phead;
    }
    int n,i,j;
    n=length(phead);
    for(i=1;i<n;i++)
    {
   
        p=phead->next;
        for(j=1;j<n;j++)
        {
   
            if(p->data < p->next->data)
            {
   
                elemtype t=p->data;
                p->data=p->next->data;
                p->next->data=t;
            }
            p=p->next;
        }
    }
    return phead;
}
int main()
{
   
    linklist la,lb,lc;
    createhead(la);
    createhead(lb);
    mergelist(la,lb,lc);
   linklist p= sortlist(lc);
    output(p);

    return 0;
}

題目內容:
编写算法建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。

输入输出说明:
输入：
1 2 3 4 5 6 7 8 9 0
输出：
1 3 5 7 9
2 4 6 8

//https://blog.csdn.net/wuxuanyi27/article/details/51174330
#include <stdio.h>
#include <stdlib.h>
typedef int elemtype;
typedef struct node
{
   
    elemtype data;
    struct node*next;
}Lnode;
void create(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        p->next=q;
        p=q;
        scanf("%d",&data);
    }
}
void output(Lnode* phead)
{
   
    phead=phead->next;
    while(phead!=NULL)
    {
   
        printf("%d ",phead->data);
        phead=phead->next;
    }
}
void reversee(Lnode *phead)
{
   
    Lnode *p=phead,*q;
    p=phead->next;
    phead->next=NULL;
    while(p!=NULL)
    {
   
        q=p;
        p=p->next;
        q->next=NULL;
        q->next=phead->next;
        phead->next=q;
    }
}
void deletee(Lnode *phead)
{
   
    Lnode *p,*q;
    p=phead;
    q=phead->next;
    while(q!=NULL)
    {
   
        if(q->data%2==0)
        {
   
            p->next=q->next;
            free(q);
            q=p->next;
        }
        else
        {
   
            p=q;
            q=q->next;
        }
    }
}
elemtype length(Lnode *phead)
{
   
    Lnode *p;
    p=phead->next;
    int a=0;
    while(p!=NULL)
    {
   
        p=p->next;
        a++;
    }
    return a;
}
Lnode *sortlist (Lnode *phead)
{
   
    Lnode *p;
    if(phead->next==NULL)
    {
   
        return phead;
    }
    int n,i,j;
    n=length(phead);
    for(i=1;i<n;i++)
    {
   
        p=phead->next;
        for(j=0;j<n-1;j++)
        {
   
            if(p->data > p->next->data)
            {
   
                elemtype t=p->data;
                p->data=p->next->data;
                p->next->data=t;
            }
            p=p->next;
        }
    }
    return phead;
}
void insertt(Lnode *p,Lnode *t)
{
   
    Lnode *p1=p->next,*p2=p;
    if(p->next==NULL)
    {
   
        p->next=t;
    return;
    }
    while(p1->data<t->data&&p1->next!=NULL)
    {
   
        p2=p1;
        p1=p1->next;
        if(p1->next!=NULL)
        {
   
            t->next=p2->next;
            p2->next=t;
        }
        else
        {
   
            if(p1->data > t->data)
            {
   
                t->next=p2->next;
                p2->next=t;
            }
            else
            {
   
                t->next=p1->next;
                p1->next=t;
            }
        }
    }
}
void add(Lnode *p1,Lnode *p2)
{
   
    Lnode *p,*q;
    p=p2->next;
    while(p!=NULL)
    {
   
        q=p;
        p=p->next;
        insertt(p1,q);
    }
}

void create1(Lnode *phead)
{
   
    int data;
    Lnode *p=phead,*q;
    scanf("%d",&data);
    while(data!=0)
    {
   
        q=(Lnode *)malloc(sizeof(Lnode));
        q->next=NULL;
        q->data=data;
        insertt(p,q);
        scanf("%d",&data);
    }
}
void divide(Lnode * head)//分为左右两部分，左边的元素为奇数，右边所有元素为偶数
{
   
    Lnode *L=head,*p,*q,*r,*s;
    r=L;
    p=L->next;
    int i,j=0;
    while(p!=NULL)
    {
   
        s=p;//s为最后一个节点；
        p=p->next;
        j++;
    }
    r=L;
    p=L->next;
    q=p->next;
    for( i=0; i<j-1; i++)
    {
   
        if((p->data)%2==0)
        {
   
            r->next=q;
            p->next=NULL;
            s->next=p;
            s=p;
            p=q;
            q=p->next;
        }
        else
        {
   
            r=p;
            p=q;
            q=p->next;
        }
    }
}
void depart(Lnode * head,Lnode* l)
{
   
  Lnode* q=head,*p;
    q=q->next;
    while(q->data%2==1)
    {
   
        elemtype x;
        x=q->data;
        p=(Lnode *)malloc(sizeof(Lnode));
        p->data=x;
        p->next=l->next;
        l->next=p;
        head->next=q->next;
        free(q);
        q=head->next;
    }
}

int main()
{
   
    Lnode
最低0.47元/天 解锁文章
_K_K_
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
锐格软件c语言答案,东北林业大学锐格系统练习题（持续更新）
weixin_29047919的博客
05-18 1837
文章目录一、Socket概述1、概念2、注意点3、Socket Families(地址簇)4、Socket Types二、Socket通信案例1. 单次收发模型1. 服务器端2. 客户端一、Socket概述1、概念 Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络…2021/5/18 1:43:36上班的时候，总是疑惑为啥上级老来查我干活的进度（最多的时候1个小时一...
[NEFU]锐格 数据结构 作业
qq_65022282的博客
09-27 1232
nefu 数据结构 作业
[NEFU锐格 数据结构]实验一 线性表有关的操作
鱼竿钓鱼干
09-08 2359
[NEFU锐格 数据结构]实验一 线性表有关的操作 题目 8599 #include<stdlib.h> #include<stdio.h> #include<string.h> #include<math.h> int arr[15]; int n; int main(){ scanf("%d",&n); for(int i=0;i<n;i++)scanf("%d",&arr[i]); for(int i=0;
【锐格】数据结构-线性表
Do1phln的博客
10-24 2374
欢迎加入NEFU计算机编程交流群：523539085 顺序表 4882 #include<iostream> #include<stdlib.h> using namespace std; const int defaultSize = 10; class SeqList { protected: int *data; int maxSize; //表最大可容纳项数 int last; //当前表大小 public: SeqList(int sz = defa
大二数据结构锐格实验题（栈和队列）
沉晨尘宸的博客
11-19 1406
1、随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）； 2、把单向链表中元素逆置（不允许申请新的结点空间）； 3、在单向链表中删除所有的偶数元素结点； 4、编写在非递减有序链表中插入一个元素使链表元素仍有序的函数。 5、利用算法4建立两个非递减有序单向链表，然后合并成一个非递增链表。 6、利用算法4建立两个非递减有序单向链表，然后合并成一个非递减链表。 7、一元多项式的存储并实现两个多项式相加。 1、随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）； .#include <
NEFU锐格网络平台（实验课）用于莫拉莱斯存储锐格做过的题。.zip
最新发布
03-29
从标题来看，这个平台可能集成了锐格（Rego）的练习系统，允许用户进行编程或理论问题的解答，并存储他们的解答记录。 【毕业设计】标签表明，该平台或其相关代码可能是某位学生的毕业设计项目。这样的项目通常涵盖...
锐格测试.cpp
04-05
锐格测试.cpp
数据结构(C语言)实验教程实验数据.zip
10-29
文件"shujujiegou_c"可能是这些数据结构的C语言实现源代码，或者是与数据结构相关的练习题目和解答。 在C语言中，数据结构的基本元素包括： 1. **数组**：是最基本的数据结构，是一系列相同类型元素的集合，可以...
C++上机考试系统（包括100道题）
10-09
通过这个包含100道题的上机考试系统，考生可以逐一练习并巩固以上知识点，从而提高自己的编程能力，为正式的上机考试做好充分准备。同时，这样的系统还能帮助考生在实践中发现问题，提升问题解决的能力，增强编程...
C语言网络教学平台
04-27
C语言程序设计教学网站的内容包括：课程学习（包括课程大纲、讲义、电子教案、实验指导等），课程作业（包括选择题、填空题、基本操作题、程序改错题题、程序填空题、编程题等，目前所有题型均可维护并自动批改），课程答疑（学生提问、学生和教师一起参与回答），课程考试（可以随机或指定课程作业题型组卷并能全部自动判卷）、学生空间（包括个人资料、我的问题、我的收藏、我的笔记、我的短信、我的文件等），文章精选（分类收录大量有关C语言程序设计相关的文章和典型算法案例）、课程公告、每日一帖（收录学习方法、C语言程序设计相关短文）、教师空间（教师基本信息、教师短信、教师教学笔记、教师收藏、回答并审核学生问题、学生基本信息维护、学生作业批改等）和系统功能（包括每日一帖、精选文章、网站调查、网站公告的维护与管理，教师管理、班级管理、题库维护、资料维护、考试设置、考试管理、常用参数维护、系统维护等功能）组成。
大一上实验5_2.cpp
07-06
彻底了解指针数组，数组指针，以及函数指针，以及堆中的分配规则
大一C语言答案大全.zip
06-21
http://124.160.107.91:9021/indexcs/simple.jsp?loginErr=0 电子信息类 大一学年C语言修晓杰 课后答案
东北林业大学 2010－2011学年第二学期C++考试试题
03-03
C++程序设计 来自东北林业大学师哥师姐的经典
东北林业大学锐格系统大一（指针与函数）
沉晨尘宸的博客
06-10 881
感觉自己最近都要写博客，看C语言了，因为快考试了，最近压力好大啊！！！！ 话不多说，指针与函数，开始吧！！！ [5880](https://222-27-166-246.webvpn.nefu.edu.cn/studentExercise/index?currentClassId=459#4880_exercise_716_ #include <stdio.h> #include <stdlib.h> int main() { float **a,*b,s; int n,
东北林业大学锐格系统练习题（课后题部分）
沉晨尘宸的博客
06-03 2162
问我几多愁，恰似正逢考试啥啥不会 为了C语言考试不拖后腿，决定重新写一下锐格系统的测试题 ，那那那那我这个菜鸟就从最简单的课后题章节开始写吧！ 3509题 【我自己码的代码如下图，但是but，不符合网管要求，菜鸟的我不知道为啥，跑起来是对的】 #include <stdio.h> #include <stdlib.h> //write your code here typedef struct list{ int data; struct list *next; };
锐格网络平台 锐格考试系统 网页内容复制方法(附c语言实验代码)
热门推荐
Gaoithe的博客
06-02 1万+
首先 ：自己写的代码Chrome可以复制，360浏览器不行 锐格上不能复制是因为js代码禁用了鼠标右键，而且锐格上的网页是要通过js动态加载的，所以网上的那些复制的方法大多不顶用。 为了方便大家，接下来我就介绍三种突破这种限制的方法(360极速浏览器下)： ...
锐格平台java答案_Java练习题4_last_1042林大锐格平台
weixin_39743357的博客
03-01 891
import java.util.Scanner;public class Main{public static void main(String args[]){int ri , repeat;int n;Scanner in = new Scanner(System.in);repeat = in.nextInt();for(ri = 1 ; ri <= repeat ; ri++){...
NEFU 校外访问锐格/图书馆系统
果光的博客
02-07 4116
通常从校外是无法访问学校锐格系统的，直接打开就会这样↓ 虽然打不开但是可以看到 IP 222.27.166.246 估计常用的也背下来了 可以搜索东北林业大学远程接入系统 直接记链接也可：vpn.nefu.edu.cn 然后选择数字东林统一认证进行登录。 遇到这种错误时可以在高级（点完变隐藏详情）里选择继续前往。 然后随便进去一个，去图书馆的可以直接进了。 继续即可。 打开之后替换...
锐格网络平台数据结构
10-12
锐格网络平台的数据结构主要包括以下几个方面： 1. 用户数据结构：包括用户基本信息、账号密码、权限等； 2. 文章数据结构：包括文章标题、内容、作者、发布时间等； 3. 评论数据结构：包括评论内容、评论者、评论...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值