数据结构——(双)链表

文章目录

1. 定义

2. 双链表和单链表的区别

3. 代码示例

3.1 双链表节点和结构定义

3.2 初始化双链表

3.3 返回双链表的长度

3.4 在指定位置插入元素

3.5 在末尾插入元素

3.6 删除指定位置的元素并返回被删除的元素

3.7 删除末尾元素

3.8 获取指定位置的元素

3.9 修改指定位置的元素

3.10 释放双链表内存

4. 流程

5. 完整代码

1. 定义

双链表（Doubly Linked List）是一种链表数据结构，其中每个节点不仅包含一个数据域，还包含两个指针域，一个指向前驱节点，一个指向后继节点。相比单链表，双链表可以更方便地进行双向遍历，插入和删除操作也更高效。

双链表的定义和操作

  1. 节点的定义：每个节点包含数据部分和指向前一个节点和后一个节点的指针部分。
  2. 头节点和尾节点：链表的头节点是链表的起点，尾节点是链表的终点，通过头节点可以遍历整个链表。
  3. 双向链接：每个节点都有指向前一个节点和后一个节点的指针，因此可以双向遍历链表。
  4. 动态扩展：节点在内存中不必是连续的，可以动态分配和释放内存。

2. 双链表和单链表的区别

结构上的区别

  • 单链表：

    • 每个节点包含一个数据域和一个指向下一个节点的指针。
    • 只有从头节点向下遍历的方向，没有指向前一个节点的指针。
    • 头节点没有前驱节点，尾节点的指针指向 NULL。

  • 双链表：

    • 每个节点包含一个数据域、一个指向下一个节点的指针和一个指向前一个节点的指针。
    • 可以从任一节点双向遍历，即可以向前遍历到头节点，也可以向后遍历到尾节点。
    • 头节点的前驱指针指向 NULL，尾节点的后继指针指向 NULL。

单链表的优缺点

优点：

  1. 简单性：实现和维护相对简单，节点只需要存储一个指针，内存开销小。
  2. 内存占用较少：每个节点只包含一个指针，因此内存占用较双链表少。
  3. 插入和删除操作效率较高：在已知前驱节点的情况下，插入和删除节点的时间复杂度为 O(1)。

缺点：

  1. 查找效率较低：从头节点遍历到目标节点的时间复杂度为 O(n)。
  2. 只能单向遍历：不能从尾节点向前遍历到头节点，灵活性差。

双链表的优缺点

优点：

  1. 双向遍历：可以从任一节点双向遍历，即可以向前遍历到头节点，也可以向后遍历到尾节点。
  2. 删除节点更方便：在已知节点本身的情况下，删除节点时不需要知道其前驱节点，因为可以通过节点本身直接访问其前驱节点和后继节点。
  3. 灵活性高：在某些情况下，双向遍历能够更方便地实现算法，比如在某些需要回溯的场景下。

缺点：

  1. 内存占用较大：每个节点包含两个指针，内存占用较单链表多。
  2. 实现和维护相对复杂：双向链表的实现和维护比单链表更复杂，需要处理更多的指针操作。
  3. 插入和删除操作相对复杂：插入和删除操作需要同时更新前驱和后继节点的指针，操作较为繁琐。

3. 代码示例

3.1 双链表节点和结构定义

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

// 双链表节点结构定义
typedef struct DNode {
    int data;             // 节点存储的数据
    struct DNode *prev;   // 指向前一个节点的指针
    struct DNode *next;   // 指向后一个节点的指针
} DNode;

// 双链表结构定义
typedef struct {
    DNode *head;  // 双链表头节点指针
    DNode *tail;  // 双链表尾节点指针
    size_t size;  // 双链表中的节点个数
} DoublyLinkedList;
  • DNode 结构体定义了双链表的节点，包含数据域 data 和指向前一个节点的指针 prev 以及指向后一个节点的指针 next。
  • DoublyLinkedList 结构体定义了双链表，包含指向头节点的指针 head 和指向尾节点的指针 tail，以及链表中节点的个数 size。

3.2 初始化双链表

// 初始化双链表
void initDoublyLinkedList(DoublyLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->tail = NULL; // 初始化尾节点为空
    list->size = 0;    // 初始化节点个数为0
}

  • initDoublyLinkedList 函数将双链表的头节点和尾节点设置为 NULL，并将节点个数初始化为 0。

3.3 返回双链表的长度

// 返回双链表的长度
size_t getLength(const DoublyLinkedList *list) {
    return list->size; // 返回双链表的节点个数
}
  •  getLength 函数返回双链表中的节点个数。

3.4 在指定位置插入元素

// 在指定位置插入元素
void insertAt(DoublyLinkedList *list, size_t index, int element) {
    // 检查插入位置是否有效
    if (index > list->size) {
        return; // 忽略无效的插入位置
    }

    // 创建新节点
    DNode *newNode = (DNode *)malloc(sizeof(DNode));
    newNode->data = element;
    newNode->prev = NULL;
    newNode->next = NULL;

    // 如果插入位置是头节点
    if (index == 0) {
        newNode->next = list->head;
        if (list->head != NULL) {
            list->head->prev = newNode;
        }
        list->head = newNode; // 新节点成为头节点
        if (list->tail == NULL) {
            list->tail = newNode; // 如果链表为空，新节点也是尾节点
        }
    } else if (index == list->size) {
        // 如果插入位置是尾节点
        newNode->prev = list->tail;
        if (list->tail != NULL) {
            list->tail->next = newNode;
        }
        list->tail = newNode; // 新节点成为尾节点
        if (list->head == NULL) {
            list->head = newNode; // 如果链表为空，新节点也是头节点
        }
    } else {
        // 找到插入位置的前一个节点
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }

        // 插入新节点
        newNode->next = current->next;
        newNode->prev = current;
        if (current->next != NULL) {
            current->next->prev = newNode;
        }
        current->next = newNode;
    }

    list->size++; // 更新节点个数
}
  • insertAt 函数在双链表的指定位置插入一个新的元素。如果插入位置是 0，则新节点成为头节点。如果插入位置是链表的末尾，则新节点成为尾节点。否则，通过遍历找到插入位置的前一个节点，并在该位置插入新节点。更新链表的节点个数。

3.5 在末尾插入元素

// 在末尾插入元素
void insertEnd(DoublyLinkedList *list, int element) {
    insertAt(list, list->size, element); // 在链表末尾插入元素
}
  • insertEnd 函数在双链表末尾插入一个新的元素，通过调用 insertAt 函数实现。

3.6 删除指定位置的元素并返回被删除的元素

// 删除指定位置的元素并返回被删除的元素
int deleteAt(DoublyLinkedList *list, size_t index) {
    // 检查删除位置是否有效
    if (index >= list->size) {
        return -1; // 忽略无效的删除位置
    }

    int deletedElement;

    // 如果删除位置是头节点
    if (index == 0) {
        DNode *temp = list->head;
        list->head = temp->next;
        if (list->head != NULL) {
            list->head->prev = NULL;
        } else {
            list->tail = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else if (index == list->size - 1) {
        // 如果删除位置是尾节点
        DNode *temp = list->tail;
        list->tail = temp->prev;
        if (list->tail != NULL) {
            list->tail->next = NULL;
        } else {
            list->head = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else {
        // 找到删除位置的前一个节点
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }

        // 删除节点
        DNode *temp = current->next;
        current->next = temp->next;
        if (temp->next != NULL) {
            temp->next->prev = current;
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    }

    list->size--; // 更新节点个数
    return deletedElement;
}
  • deleteAt 函数删除双链表中指定位置的节点，并返回该节点的值。如果删除位置是 0，则直接删除头节点。如果删除位置是链表的末尾，则删除尾节点。否则，通过遍历找到删除位置的前一个节点，并删除该位置的节点。更新链表的节点个数。

3.7 删除末尾元素

// 删除末尾元素并返回被删除的元素
int deleteEnd(DoublyLinkedList *list) {
    return deleteAt(list, list->size - 1); // 删除链表末尾的元素
}
  • deleteEnd 函数删除双链表末尾的节点，通过调用 deleteAt 函数实现。

3.8 获取指定位置的元素

// 获取指定位置的元素
int getElementAt(const DoublyLinkedList *list, size_t index) {
    // 检查索引位置是否有效
    if (index >= list->size) {
        return -1; // 返回无效的索引
    }

    // 遍历找到指定位置的节点
    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    return currentNode->data; // 返回指定位置的元素
}
  • getElementAt 函数返回双链表中指定位置的元素。通过遍历找到指定位置的节点，并返回该节点的值。

3.9 修改指定位置的元素

// 修改指定位置的元素
void modifyAt(DoublyLinkedList *list, size_t index, int newValue) {
    // 检查修改位置是否有效
    if (index >= list->size) {
        return; // 忽略无效的修改位置
 }

    // 遍历找到指定位置的节点
    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    currentNode->data = newValue; // 修改节点的值
}
  • modifyAt 函数修改双链表中指定位置的元素值。通过遍历找到指定位置的节点，并修改该节点的值。

3.10 释放双链表内存

// 释放双链表内存
void destroyDoublyLinkedList(DoublyLinkedList *list) {
    // 遍历释放每个节点的内存
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        DNode *temp = currentNode;
        currentNode = currentNode->next;
        free(temp); // 释放每个节点的内存
    }

    list->head = NULL; // 头节点置为空
    list->tail = NULL; // 尾节点置为空
    list->size = 0;    // 节点个数置为0
}
  • destroyDoublyLinkedList 函数释放双链表使用的内存。通过遍历链表，逐个释放每个节点的内存。将头节点和尾节点指针置为空，节点个数置为 0。

4. 流程

初始化双链表：

  • 判断链表是否为空。
  • 如果为空，设置头指针和尾指针为NULL。
  • 如果不为空，创建头节点和尾节点。

插入节点：

  • 判断插入位置是在头部、尾部还是中间。
  • 如果是头部，设置新节点为头节点并更新头节点的前驱指针。
  • 如果是尾部，设置新节点为尾节点并更新尾节点的后继指针。
  • 如果是在中间，找到插入位置前一个节点，设置新节点的前驱和后继指针，并更新前一个节点和后一个节点的指针。
  • 更新链表长度。

删除节点：

  • 判断删除位置是在头部、尾部还是中间。
  • 如果是头部，找到头节点并更新头节点指针。
  • 如果是尾部，找到尾节点并更新尾节点指针。
  • 如果是在中间，找到要删除节点的前一个节点，更新前一个节点和后一个节点的指针。
  • 释放被删除节点的内存。
  • 更新链表长度。

遍历链表：

  • 从头节点开始。
  • 判断当前节点是否为NULL。
  • 如果不为NULL，访问节点数据并移动到下一个节点，重复判断。
  • 如果为NULL，遍历结束。

修改节点数据：

  • 找到目标节点。
  • 更新节点数据。

 

5. 完整代码

代码包括双链表的基本操作，包括初始化、插入、删除、获取和修改元素，以及释放链表的内存.

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

// 双链表节点结构定义
typedef struct DNode {
    int data;           // 节点存储的数据
    struct DNode *prev; // 指向前一个节点的指针
    struct DNode *next; // 指向后一个节点的指针
} DNode;

// 双链表结构定义
typedef struct {
    DNode *head; // 双链表头节点指针
    DNode *tail; // 双链表尾节点指针
    size_t size; // 双链表中的节点个数
} DoublyLinkedList;

// 初始化双链表
void initDoublyLinkedList(DoublyLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->tail = NULL; // 初始化尾节点为空
    list->size = 0;    // 初始化节点个数为0
}

// 返回双链表的长度
size_t getLength(const DoublyLinkedList *list) {
    return list->size; // 返回双链表的节点个数
}

// 在指定位置插入元素
void insertAt(DoublyLinkedList *list, size_t index, int element) {
    if (index > list->size) {
        return; // 忽略无效的插入位置
    }

    DNode *newNode = (DNode *)malloc(sizeof(DNode)); // 创建新节点
    newNode->data = element;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (index == 0) { // 插入位置是头节点
        newNode->next = list->head;
        if (list->head != NULL) {
            list->head->prev = newNode;
        }
        list->head = newNode;
        if (list->tail == NULL) {
            list->tail = newNode;
        }
    } else if (index == list->size) { // 插入位置是尾节点
        newNode->prev = list->tail;
        if (list->tail != NULL) {
            list->tail->next = newNode;
        }
        list->tail = newNode;
        if (list->head == NULL) {
            list->head = newNode;
        }
    } else {
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }
        newNode->next = current->next;
        newNode->prev = current;
        if (current->next != NULL) {
            current->next->prev = newNode;
        }
        current->next = newNode;
    }

    list->size++; // 更新节点个数
}

// 在末尾插入元素
void insertEnd(DoublyLinkedList *list, int element) {
    insertAt(list, list->size, element); // 在链表末尾插入元素
}

// 删除指定位置的元素并返回被删除的元素
int deleteAt(DoublyLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 忽略无效的删除位置
    }

    int deletedElement;

    if (index == 0) { // 删除位置是头节点
        DNode *temp = list->head;
        list->head = temp->next;
        if (list->head != NULL) {
            list->head->prev = NULL;
        } else {
            list->tail = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else if (index == list->size - 1) { // 删除位置是尾节点
        DNode *temp = list->tail;
        list->tail = temp->prev;
        if (list->tail != NULL) {
            list->tail->next = NULL;
        } else {
            list->head = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else {
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }
        DNode *temp = current->next;
        current->next = temp->next;
        if (temp->next != NULL) {
            temp->next->prev = current;
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    }

    list->size--; // 更新节点个数
    return deletedElement;
}

// 删除末尾元素并返回被删除的元素
int deleteEnd(DoublyLinkedList *list) {
    return deleteAt(list, list->size - 1); // 删除链表末尾的元素
}

// 获取指定位置的元素
int getElementAt(const DoublyLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 返回无效的索引
    }

    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    return currentNode->data; // 返回指定位置的元素
}

// 修改指定位置的元素
void modifyAt(DoublyLinkedList *list, size_t index, int newValue) {
    if (index >= list->size) {
        return; // 忽略无效的修改位置
    }

    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    currentNode->data = newValue; // 修改节点的值
}

// 释放双链表内存
void destroyDoublyLinkedList(DoublyLinkedList *list) {
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        DNode *temp = currentNode;
        currentNode = currentNode->next;
        free(temp); // 释放每个节点的内存
    }

    list->head = NULL; // 头节点置为空
    list->tail = NULL; // 尾节点置为空
    list->size = 0;    // 节点个数置为0
}

// 打印双链表中的所有元素
void printDoublyLinkedList(const DoublyLinkedList *list) {
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    }
    printf("\n");
}

// 主函数测试双链表操作
int main() {
    DoublyLinkedList myList; // 声明双链表

    initDoublyLinkedList(&myList); // 初始化双链表
    printf("初始化双链表成功!\n");

    insertEnd(&myList, 1); // 链表尾部插入元素1
    insertEnd(&myList, 2); // 链表尾部插入元素2
    insertEnd(&myList, 3); // 链表尾部插入元素3
    printf("向双链表插入了3个元素\n");
    printDoublyLinkedList(&myList); // 打印链表中的元素

    printf("双链表长度为: %zu\n", getLength(&myList)); // 获取双链表长度

    insertAt(&myList, 1, 4); // 在索引1处插入元素4
    printf("在索引1处插入元素4\n");
    printDoublyLinkedList(&myList); // 打印链表中的元素

    printf("双链表长度为: %zu\n", getLength(&myList)); // 再次获取双链表长度

    printf("索引1处的元素为: %d\n", getElementAt(&myList, 1)); // 获取索引1处的元素

    modifyAt(&myList, 0, 5); // 修改索引0处的元素
    printf("把索引0处的元素修改为5\n");
    printDoublyLinkedList(&myList); // 打印链表中的元素

    printf("删除索引1处的元素,该元素值是: %d\n", deleteAt(&myList, 1)); // 删除索引1处的元素
    printDoublyLinkedList(&myList); // 打印链表中的元素

    destroyDoublyLinkedList(&myList); // 销毁双链表
    printf("双链表销毁成功!\n");

    return 0;
}
  • 初始化双链表：initDoublyLinkedList 函数初始化双链表，将头节点和尾节点设置为 NULL，节点个数初始化为 0。
  • 返回双链表的长度：getLength 函数返回双链表中的节点个数。
  • 在指定位置插入元素：insertAt 函数在双链表的指定位置插入一个新节点，根据插入位置调整前后节点的指针。
  • 在末尾插入元素：insertEnd 函数在双链表末尾插入一个新节点，调用 insertAt 函数实现。
  • 删除指定位置的元素：deleteAt 函数删除双链表中指定位置的节点，并返回该节点的值，根据删除位置调整前后节点的指针。
  • 删除末尾元素：deleteEnd 函数删除双链表末尾的节点，调用 deleteAt 函数实现。
  • 获取指定位置的元素：getElementAt 函数返回双链表中指定位置的元素，通过遍历找到目标节点。
  • 修改指定位置的元素：modifyAt 函数修改双链表中指定位置的节点的值，通过遍历找到目标节点并更新其数据。
  • 释放双链表内存：destroyDoublyLinkedList 函数释放双链表中的所有节点内存，并将链表恢复到初始状态。
  • 打印双链表中的所有元素：printDoublyLinkedList 函数遍历双链表并打印每个节点的数据。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【IT领域新生必看】探索Java中的对象创建：深入理解`new`与`clone`的对比

【IT领域新生必看】探索Java中的对象创建：深入理解`new`与`clone`的对比

文章目录 引言什么是new关键字&#xff1f;使用new关键字的基本语法示例&#xff1a; 什么是clone方法&#xff1f;使用clone方法的基本语法示例&#xff1a; new与clone的区别内存分配与初始化调用方式适用场景性能 new关键字的优缺点优点缺点 clone方法的优缺点优点缺点 深入…
阅读更多...
机器学习---线性回归

机器学习---线性回归

1、线性回归 例如&#xff1a;对于一个房子的价格&#xff0c;其影响因素有很多&#xff0c;例如房子的面积、房子的卧室数量、房子的卫生间数量等等都会影响房子的价格。这些影响因子不妨用 x i x_{i} xi​表示&#xff0c;那么房价 y y y可以用如下公式表示&#xff1a; y …
阅读更多...
【贪心 堆 优先队列】502. IPO

【贪心 堆 优先队列】502. IPO

本文涉及知识点 贪心 堆 优先队列 LeetCode502. IPO 假设 力扣&#xff08;LeetCode&#xff09;即将开始 IPO 。为了以更高的价格将股票卖给风险投资公司&#xff0c;力扣 希望在 IPO 之前开展一些项目以增加其资本。 由于资源有限&#xff0c;它只能在 IPO 之前完成最多 k…
阅读更多...
评价ChatGPT与强人工智能的未来

评价ChatGPT与强人工智能的未来

在人工智能领域&#xff0c;ChatGPT的出现无疑是一个里程碑事件。它不仅展示了自然语言处理技术的巨大进步&#xff0c;也引发了人们对于强人工智能&#xff08;AGI&#xff09;的无限遐想。本文将从多个角度评价ChatGPT&#xff0c;并探讨强人工智能距离我们还有多远。 ChatGP…
阅读更多...
【Leetcode笔记】406.根据身高重建队列

【Leetcode笔记】406.根据身高重建队列

文章目录 1. 题目要求2.解题思路 注意3.ACM模式代码 1. 题目要求 2.解题思路 首先&#xff0c;按照每个人的身高属性&#xff08;即people[i][0]&#xff09;来排队&#xff0c;顺序是从大到小降序排列&#xff0c;如果遇到同身高的&#xff0c;按照另一个属性&#xff08;即p…
阅读更多...
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥导入介绍及算法规格】

鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥导入介绍及算法规格】

密钥导入介绍及算法规格 如果业务在HUKS外部生成密钥&#xff08;比如应用间协商生成、服务器端生成&#xff09;&#xff0c;业务可以将密钥导入到HUKS中由HUKS进行管理。密钥一旦导入到HUKS中&#xff0c;在密钥的生命周期内&#xff0c;其明文仅在安全环境中进行访问操作&a…
阅读更多...
类继承-多继承虚继承

类继承-多继承虚继承

#include<iostream> using namespace std; class A1 { public:int a 10;}; class A2 { public:int b 20; }; class B :public A1, public A2 { public:int c 30; }; int main(){B b;cout << b.a << b.b << b.c << endl;return 0; } 如果基类…
阅读更多...
十五、小型电脑没有数字键及insert，怎么解决IDEA快速插入getset构造这些方法

十五、小型电脑没有数字键及insert，怎么解决IDEA快速插入getset构造这些方法

&#x1f33b;&#x1f33b;目录 一、小型电脑没有数字键及insert&#xff0c;怎么解决IDEA快速插入getset构造这些方法 一、小型电脑没有数字键及insert&#xff0c;怎么解决IDEA快速插入getset构造这些方法 解决&#xff1a; 1.winR打开搜索 2.osk回车 屏幕就出现了这样的一…
阅读更多...
windows USB 设备驱动开发- 不同模型下的控制传输

windows USB 设备驱动开发- 不同模型下的控制传输

在不同的模型下&#xff0c;USB控制传输会有不同的特点&#xff0c;但是任何控制传输的目标都始终是默认端点。 接收者是设备的实体&#xff0c;其信息&#xff08;描述符、状态等&#xff09;是主机感兴趣的。请求可进一步分为&#xff1a;配置请求、功能请求和状态请求。 发…
阅读更多...
二刷力扣——单调栈

二刷力扣——单调栈

739. 每日温度 单调栈应该从栈底到栈顶 是递减的。 找下一个更大的 &#xff0c;用递减单调栈&#xff0c;就可以确定在栈里面的每个比当前元素i小的元素&#xff0c;下一个更大的就是这个i&#xff0c;然后弹出并记录&#xff1b;然后当前元素i入栈&#xff0c;仍然满足递减…
阅读更多...
基于.NET开源游戏框架MonoGame实现的开源项目合集

基于.NET开源游戏框架MonoGame实现的开源项目合集

前言 今天分享一些基于.NET开源游戏框架MonoGame实现的开源项目合集。 MonoGame项目介绍 MonoGame是一个简单而强大的.NET框架&#xff0c;使用C#编程语言可以创建桌面PC、视频游戏机和移动设备游戏。它已成功用于创建《怒之铁拳4》、《食肉者》、《超凡蜘蛛侠》、《星露谷物…
阅读更多...
linux之管道重定向

linux之管道重定向

管道与重定向 一、重定向 将原输出结果存储到其他位置的过程 标准输入、标准正确输出、标准错误输出 ​ 进程在运行的过程中根据需要会打开多个文件&#xff0c;每打开一个文件会有一个数字标识。这个标识叫文件描述符。 进程使用文件描述符来管理打开的文件&#xff08;FD--…
阅读更多...
【Dell R730 折腾记录】风扇调速--在 Ubuntu 系统上开机自启动并每隔30分钟执行一次风扇定速脚本

【Dell R730 折腾记录】风扇调速--在 Ubuntu 系统上开机自启动并每隔30分钟执行一次风扇定速脚本

前段时间升级了一下机柜里的服务器&#xff0c;替换掉了一台旧的 Dell 服务器&#xff0c;换上了这台 R730。但是无奈于噪音的袭扰&#xff0c;搁置了一段时间。我在这台机器上目前安装了一块 Intel Xeon E5-2630v3 芯片以及一张改过散热的 NVIDIA Tesla P4 计算卡。结果就是散…
阅读更多...
电脑硬盘分区的基本步骤（2个实用的硬盘分区方法）

电脑硬盘分区的基本步骤（2个实用的硬盘分区方法）

在现代计算机中&#xff0c;硬盘分区是非常重要的一步。无论是新硬盘的初始化&#xff0c;还是重新组织现有硬盘&#xff0c;分区都是必不可少的操作。本文将详细介绍电脑硬盘分区的基本步骤&#xff0c;帮助您更好地管理和利用硬盘空间。 文章开始&#xff0c;我们先简单说一…
阅读更多...
【C++】类和对象3.0

【C++】类和对象3.0

浅浅介绍最近所学&#xff0c;希望有兴趣的读者老爷垂阅&#xff01; 目录 1.再谈构造函数 1.1.构造函数体赋值 1.2.初始化列表 1.3.构造函数的小知识 2. explicit关键字 3.static成员 3.1.static成员概念 3.2.static成员特性 4.友元 4.1.友元函数 4.2.友元类 5…
阅读更多...
七、Linux二进制安装Redis集群

七、Linux二进制安装Redis集群

目录 七、Linux二进制安装Redis集群1 安装Redis所需依赖2 单机安装Redis&#xff08;7.2.4&#xff09;2.1 下载Redis2.2 安装Redis 3 分布式部署模式&#xff08;Redis Cluster&#xff09;3.1 分布式部署模式的配置文件3.2创建集群 4 主从复制模式&#xff08;Redis Sentinel…
阅读更多...
jenkins搭建部署前端工程 ，从0到1

jenkins搭建部署前端工程 ，从0到1

一.java环境配置 1 安装tomcatjdk17 这个也行 3 安装maven3.3.9 安装教程参考 4 安装Jenkins 下载地址 参考教程 二、相关配置 1 访问http://localhost:8080/jenkins&#xff0c;进入Jenkins初始化页面&#xff0c;第一次启动时间可能有点长&#xff0c;耐心等待。进入成功后会…
阅读更多...
AndroidKille不能用?更新apktool插件-cnblog

AndroidKille不能用?更新apktool插件-cnblog

AndroidKiller不更新插件容易报错 找到apktool管理器 填入apktool位置&#xff0c;并输入apktool名字 选择默认的apktool版本 x掉&#xff0c;退出重启 可以看到反编译完成了
阅读更多...
《Windows API每日一练》8.3 scrollbar控件

《Windows API每日一练》8.3 scrollbar控件

在第三章SYSMETS2.C实例中&#xff0c;我们是通过CreateWindow函数创建窗口的参数窗口样式中添加垂直或水平滚动条。本节我们将讲述作为子窗口控件的滚动条。 本节必须掌握的知识点&#xff1a; 滚动条类 滚动条控件和着色 8.3.1 滚动条类 ■窗口滚动条与滚动条控件的异同 …
阅读更多...
带你了解“Java新特性——模块化”

带你了解“Java新特性——模块化”

Java平台从Java 8向Java 9及更高版本的进化&#xff0c;其中引入了一个重要的新特性——模块系统&#xff08;Project Jigsaw&#xff09;。模块系统的目的是解决大型应用的依赖管理问题&#xff0c;提升性能&#xff0c;简化JRE&#xff0c;增强兼容性和安全性&#xff0c;并提…
阅读更多...
最新文章

Copyright @ 2022~2023