2-21练习题

最新推荐文章于 2024-10-01 23:05:47 发布
最新推荐文章于 2024-10-01 23:05:47 发布
阅读量270 收藏
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZC12345689/article/details/136218502
版权

一、双向链表：创建双链表、从头部插入数据、从尾部插入数据、任意位置插入数据、从头部删除、从尾部删除、从任意位置删除、遍历双链表、判段链表是否为空

1、03_linklist.c

#include <stdio.h>                                                                                     
#include <stdlib.h>                                                                                    
#include "./03_linklist.h"                                                                             
doublelinklist* create_doubleLInklist(void)                                                            
{                                                                                                      
    doublelinklist* head = (doublelinklist*)malloc(sizeof(doublelinklist));                            
    if(NULL == head)                                                                                   
    {                                                                                                  
        printf("申请空间失败，创建链表失败\n");                                                        
        return NULL;                                                                                   
    }                                                                                                  
    head->next = NULL;                                                                                 
    head->prev = NULL;                                                                                 
    head->text.len = 0;                                                                                
    return head;                                                                                       
}                                                                                                      
                                                                                                       
//头插                                                                                                 
void head_Insertlinklist(doublelinklist* head,dataType num)                                            
{                                                                                                      
    doublelinklist* p = head;                                                                          
    doublelinklist* temp = (doublelinklist*)malloc(sizeof(doublelinklist));                            
    if(NULL == temp)                                                                                   
    {                                                                                                  
        printf("申请空间失败!");                                                                       
        return;                                                                                        
    }                                                                                                  
    temp->text.data = num;                                                                             
    temp->next = NULL;                                                                                 
    temp->prev = NULL;
    //链表为空和链表中有数据时头插位置不一样
    if(Empty(head) == 1)
    {
        temp->next = p->next;
        p->next = temp;
        temp->prev = p;
    }
    else
    {
        temp->next = p->next;
        p->next = temp;
        temp->prev = p;
        temp->next->prev = temp;
    }                                                                                                  
    head->text.len++;

}
//判空（空：1，不空：0）
int Empty(doublelinklist* head)
{
    if(NULL == head->next)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//尾插
void tail_InsertLinklist(doublelinklist* head,dataType num)
{
    doublelinklist* p = head;
    doublelinklist* temp = (doublelinklist*)malloc(sizeof(doublelinklist));
    if(NULL == temp)
    {
        printf("申请空间失败!");
        return;
    }
    temp->text.data = num;
    temp->next = NULL;
    temp->prev = NULL;
    if(1 == Empty(head))//空链表
    {
        temp->next = p->next;
        p->next = temp;
    //  temp->next = NULL;
        temp->prev = p;
    }
    else
    {
        //遍历出最后一个元素位置
        while(p->next!= NULL)
        {
            p=p->next;                                                                                 
        }                                                                                              
        temp->next = p->next;                                                                          
        p->next = temp;                                                                                
    //  temp->next = NULL;                                                                             
        temp->prev = p;                                                                                
    }                                                                                                  
    head->text.len++;                                                                                  
                                                                                                       
                                                                                                       
}                                                                                                      
//遍历
void show_doubleLinklist(doublelinklist* head)                                                                   
{                                                                                                                
    doublelinklist* p = head;                                                                                    
    while(NULL != p->next)                                                                                       
    {                                                                                                            
        p=p->next;                                                                                               
        printf("%d ",p->text.data);                                                                              
    }                                                                                                            
    printf("\n");
}                                                                                                                
//按位置插入                                                                                                     
void insertDouobleLinklist(doublelinklist* head,int n,dataType num)                                              
{                                                                                                                
    doublelinklist* p = head;                                                                                    
    int i;                                                                                                       
                                                                                                                 
    doublelinklist* temp = (doublelinklist*)malloc(sizeof(doublelinklist));                                      
    if(NULL == temp)                                                                                             
    {                                                                                                            
        printf("申请空间失败!");                                                                                 
        return;                                                                                                  
    }                                                                                                            
    if(n<1 && n>head->text.len+1)                                                                                
    {                                                                                                            
        printf("插入位置非法，插入失败\n");                                                                      
        return;                                                                                                  
    }                                                                                                            
    for(i=0;i<n-1;i++)                                                                                           
    {                                                                                                            
        p=p->next;                                                                                               
    }                                                                                                            
                                                                                                                 
    temp->text.data = num;                                                                                       
    temp->next = NULL;                                                                                           
    temp->prev = NULL;                                                                                           
                                                                                                                 
    if(p->next == NULL)                                                                                          
    {                                                                                                            
        temp->next = p->next;                                                                                    
        p->next = temp;                                                                                          
        temp->prev = p;                                                                                          
    }                                                                                                            
    else                                                                                                         
    {                                                                                                            
        temp->next = p->next;                                                                                    
        p->next = temp;                                                                                          
        temp->next->prev = temp;                                                                                 
        temp->prev = p;                                                                                          
    }                                                                                                            
    head->text.len++;                                                                                            
}                                                                                                                
                                                                                                                 
//头删                                                                                                           
void head_DeleteDoubleLinklist(doublelinklist* head)                                                             
{                                                                                                                
    doublelinklist* p = head;                                                                                    
    doublelinklist* q = p->next;                                                                                 
    if(NULL == p->next)                                                                                          
    {                                                                                                            
        printf("该链表为空，无法进行删除操作\n");                                                                
        return;                                                                                                  
    }                                                                                                            
    if(q->next == NULL)                                                                                          
    {                                                                                                            
        p->next = q->next;                                                                                       
        free(p);                                                                                                 
    }                                                                                                            
    else                                                                                                         
    {                                                                                                            
        p->next = q->next;                                                                                       
        q->next->prev = p;                                                                                       
        free(q);                                                                                                 
    }                                                                                                            
    printf("头删成功\n");                                                                                        
    head->text.len--;                                                                                            
}                                                                                                                
//尾删                                                                                                                  
void tail_DeleteDoubleLinklist(doublelinklist* head)                                                                    
{                                                                                                                       
    doublelinklist* p = head;                                                                                           
    if(NULL == p->next)                                                                                                 
    {                                                                                                                   
        printf("该链表为空，无法进行删除操作\n");                                                                       
        return;                                                                                                         
    }                                                                                                                   
    while(p->next != NULL)                                                                                              
    {
        p = p->next;
    }                                                                                                                   
    p->prev->next = NULL;                                                                                               
    free(p);                                                                                                            
    head->text.len--;                                                                                                   
    printf("尾删成功\n");                                                                                               
                                                                                                                        
}                                                                                                                       
//按位置删除                                                                                                            
void deleteDoubleLinklist(doublelinklist* head,int n)                                                                   
{
    doublelinklist* p = head;                                                                                           
    if(NULL == p->next)                                                                                                 
    {                                                                                                                   
        printf("该链表为空，无法进行删除操作\n");                                                                       
        return;                                                                                                         
    }                                                                                                                   
    int i;                                                                                                              
    for(i=0;i<n;i++)                                                                                                    
    {                                                                                                                   
        p = p->next;                                                                                                    
    }                                                                                                                   
    if(p->next == NULL)                                                                                                 
    {                                                                                                                   
        p->prev->next = p->next;                                                                                        
        free(p);                                                                                                        
    }                                                                                                                   
    else                                                                                                                
    {                                                                                                                   
        p->prev->next = p->next->next;                                                                                  
        p->next->prev = p->prev;                                                                                        
        free(p);                                                                                                        
    }                                                                                                                   
    head->text.len--;                                                                                                   
    printf("按位删除成功\n");                                                                                           
                                                                                                                        
}

 2、03_main.c

#include <stdio.h>                                      
#include "./03_linklist.h"                              
int main(int argc, const char *argv[])                  
{                                                       
    doublelinklist* head = create_doubleLInklist();     
    head_Insertlinklist(head,2);                        
    tail_InsertLinklist(head,3);                        
    tail_InsertLinklist(head,4);                        
    tail_InsertLinklist(head,5);                        
                                                        
    show_doubleLinklist(head);                          
    //按位置插入                                        
    insertDouobleLinklist(head,3,4);                    
    show_doubleLinklist(head);                          
    //头删                                              
    head_DeleteDoubleLinklist(head);                    
    //尾删                                              
    tail_DeleteDoubleLinklist(head);                    
    //按位置删除                                        
    deleteDoubleLinklist(head,3);                       
                                                        
    return 0;                                           
}

  3、03_linklist.h

#ifndef __LINKLIST_H__                                                      
#define __LINKLIST_H__                                                      
                                                                            
typedef int dataType;                                                       
union msg                                                                   
{                                                                           
    dataType data;                                                          
    int len;                                                                
};                                                                          
typedef struct node                                                         
{                                                                           
    union msg text;                                                         
    struct node* next;                                                      
    struct node* prev;                                                      
}doublelinklist;                                                            
                                                                            
//创建双向链表                                                              
doublelinklist* create_doubleLInklist(void);                                
//头插                                                                      
void head_Insertlinklist(doublelinklist* head,dataType num);                
//尾插                                                                      
void tail_InsertLinklist(doublelinklist* head,dataType num);                
//遍历                                                                      
void show_doubleLinklist(doublelinklist* head);                             
//判空（空：1，不空：0）                                                    
int Empty(doublelinklist* head);                                            
//按位置插入                                                                
void insertDouobleLinklist(doublelinklist* head,int n,dataType num);        
//按位置删除                                                                
void deleteDoubleLinklist(doublelinklist* head,int n);                      
//尾删                                                                      
void tail_DeleteDoubleLinklist(doublelinklist* head);                       
//头删                                                                      
void head_DeleteDoubleLinklist(doublelinklist* head);                       
                                                                            
                                                                            
                                                                            
#endif

二、单循环链表：创建单向循环链表、头插链表、尾插链表、按位置插入链表、按位置查找链表、头删、尾删、遍历链表、判断链表是否为空

1、02_linklist.c

#include <stdio.h>                                                                          
#include <stdlib.h>                                                                         
#include "./02_linklist.h"                                                                  
//创建单向循环链表                                                                          
looplinklist* create_Looplinklist(void)                                                     
{                                                                                           
    looplinklist* head = (looplinklist*) malloc(sizeof(looplinklist));                      
    if(NULL == head)                                                                        
    {                                                                                       
        printf("节点创建失败，链表创建失败\n");                                             
        return NULL;                                                                        
    }                                                                                       
    //初始化                                                                                
    head->text.len=0;                                                                       
    //循环链表初始化头结点的next指向自身                                                    
    head->next = head;                                                                      
    return head;                                                                            
}                                                                                           
//头插                                                                                      
void head_InsertLooplinklist(looplinklist* head,dataType num)                               
{                                                                                           
    looplinklist* temp = (looplinklist*) malloc(sizeof(looplinklist));                      
    if(NULL == temp)                                                                        
    {                                                                                       
        printf("创建节点失败!\n");                                                          
        return;                                                                             
    }                                                                                       
    //初始化节点                                                                            
    temp->text.data = num;                                                                  
    temp->next = NULL;                                                                      
    looplinklist* p = head;                                                                 
    temp->next = p->next;                                                                   
    p->next = temp;                                                                         
    head->text.len++;                                                                       
}                                                                                           
//尾插                                                                                      
void tail_InsertLoopLinklist(looplinklist* head,dataType num)                               
{                                                                                           
    looplinklist* temp = (looplinklist*)malloc(sizeof(looplinklist));                       
    if(NULL == temp)                                                                        
    {                                                                                       
        printf("创建节点失败!\n");                                                          
        return;                                                                             
    }                                                                                       
    //初始化节点                                                                            
    temp->text.data = num;                                                                  
    temp->next = NULL;                                                                      
                                                                                            
    looplinklist* p = head;                                                                 
    while(p->next!=head)                                                                    
    {                                                                                       
        p=p->next;                                                                          
    }                                                                                       
    p->next = temp;                                                                         
    temp->next = head;                                                                      
    head->text.len++;                                                                       
}                                                                                           
//遍历                                                                                      
void show_Looplinklist(looplinklist* head)                                                  
{                                                                                           
    looplinklist* p = head;                                                                 
    while(p->next!=head)                                                                    
    {                                                                                       
        p=p->next;                                                                          
        printf("%d ",p->text.data);                                                         
    }                                                                                       
    printf("\n");                                                                           
}                                                                                           
//判空                                                                                      
int Empty(looplinklist* head)                                                               
{                                                                                           
    looplinklist* p = head;                                                                 
    if(p->next == head)                                                                     
    {                                                                                       
        return 1;                                                                           
    }                                                                                       
    else                                                                                    
    {                                                                                       
        return 0;                                                                           
    }                                                                                       
}                                                                                           
//头删                                                                                      
void head_deletLoopLinklist(looplinklist* head)                                             
{                                                                                           
    looplinklist* p = head;                                                                 
    looplinklist* q = head->next;                                                           
    if(Empty(head) == 1)                                                                    
    {                                                                                       
        printf("此单向循环链表为空，无法进行删除操作\n");                                   
        return;                                                                             
    }                                                                                       
    p->next = q->next;                                                                      
    free(q);                                                                                
    q=NULL;                                                                                 
    head->text.len--;
    printf("头删完成\n");                                                                   
    
}                                                                                           
//尾删
void tail_deleteLoopLinklist(looplinklist* head)                                  
{                                                                                 
    looplinklist* p = head;                                                       
    if(Empty(head) == 1)                                                          
    {                                                                             
        printf("此单向循环链表为空，无法进行删除操作\n");                         
        return;                                                                   
    }                                                                             
    while(p->next->next!=head)                                                    
    {                                                                             
        p=p->next;                                                                
    }                                                                             
    looplinklist* q = p->next;                                                    
    p->next = q->next;                                                            
    free(q);                                                                      
    head->text.len--;                                                             
    printf("尾删完成\n");                                                         
    q=NULL;                                                                       
}                                                                                 
//定位插入                                                                        
void insert_LoopLinklist(looplinklist* head,dataType num,int n)                   
{                                                                                 
    looplinklist* temp = (looplinklist*)malloc(sizeof(looplinklist));             
    if(NULL == temp)                                                              
    {                                                                             
        printf("申请空间失败，创建新节点失败\n");                                 
        return;                                                                   
    }                                                                             
    //初始化新节点                                                                
    temp->text.data = num;                                                        
    temp->next = NULL;                                                            
    looplinklist* p = head;                                                       
    int i;                                                                        
    for(i=0;i<n;i++)                                                              
    {                                                                             
        p=p->next;                                                                
    }                                                                             
    if(NULL == p->next)                                                           
    {                                                                             
        p->next = temp;                                                           
        temp->next = head;                                                        
    }                                                                             
    else                                                                          
    {                                                                             
        temp->next = p->next;                                                     
        p->next = temp;                                                           
                                                                                  
    }                                                                             
    head->text.len++;                                                             
}                                                                                 
//定位查看                                                                        
void select_LoopLinklist(looplinklist* head,int n)                                
{                                                                                 
    looplinklist* p = head;                                                       
    int i;                                                                        
    for(i=0;i<n;i++)                                                              
    {                                                                             
        p = p->next;                                                              
    }                                                                             
    printf("查看的第%d为元素值为:%d\n",n,p->text.data);                           
    p=NULL;                                                                       
}                                                                                 
//                                                                                
 //                                                                                                
 //约瑟夫问题                                                                                      
 void joseph(looplinklist* head,int n,int m,int k)                                                 
 {                                                                                                 
     looplinklist* p = head;                                                                       
     looplinklist* p1 = head;                                                                      
     looplinklist* q = NULL;                                                                       
     //删除头结点                                                                                  
     if (p == head)                                                                                
     {                                                                                             
         if (head->next == head)                                                                   
         { // 只有一个节点的情况                                                                   
             free(head);                                                                           
             head = NULL;                                                                          
         }                                                                                         
         else                                                                                      
         {                                                                                         
             p1 = head;                                                                            
             while (p1->next != head)                                                              
             {                                                                                     
                 p1 = p1->next;                                                                    
             }                                                                                     
             p1->next = head->next;                                                                
             free(head);                                                                           
             head = p1->next;                                                                      
         }                                                                                         
     }                                                                                             
     //p2指向新的头节点                                                                            
     looplinklist* p2 = head;                                                                      
     //循环                                                                                        
     int i;                                                                                        
     //p2定位到数据3，开始的地方                                                                   
     for(i=1;i<k;i++)                                                                              
     {                                                                                             
         q = p2;                                                                                   
         p2 = p2->next;                                                                            
     }                                                                                             
                                                                                                   
     while(n>0)                                                                                    
     {                                                                                             
         for(i=1;i<m;i++)//6                                                                       
         {                                                                                         
             q = p2;                                                                               
             p2 = p2->next;                                                                        
         }                                                                                         
         printf("%d ",p2->text.data);                                                              
         if(p2 == q)                                                                               
         {                                                                                         
             head = NULL;                                                                          
         }                                                                                         
         else                                                                                      
         { //删除节点                                                                              
             q->next = p2->next;                                                                   
             head = p2->next;                                                                      
         }                                                                                         
         free(p2);                                                                                 
         p2 = head;                                                                                
         n--;                                                                                      
     }                                                                                             
     printf("\n");                                                                                 
 }

2、02_main.c

#include <stdio.h>                                                   
#include <stdlib.h>                                                  
#include "./02_linklist.h"                                           
int main(int argc, const char *argv[])                               
{                                                                    
                                                                     
    //创建单项循环链表                                               
    looplinklist* head = create_Looplinklist();                      
    //头插                                                           
    int i=1;                                                         
    for(i=8;i>=1;i--)                                                
    {                                                                
        head_InsertLooplinklist(head,i);                             
    }                                                                
                                                                     
    //遍历                                                           
    show_Looplinklist(head);                                         
    //尾插                                                           
//  tail_InsertLoopLinklist(head,12);                                
//  show_Looplinklist(head);                                         
    //头删                                                           
//  head_deletLoopLinklist(head);                                    
//  show_Looplinklist(head);                                         
//  joseph(head,8,4,3);                                              
    //尾删                                                           
    tail_deleteLoopLinklist(head);                                   
    //定位插入                                                       
    insert_LoopLinklist(head,12,5);                                  
    show_Looplinklist(head);                                         
    //定位查看                                                       
    select_LoopLinklist(head,5);

3、02_linklist.h

#ifndef __LINKLIST_H__                                                
#define __LINKLIST_H__                                                
                                                                      
typedef int dataType;                                                 
union msg                                                             
{                                                                     
    dataType data;                                                    
    int len;                                                          
};                                                                    
typedef struct node                                                   
{                                                                     
    union msg text;                                                   
    struct node* next;                                                
}looplinklist;                                                        
//创建单向循环链表                                                    
looplinklist* create_Looplinklist(void);                              
//头插                                                                
void head_InsertLooplinklist(looplinklist* head,dataType num);        
//遍历                                                                
void show_Looplinklist(looplinklist* head);                           
//尾插                                                                
void tail_InsertLoopLinklist(looplinklist* head,dataType num);        
//头删                                                                
void head_deletLoopLinklist(looplinklist* head);                      
//约瑟夫问题                                                          
void joseph(looplinklist* head,int n,int m,int k);                    
//尾删                                                                
void tail_deleteLoopLinklist(looplinklist* head);                     
//定位插入                                                            
void insert_LoopLinklist(looplinklist* head,dataType num,int n);      
//定位查看                                                            
void select_LoopLinklist(looplinklist* head,int n);                   
                                                                      
#endif

ZZC12345689
关注
python实战训练--基础练习题(2)
xdc1812547560的博客
07-24 5470
文章目录斐波那契数列。递归实现朴素实现列表copy九九乘法表暂停一秒输出给人看的时间 斐波那契数列。 斐波那契数列指的是bai这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368… 这个数列从第3项开始，每一项都等于前两项之和。 程序分析： 斐波那契数列（Fibonacci sequence），从1,1开始，后面每一项等于前面两项之和。图方便就
Datacom-HCIP-H12-821 练习题(2022).docx
04-12
这些练习题涵盖了多个IT网络领域的知识点，主要涉及OSPF协议、IPv6配置、IS-IS路由、ACL访问控制列表、WLAN无线局域网漫游、STP生成树协议以及BGP边界网关协议。以下是这些知识点的详细解释： 1. **OSPF协议故障...
Linux--shell练习题
banliyaoguai的博客
12-23 1726
【代码】Linux--shell练习题。
C-11练习题
YJlio的博客
12-05 4243
在每小题给出的四个备选项中选出一个正确的答案,并将所选项前的字母填写在答题纸的相应位置上。二、程序阅读题(本大题共5小题,每小题6分,共30分。2,设有定义: int a[10],*p=a+6,*q=a;一printf(“%d”,strcmp(s1,s2));x++&&y-) 的值是()6.已知字母a的ASCII值为十进制的97,下面程序的输出是()10.假定a和b为int型变量,则执行以下语句后b的值为(）15.当说明一个共用体变量时,系统分配给它的内存是()1,在C语言中,合法的长整型常数是(）
-离散数学-期末练习题解析
热门推荐
unseven的博客
12-19 2万+
一、填空 A,B,C表示三个集合，图中阴影部分的集合的表达式为_______ (B ⊕ C) - A ⊕表示对称差，A⊕B为表示（A∪B)-(A∩B)，该图表示B与C的对称差还要减去与A相交的部分 公式
PTA-队列练习题
ZYQ_37210462的博客
10-31 4772
选择题 2-1在少用一个元素空间的循环队列(m为最大队列长度)是满队列的条件（ ）。 A.rear== front B.(rear+1)%m==front C.(rear+1) == front D.front ==(front+1)%m 2-2循环队列存储在数组A[0…n-1]中，其头尾指针分别为f和r，头指针f总是指向队头元素，尾指针r总是指向队尾元素的下一个位置，假设队列不空，元素出队时头尾指针的操作为（ ）。 A.f=(f+1)%n B.f=f+1 C.r=(r+1)%n D.f=(f+1)%(n
HarmonyOS云开发基础认证---练习题一
u010689434的博客
10-13 7701
HarmonyOS云开发基础认证
HCIP-H12-221练习题
Tony_long7483的博客
12-01 4776
HCIP-H12-221练习题 习题1 由于属性AS-PATH不能在AS内起作用，所以规定BGP路由器不会宣告任何从IBGP对等体来的更新信息给其IBGP对等体。 A. 正确 B. 错误 答案: A 习题2 通过重发布命令注入BGP的路由，其Origin属性为Incomplete。 A. 正确 B. 错误 答案: A 习题3 自治系统AS（AUTONOMOUS SYSTEM）是指用户自主定义的，使用统一选路策略的一组路由器的集合。 A. 正确 B. 错误 答案: B 习题4 OSPF邻居的主从关系是通过DD
HCIP-H12-223练习题
Tony_long7483的博客
12-01 4532
习题 1 企业网络常常使用DHCP为用户分配IP地址，与静态地址分配方式相比，DHCP地址分配方式极大地减少了对网络地址进行管理的工作量？ A. 正确 B. 错误 答案: A 习题 2 下列哪项故障排除方法不是使用TCP/IP参考模型作为理论基础的？ A. 对比配置法 B. 自顶向下法 C. 自底向上法 D. 替换法 答案: A 习题 3 确定项目组成员是实施阶段的工作内容？ A. 正确 B. 错误 答案: B 方案制定阶段 习题 4 下述哪些原因可能导致局域网内的MSTP协议无法正常工作？ A. MSTP
HCIP-H12-222练习题
Tony_long7483的博客
12-01 5118
HCIP-H12-222练习题 习题 1 IP报文中用Tos字段进行Qos的标记，Tos字段中是使用前6bit来标记DSCP的。 A. 正确 B. 错误 答案: A 习题 2 传统的丢包策略采用尾部丢弃（Tail-Drop）的方法，这种丢弃方法会导致TCP全局同步现象。 A. 正确 B. 错误 答案: A 习题 3 下列选项中，属于Agile Controller的业务编排的亮点的是？ A. 基于三层GRE隧道进行编排，业务设备的组网方式、部署位置更加灵活 B. 通过拓扑可视化方式进行业务编排，配置简单，管
华为认证云服务工程师（HCIA-Cloud Service）-- 练习题2
ak4777t的博客
12-13 5955
华为认证云服务工程师（HCIA-Cloud Service）-- 练习题2 本文收集整理了一些华为认证云服务工程师有关的练习题供大家学习参考 1、华为云是云原生基金会(CNCF)的亚洲唯一创始会员，国内第一个白金会员。 对 错 正确答案：对 2、Anti-DDos服务的主要功能是入侵防御。 对 错 正确答案：错 3、GES服务能够支持 Gremlin图查询语言。 对 错 正确答案：对 4、 Devops于2009年提出，现已发展成为一种方法框架，综合运用人员、流程和工具产品，来持续快速地向最终用户交付.
超好二年级数学上册100以内加减法竖式及横式训练-算练习题.doc
10-07
这篇文档是针对二年级学生设计的一系列100以内加减法的...总的来说，这份“超好二年级数学上册100以内加减法竖式及横式训练-算练习题”是一份全面、实用的教学资源，对于培养二年级学生的数学运算技能具有很大的帮助。
(完整版)因式分解--十字相乘法练习题含答案.pdf
10-05
2. 十字相乘法因式分解练习题2： 8x^2 + 6x - 35 = ? 答案：(2x + 7)(4x - 5) 3. 十字相乘法因式分解练习题3： 18x^2 - 21x + 5 = ? 答案：(3x - 1)(6x - 5) ... 20. 十字相乘法因式分解练习题20： 7(x - 1)...
基本数值计算-第8周习题-2019-2020-21
08-03
2. 埃特金插值法：这是一种不直接计算多项式系数的插值方法，它通过递归地减小误差来逼近插值结果。给定的aitken函数实现了这一方法，用于求解特定点的插值值。你可以使用这个函数来重新解决牛顿插值法中的问题，并...
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1277
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 367
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1001
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
最新发布
qq_64039411的博客
10-01 437
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
可编程控制器技术练习题解析
这篇练习题涉及到可编程控制器（PLC）的基本知识，包括硬件组件、编程元件、特殊辅助继电器的功能以及基本编程指令的应用。以下是各题目涉及的知识点详解： 1. 三菱FX2N-32MR的基本单元输入输出点数为32个，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值