顺序表、单链表和双链表

news2024/11/27 8:48:34

2.算法设计题

1.合并递增链表

1.算法分析：

两个链表合并，由于限定不能用额外的存储空间，所以链表比较合适。

算法步骤：

第一步：取出b表中的第一个结点；

第二步：和a表中的结点依次比较，找到第一个大于b表的结点的位置，并记下位置；

如果直到表尾都没有遇到大于b结点的值， 记下表尾位置。

第三步: 在第二步中的位置前面插入该b表结点，或者插入表尾后面。

第四步：返回到第一步，循环执行，直到b表的结点取完为止。

代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;
typedef struct
{
    elemtype *elem;
    int length;
}sqlsit;

// status init(sqlsit *L);

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(linklist list);
void create(linklist list, elemtype data[]);
void print(linklist list);
void destroy(linklist list);
linklist merge(linklist alist, linklist blist);

void main() {

    // sqlsit a, b;
    // init(&a);
    // init(&b);
    lnode a_list,b_list;
    init(&a_list);
    init(&b_list);
    int a[10] = {1,3,5,7,9,11,13,15,17,19};
    int b[10] = {2,4,6,8,10,12,14,16,18,20};

    create(&a_list, a);
    create(&b_list, b);
    print(&a_list);
    print(&b_list);

    printf("\n");
    merge(&a_list, &b_list);
    print(&a_list);

    //destroy(&a_list);
    //destroy(&b_list);    
}

// status init(sqlsit *L) {

//     L->length = MAXSIZE;

//     L = (elemtype *) malloc(MAXSIZE*sizeof(elemtype));

//     if(!L->elem) exit(ERROR);
//     return OK;

// }

status init(linklist list) {
    list = (linklist) malloc (sizeof(lnode));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(linklist list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        linklist p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(linklist list) {
    linklist tail = list->next;

    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(linklist list) {
    linklist tail = list->next;
    for(int i = 0; i <= 10; i++) {
        list->next = NULL;
        free(list);
        list = tail;
        tail = tail->next;
    }
}

linklist merge(linklist alist, linklist blist) {
    lnode *a_head = alist;
    lnode *a_tail = alist->next;
    lnode *b_head = blist;
    lnode *b_tail = blist->next;

        while(b_tail) {
            b_head->next = b_tail->next;
            b_tail->next = NULL;
            while(a_tail) {
            if(a_tail->data > b_tail->data) {
                a_head->next = b_tail;//insert a node
                b_tail->next = a_tail;
                a_head = b_tail;//update a head node
                b_tail = b_head->next;
                break;
            } else if(!a_tail->next) {
                a_tail->next = b_tail;
                a_tail = b_tail;
                a_head = a_head->next;
                b_tail = b_head->next;
                break;
            }
            a_tail = a_tail->next;
            a_head = a_head->next;
        }
    }
    return alist;
}

 输出结果：

2. 合并非递减链表

 

 代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;
typedef struct
{
    elemtype *elem;
    int length;
}sqlsit;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(linklist list);
void create(linklist list, elemtype data[]);
void print(linklist list);
void destroy(linklist list);
void merge(linklist alist, linklist blist, linklist clist);

void main() {

    lnode a_list,b_list;
    init(&a_list);
    init(&b_list);
    int a[10] = {1,3,5,5,9,11,13,15,15,19};
    int b[10] = {2,4,6,8,10,10,14,16,16,20};

    create(&a_list, a);
    create(&b_list, b);
    print(&a_list);
    print(&b_list);
    printf("\n");

    lnode c_list;
    init(&c_list);
    merge(&a_list, &b_list, &c_list);
    print(&c_list);
    //destroy(&a_list);
    //destroy(&b_list);    
}

status init(linklist list) {
    list = (linklist) malloc (sizeof(lnode));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(linklist list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        linklist p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(linklist list) {
    linklist tail = list->next;

    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(linklist list) {
    linklist tail = list->next;
    for(int i = 0; i <= 10; i++) {
        list->next = NULL;
        free(list);
        list = tail;
        tail = tail->next;
    }
}

void merge(linklist alist, linklist blist, linklist clist) {
    lnode *a_node = alist->next;
    lnode *b_node = blist->next;

        while(a_node && b_node) {
            if(a_node->data > b_node->data) {
                blist->next = b_node->next;
                b_node->next = NULL;
                clist->next = b_node;
                clist = b_node;
                b_node = blist->next;
            } else {
                alist->next = a_node->next;
                a_node->next = NULL;
                clist->next = a_node;
                clist = a_node;
                a_node = alist->next;
            }
        }
    clist->next = a_node ? a_node : b_node;
    free(a_node);
    free(b_node);
}

输出结果：

3．求A表和B表的交集

代码：

 

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(lnode *list);
void create(lnode *list, elemtype data[]);
void print(lnode *list);
void destroy(lnode *list);
void common(lnode *alist, lnode *blist, lnode *clist);

void main() {
    lnode a_list,b_list;
    init(&a_list);
    init(&b_list);
    int a[10] = {1,3,5,7,9,10,13,15,17,19};
    int b[10] = {2,4,6,8,10,12,15,16,18,20};

    create(&a_list, a);
    create(&b_list, b);
    print(&a_list);
    print(&b_list);
    lnode c_list;
    init(&c_list);
    common(&a_list, &b_list, &c_list);
    printf("\nThe common elem between A and B is:");
    print(&c_list);

    destroy(&a_list);
    destroy(&b_list);
    destroy(&c_list);

}

status init(lnode *list) {
    list = (lnode *) malloc (sizeof(lnode *));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(lnode * list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        lnode * p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(lnode * list) {
    lnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(lnode *list) {
    while(list) {
        lnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

void common(lnode *alist, lnode *blist, lnode *clist) {

    lnode *a_head = alist;
    lnode *a_tail = alist->next;
    lnode *b_tail = blist->next;
    lnode *c_tail = clist;

    while(b_tail) {
        
        while(a_tail) {
            if(a_tail->data == b_tail->data) {
                a_head->next = a_tail->next;//delete a node
                a_tail->next = NULL;

                c_tail->next = a_tail;
                c_tail = a_tail;
                break;
            }
            a_head = a_head->next;
            a_tail = a_tail->next;
        }
        b_tail = b_tail->next;
        a_head = alist;
        a_tail = alist->next;
    }
}

输出结果：

 

4. 求集合A和集合B的差集

算法分析：

依次判断A的元素不在B中，就输出这些元素到C集合中。

代码：

 

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(lnode *list);
void create(lnode *list, elemtype data[]);
void print(lnode *list);
void destroy(lnode *list);
void minus(lnode *alist, lnode *blist, lnode *clist);

void main() {
    lnode a_list,b_list;
    init(&a_list);
    init(&b_list);
    int a[10] = {1,3,5,7,9,10,13,15,17,19};
    int b[10] = {2,4,6,8,10,12,15,16,18,20};

    create(&a_list, a);
    create(&b_list, b);
    print(&a_list);
    print(&b_list);
    lnode c_list;
    init(&c_list);
    minus(&a_list, &b_list, &c_list);
    printf("\nThe common elem between A and B is:");
    print(&c_list);

    destroy(&a_list);
    destroy(&b_list);
    destroy(&c_list);

}

status init(lnode *list) {
    list = (lnode *) malloc (sizeof(lnode *));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(lnode * list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        lnode * p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(lnode * list) {
    lnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(lnode *list) {
    while(list) {
        lnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

void minus(lnode *alist, lnode *blist, lnode *clist) {

    lnode *a_head = alist;
    lnode *a_tail = alist->next;
    lnode *b_tail = blist->next;
    lnode *c_tail = clist;

    while(a_tail) {
        
        while(b_tail) {
            if(a_tail->data == b_tail->data) {
                break;
            }
            b_tail = b_tail->next;
        }
        if(!b_tail) {
            a_head->next = a_tail->next;
            a_tail->next = NULL;

            c_tail->next = a_tail;
            c_tail = a_tail;
            a_tail = a_head->next;

        } else {
            a_head = a_head->next;
            a_tail = a_head->next;
        }
        b_tail = blist->next;
        
    }
}

 输出结果：

 

5.拆解表A成复数表B和正数表C.

代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(lnode *list);
void create(lnode *list, elemtype data[]);
void print(lnode *list);
void destroy(lnode *list);
void split(lnode *alist, lnode *blist, lnode *clist);

void main() {
    lnode a_list;
    init(&a_list);
    
    int a[10] = {1,3,5,7,9,10,-1,-3,-5,-10};

    create(&a_list, a);

    print(&a_list);

    lnode b_list,c_list;
    init(&b_list);
    
    init(&c_list);
    split(&a_list, &b_list, &c_list);
    printf("\nThe < 0 elem B from A is:");
    print(&b_list);
    printf("\nThe > 0 elem C from A is:");
    print(&c_list);

    destroy(&a_list);
    destroy(&b_list);
    destroy(&c_list);

}

status init(lnode *list) {
    list = (lnode *) malloc (sizeof(lnode*));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(lnode * list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        lnode * p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(lnode * list) {
    lnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(lnode *list) {
    while(list) {
        lnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

void split(lnode *alist, lnode *blist, lnode *clist) {

    lnode *a_head = alist;
    lnode *a_tail = alist->next;
    lnode *b_tail = blist;
    lnode *c_tail = clist;

    while(a_tail) {
        if(a_tail->data < 0) {
            a_head->next = a_tail->next;
            a_tail->next = NULL;
            b_tail->next = a_tail;
            b_tail = b_tail->next;
            a_tail = a_head->next;
        } else if(a_tail->data > 0) {
            a_head->next = a_tail->next;
            a_tail->next = NULL;
            c_tail->next = a_tail;
            c_tail = c_tail->next;
            a_tail = a_head->next;
        } else {
            a_head = a_head->next;
            a_tail = a_tail->next;
        }
    }
}

输出结果：

 

 

6.求最大值。

代码：

#include "stdio.h"

#define MAXSIZE 10
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;
typedef struct
{
    elemtype *elem;
    int length;
}sqlsit;

status init(sqlsit *list);
void create(sqlsit *list, elemtype data[]);
void print(sqlsit list);
void destroy(sqlsit *list);
elemtype max(sqlsit list);

void main() {

    sqlsit list;
    init(&list);

    int a[10] = {1,3,5,7,9,11,13,15,17,19};

    create(&list, a);
    print(list);

    elemtype i = max(list);
    printf("\nThe %d node of list is max:%d", i, list.elem[i-1]);
    destroy(&list);  
}

status init(sqlsit *L) {

    L->length = MAXSIZE;

    L->elem = (elemtype *) malloc(MAXSIZE*sizeof(elemtype));

    if(!L->elem) exit(ERROR);
    return OK;
}

void create(sqlsit *list, elemtype data[10]) {

    for(int i = 0; i < 10; i++) {
        list->elem[i] = data[i];
    }
}
void print(sqlsit list) {

    for(int i = 0; i < list.length; i++) {
        printf("%d,", list.elem[i]);
    }
}

void destroy(sqlsit *list) {
    if(list)free(list->elem);
}
elemtype max(sqlsit list) {
    elemtype max = 0;
    for(int i = 0; i < list.length; i++) {
        if(max < list.elem[i]) max = i+1;
    }
    return max;
}

 输出结果：

7．将链表链接方向逆转。

算法分析：

第一步：定义一个操作指针指a向头节点的下一个结点， 再定义一个标记指针b，指向操作指针的下一个元素。

第二步：修改操作指针的转向，同时将标记位b赋给a, 标记指针后移一位。

第三步：重复第一，第二步，直到b移到最后一个指针结束。

代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(lnode *list);
void create(lnode *list, elemtype data[]);
void print(lnode *list);
void destroy(lnode *list);

lnode *reverse(lnode *list);

void main() {
    lnode a_list;
    init(&a_list);
    int a[10] = {1,3,5,7,9,10,-1,-3,-5,-10};
    create(&a_list, a);
    //print(&a_list);

    lnode *list = reverse(&a_list);
    print(list);
    destroy(&a_list);

}

status init(lnode *list) {
    list = (lnode *) malloc (sizeof(lnode*));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(lnode * list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        lnode * p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(lnode * list) {
    lnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(lnode *list) {
    while(list) {
        lnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

lnode *reverse(lnode *list) {
    lnode *a = list->next;
    lnode *b = a->next;
    list->next = NULL;
    lnode *head = a;

    while(a->next) {
        a->next = list;
        list = a;
        a = b;
        b = b->next;
    }
    a->next = list;
    list = head->next;
    list->next = a;
    head->next = NULL;
    return list;
}

 输出结果：

8. 删除链表中的部分结点

算法分析：

第一步：找到第一个大于mink的位置，然后记下该位置a；

第二步：找到第一个大于maxk的位置，然后记下该位置b。

第三步:  删除a到b之间的结点。

代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct lnode *next;
}lnode, *linklist;

status init(lnode *list);
void create(lnode *list, elemtype data[]);
void print(lnode *list);
void destroy(lnode *list);

void delete(lnode *list, int mink, int maxk);

void main() {
    lnode a_list;
    init(&a_list);
    int a[10] = {1,3,5,7,9,11,13,15,17,19};
    create(&a_list, a);
    print(&a_list);

    delete(&a_list, 6, 20);
    printf("\n");
    print(&a_list);
    destroy(&a_list);

}

status init(lnode *list) {
    list = (lnode *) malloc (sizeof(lnode*));
    list->next = NULL;
    list->data = 10;
    return OK;
}

void create(lnode * list, elemtype data[10]) {

    lnode *tail = list;
    for(int i = 0; i < 10; i++) {
        lnode * p = (lnode *) malloc(sizeof(elemtype));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        tail = p;
    }
}

void print(lnode * list) {
    lnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(lnode *list) {
    while(list) {
        lnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

void delete(lnode *list, int mink, int maxk) {
    lnode *min = list;
    lnode *max = list->next;
    lnode *node = list->next;

    while(node->next) {
        min = node->next;
        if(min->data > mink) {
            min = node;
            break;
        }
        node = node->next;
    }
    if(!node->next)return;

    while(node->next) {
        max = node->next;
        if(maxk < max->data) {
            max = node;
            break;
        }
        node = node->next;
    }
    node = min->next;
    min->next = max->next;
    max->next = NULL;
    //destroy(&node);

}

 输出结果：

9. 双链表的交换结点

算法分析：

第一步：先删除p结点

第二步：在p结点的前驱结点前插入该节点。

代码：

#include "stdio.h"

#define MAXSIZE 100
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;

typedef struct
{
    elemtype data;
    struct dlnode *next;
    struct dlnode *prior;
}dlnode, *dlinklist;

status init(dlnode *list);
void create(dlnode *list, elemtype data[]);
void print(dlnode *list);
void destroy(dlnode *list);

void change(dlnode *list, int p);

void main() {
    dlnode a_list;
    init(&a_list);
    int a[10] = {1,3,5,7,9,11,13,15,17,19};
    create(&a_list, a);
    print(&a_list);

    change(&a_list, 7);
    printf("\n");
    print(&a_list);
    //destroy(&a_list);

}

status init(dlnode *list) {
    list = (dlnode *) malloc (sizeof(dlnode*));
    list->next = NULL;
    list->prior = NULL;
    return OK;
}

void create(dlnode * list, elemtype data[10]) {

    dlnode *tail = list;
    for(int i = 0; i < 10; i++) {
        dlnode *p = (dlnode *) malloc(sizeof(dlnode));
        p->data = data[i];
        tail->next = p;
        p->next = NULL;
        p->prior = tail;
        tail = p;
    }
}

void print(dlnode * list) {
    dlnode *tail = list->next;
    while(tail) {
        printf("%d,", tail->data);
        tail = tail->next;
    }
}

void destroy(dlnode *list) {
    while(list) {
        dlnode *temp = list;
        list = list->next;
        temp = NULL;
        if(temp)free(temp);
    }
}

void change(dlnode *list, int p) {
    dlnode *pri = list;
    while(pri) {
        if(pri->data == p) break;
        pri = pri->next;
    }
    if(!pri) return;
    dlnode *tail = pri->next;
    dlnode *head = pri->prior;
    head->next = tail;
    tail->prior = head;

    head = head->prior;
    tail = tail->prior;
    head->next = pri;
    pri->prior = head;
    pri->next = tail;
    tail->prior = pri;

}

 输出结果：

10.输出指定重复元素

算法分析：

第一步：遍历顺序表找到等于Item的结点i同时用j统计删除结点的个数，同时把最大数赋给删除结点，

第二步：如果A[i]不是输出结点A[i-j]=A[i].

第三步：重复以上步骤，直到遍历完整个顺序表。

代码：

#include "stdio.h"

#define MAXSIZE 10
#define OK 1
#define ERROR 0

typedef int elemtype;
typedef int status;
typedef struct
{
    elemtype *elem;
    int length;
}sqlsit;

status init(sqlsit *list);
void create(sqlsit *list, elemtype data[]);
void print(sqlsit list);
void destroy(sqlsit *list);
void delete(sqlsit *list, elemtype item);

void main() {

    sqlsit list;
    init(&list);

    int a[10] = {1,3,5,7,9,11,13,15,17,19};

    create(&list, a);
    print(list);

    delete(&list, 3);
    print(list);
    destroy(&list);  
}

status init(sqlsit *L) {

    L->length = MAXSIZE;

    L->elem = (elemtype *) malloc(MAXSIZE*sizeof(elemtype));

    if(!L->elem) exit(ERROR);
    return OK;

}

void create(sqlsit *list, elemtype data[10]) {

    for(int i = 0; i < 10; i++) {
        list->elem[i] = data[i];
    }
}

void print(sqlsit list) {

    for(int i = 0; i < list.length; i++) {
        printf("%d,", list.elem[i]);
    }
}

void destroy(sqlsit *list) {
    if(list)free(list->elem);
}

void delete(sqlsit *list, elemtype item) {
    for(int i = 0; i < list->length; i++) {
        if(item == list->elem[i]) {
            list->elem[i] = 0xffffffff;
        }
    }
    int j = 0;
    for(int i = 0; i < list->length; i++) {
        if(list->elem[i] == 0xffffffff) {
            j++;
        } else {
            list->elem[i-j] = list->elem[i];
        }
    }
    elemtype *del = &list->elem[list->length-j];
    list->length = list->length - j;
    //free(del);
}

 输出结果：

 1.选择题

  1. 100 + (5-1) * 2 = 108 选B
  2. A
  3. (126+1)/2 = 65 选B
  4. A
  5. D

 

  • 11.B
  • 12.D
  • 13.A
  • 14.A
  • 15.C

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1668892.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

全国院校及梯度排序深度解析课（免费下载-帮助更多高考生做出人生重要的选择。）

全国院校及梯度排序深度解析课（免费下载-帮助更多高考生做出人生重要的选择。）

"全国院校及梯度排序深度解析课"旨在深入探讨全国院校的排名及梯度排序原理。通过系统解析各院校的学术声誉、师资力量、科研水平等因素&#xff0c;帮助学员全面了解院校排名的背后逻辑&#xff0c;为选择合适院校提供理论支持。 课程大小&#xff1a;7G 课程下载…
阅读更多...
Electron、QT、WPF三强争霸，该支持谁呢？

Electron、QT、WPF三强争霸，该支持谁呢？

Electron、QT、WPF都是跨平台的桌面应用开发框架&#xff0c;都是非常流行的&#xff0c;作为开发者该选用哪个呢&#xff1f;本文从多个角度分析一下。 一、定义 Electron、Qt 和 WPF 都是用于创建桌面应用程序的框架或工具&#xff0c;它们各自有着不同的特点和优势。 Elec…
阅读更多...
【3dmax笔记】036：FDD修改器

【3dmax笔记】036：FDD修改器

一、FDD修改器简介 FDD修改器是对模型进行变形处理的命令，FDD后面的数字越大，编辑节点越多，编辑越精细，但是FDD控制点多的同时，模型上的节点也要多才可以。 FFD修改器是一种非常灵活的修改器，可以让我们对模型进行自由的变形操作。通过在FFD修改器中设置变形点，我们可…
阅读更多...
力扣HOT100 - 55. 跳跃游戏

力扣HOT100 - 55. 跳跃游戏

解题思路&#xff1a; class Solution {public boolean canJump(int[] nums) {int n nums.length;int maxReach 0;// 正常来说每次至少跳一格&#xff0c;所以最多循环n次for (int i 0; i < n; i) {if (i > maxReach) return false;// 这种情况代表遇到了0&#xff0…
阅读更多...
树莓派python开发

树莓派python开发

树莓派自带thonny 点亮LED灯 import RPi.GPIO as GPIO import time# 设置GPIO模式为BCM GPIO.setmode(GPIO.BCM)# 设置LED引脚 led_pin 18# 设置LED引脚为输出 GPIO.setup(led_pin, GPIO.OUT)# 点亮LED GPIO.output(led_pin, GPIO.HIGH)# 延时2秒 time.sleep(2)# 关闭LED GPI…
阅读更多...
机器学习周报第三十八周 iTransformer

机器学习周报第三十八周 iTransformer

文章目录 week38 iTransformer摘要Abstract一、文献阅读1. 题目2. abstract3. 网络架构**转置Embedding&#xff1a;****LayerNorm&#xff08;层归一化&#xff09;****Feed-forward network&#xff08;前馈网络&#xff09;****Multivariate-Attention&#xff08;多变量注意…
阅读更多...
使用 PXE+Kickstart 批量网络自动装机

使用 PXE+Kickstart 批量网络自动装机

前言&#xff1a; 正常安装系统的话使用u盘一个一个安装会非常慢&#xff0c;所以批量安装的技术就出来了。 一、 概念 PXE &#xff08;Preboot eXecute Environment&#xff0c;预启动执行环境&#xff09;是由 Intel 公司开发的技术&#xff0c;可以让计算机通过网络来启动…
阅读更多...
无人机+远程控制：卫星通信技术详解

无人机+远程控制：卫星通信技术详解

无人机与远程控制技术的结合&#xff0c;为现代科技应用带来了广阔的前景。其中&#xff0c;卫星通信技术作为无人机远程控制的关键技术之一&#xff0c;发挥着至关重要的作用。以下是无人机远程控制中卫星通信技术的详细解析&#xff1a; 一、卫星通信技术的概述 卫星通信技术…
阅读更多...
《完美黑暗》重启版6月发布，分析指出开发“没有问题” 状况没那么

《完美黑暗》重启版6月发布，分析指出开发“没有问题” 状况没那么

易采游戏网5月12日消息&#xff0c;在21世纪初的游戏界&#xff0c;一款名为《完美黑暗》的FPS游戏在N64平台上崭露头角&#xff0c;以其独特的剧情设定和丰富的武器系统赢得了众多玩家的喜爱。然而&#xff0c;这款作品在推出时也并非一帆风顺&#xff0c;受到了不少玩家的吐槽…
阅读更多...
C++高精度算法-加法

C++高精度算法-加法

引子 在C++的运算中，难免会出现很大很大的数，下面是各个关键字的表示范围 但是如果要表示的数超过了long long可以表示的最大值（ 2 64 2^{64} 264-1） 怎么办呢？ 如果强制表示，就会溢出，这里的溢出大家可以自行百度，反正就是会出一些-5665434之类的数 现在，就要切入正…
阅读更多...
后端开发之用Mybatis简化JDBC的开发快速入门2024及数据库连接池技术和lombok工具详解

后端开发之用Mybatis简化JDBC的开发快速入门2024及数据库连接池技术和lombok工具详解

JDBC 简化JDBC的开发 JDBC仅仅是一套接口 是一套规范 Mybatis是持久层框架 用于简化JDBC的开发 使用Java语言操作关系型数据库的一套API 原始的JDBC程序 package com.bigdate.mybatis;import com.bigdate.mybatis.mapper.UserMapper; import com.bigdate.mybatis.pojo.Use…
阅读更多...
易图讯三维电子沙盘-大数据处理服务

易图讯三维电子沙盘-大数据处理服务

易图讯科技10名高级大数据工程师&#xff0c;高效、快速进行POI、DEM、高清卫星影像、地形地貌、路网、矢量地图等海量大数据处理服务。 免费专业提供POI、AOI、DEM、高清卫星影像、地形地貌、路网、矢量地图等海量大数据处理服务。 1年更新2次POI、高清卫星影像。
阅读更多...
[通用人工智能] 论文分享：ElasticViT：基于冲突感知超网的快速视觉Transformer

[通用人工智能] 论文分享：ElasticViT：基于冲突感知超网的快速视觉Transformer

引言: 近年来&#xff0c;视觉Transformer&#xff08;Vision Transformer&#xff0c;简称ViT&#xff09;在计算机视觉任务中的应用日益广泛&#xff0c;从图像分类到对象识别等&#xff0c;均显示出优越的性能。然而&#xff0c;ViT模型也面临一些挑战&#xff0c;特别是在模…
阅读更多...
2024最新最全【网络安全】逆向工程教学

2024最新最全【网络安全】逆向工程教学

逆向工程 以设计方法学为指导&#xff0c;以现代设计理论、方法、技术为基础&#xff0c;运用各种专业人员的工程设计经验、知识和创新思维&#xff0c;对已有产品进行解剖、深化和再创造。 逆向工程不仅仅在计算机行业、各行各业都存在逆向工程。 计算机行业逆向工程 计算…
阅读更多...
pytorch单机多卡训练_数据并行DataParallel

pytorch单机多卡训练_数据并行DataParallel

1.单机多卡概述 单卡多级的模型训练&#xff0c;即并行训练&#xff0c;可分为数据并行和模型并行两种. 数据并行是指&#xff0c;多张 GPUs 使用相同的模型副本&#xff0c;但采用不同 batch 的数据进行训练. 模型并行是指&#xff0c;多张 GPUs 使用同一 batch 的数据&…
阅读更多...
C#泛型委托

C#泛型委托

在C#中&#xff0c;delegate 关键字用于声明委托&#xff08;delegates&#xff09;&#xff0c;委托是一种类型安全的函数指针&#xff0c;允许你传递方法作为参数或从方法返回方法。有时我们需要将一个函数作为另一个函数的参数&#xff0c;这时就要用到委托&#xff08;Dele…
阅读更多...
SQL Server共享功能目录显示灰色无法自行选择

SQL Server共享功能目录显示灰色无法自行选择

SQL Server共享功能目录显示灰色无法自行调整 一、 将之前安装SQL Server卸载干净 二、 清空注册表 1. 打开注册表&#xff0c;winR&#xff0c;输入regedit 2. 注册表-》编辑-》查找&#xff0c;输入C:\Program Files\Microsoft SQL Server\ 3. 注册表-》编辑-》查找&#x…
阅读更多...
EfficientNet网络结构详细解读+SE注意力机制+pytorch框架复现

EfficientNet网络结构详细解读+SE注意力机制+pytorch框架复现

文章目录 &#x1f680;&#x1f680;&#x1f680;前言一、1️⃣ 网络详细结构1.1 &#x1f393; MBConv结构1.2 ✨SE注意力机制模块1.3 ⭐️Depthwise Separable Convolution深度可分离卷积1.3.1 普通卷积操作(Convolution)1.3.2 逐深度卷积&#xff08;Depthwise Convoluti…
阅读更多...
一对一WebRTC视频通话系列（六）——部署到公网

一对一WebRTC视频通话系列（六）——部署到公网

本系列博客主要记录一对一WebRTC视频通话实现过程中的一些重点&#xff0c;代码全部进行了注释&#xff0c;便于理解WebRTC整体实现。 本专栏知识点是通过<零声教育>的音视频流媒体高级开发课程进行系统学习&#xff0c;梳理总结后写下文章&#xff0c;对音视频相关内容感…
阅读更多...
什么是JVM中的程序计数器

什么是JVM中的程序计数器

在计算机的体系结构中&#xff1a; 程序计数器&#xff08;Program Counter&#xff09;&#xff0c;通常缩写为 PC&#xff0c;是计算机体系结构中的一个寄存器&#xff0c;用于存储下一条指令的地址。程序计数器是控制单元的一部分&#xff0c;它的作用是确保程序能够按正确…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023