任振铭
任振铭

16C++ 数据结构

线性表顺序存储

sqlist.h

#pragma once
#include 

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

sqlist.c

#include "seqlist.h"

typedef struct _tag_SeqList {
    int length;
    int capacity;
    unsigned int* node;
}TSeqList;

SeqList* SeqList_Create(int capacity) {
    int ret = 0;
    TSeqList* list = NULL;
    list = (TSeqList*)malloc(sizeof(TSeqList));
    if (list == NULL) {
        ret = -1;
        printf("func SeqList_Create failed ret =%d\n", ret);
        return NULL;
    }
    memset(list, 0, sizeof(TSeqList));
    //根据capacity大小指定节点空间大小
    list->node = (unsigned int*)malloc(sizeof(unsigned int*) * capacity);
    if (list->node == NULL) {
        ret = -1;
        printf("list->node malloc failed ret =%d\n", ret);
        return NULL;
    }

    list->capacity = capacity;
    list->length = 0;
    return list;
}

void SeqList_Destroy(SeqList* list) {
    if (list == NULL)
    {
        return;
    }
    TSeqList* tList = list;
    if (tList->node != NULL) {
        free(tList->node);
    }
    free(tList);
    return;
}

void SeqList_Clear(SeqList* list) {
    if (list == NULL)
    {
        return;
    }
    TSeqList* tList = list;
    tList->length = 0;
    return;
}

int SeqList_Length(SeqList* list) {
    int ret = 0;
    if (list == NULL)
    {
        return ret;
    }
    TSeqList* tList = list;
    return tList->length;
}

int SeqList_Capacity(SeqList* list) {
    int ret = 0;
    if (list == NULL)
    {
        return ret;
    }
    TSeqList* tList = list;
    return tList->capacity;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) {
    int ret = 0;
    if (list == NULL || pos < 0 || node == NULL)
    {
        printf("SeqList_Insert fail ret=", ret = -1);
        return ret = -1;
    }
    TSeqList* tList = list;
    if (tList->node == NULL) {
        printf("SeqList_Insert fail tList->node = null,ret=", ret = -1);
        return ret = -1;
    }

    //判断是否容量已满
    if (tList->length == tList->capacity) {
        printf("capacity full", ret = -2);
        return ret = -2;
    }

    //判断pos正确性
    if (pos > tList->length) {
        pos = tList->length;
    }
    for (int i = tList->length; i > pos; i--) {
        //从后往前，将每一个元素后移一位，然后将插入的元素放在pos位置上
        tList->node[i] = tList->node[i - 1];
    }
    tList->node[pos] =(unsigned int*)node;
    tList->length++;
    return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) {
    int ret = 0;
    if (list == NULL || pos < 0)
    {
        printf("SeqList_Get fail ret=", ret = -1);
        return ret = -1;
    }
    TSeqList* tList = list;
    if (tList->node == NULL) {
        printf("SeqList_Get fail tList->node = null,ret=", ret = -1);
        return ret = -1;
    }
    return tList->node[pos];
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) {
    int ret = 0;
    if (list == NULL || pos < 0)
    {
        printf("SeqList_Delete fail ret=", ret = -1);
        return ret = -1;
    }
    TSeqList* tList = list;
    if (tList->node == NULL) {
        printf("SeqList_Delete fail tList->node = null,ret=", ret = -1);
        return ret = -1;
    }

    SeqListNode* node = (SeqListNode*)tList->node[pos];

    for (int i = pos; i < tList->length+1; i++) {
        tList->node[i] = tList->node[i + 1];
    }
    tList->length--;

    return node;
}

test.c

#include 
#include
#include 
#include "seqlist.h"

typedef struct _Teacher{
    int age;
    char name[64];
}Teacher;

void main() {
    int ret = 0;
    SeqList* list = NULL;

    Teacher t1, t2, t3, t4, t5;
    t1.age = 10;
    t2.age = 20;
    t3.age = 40;
    t4.age = 50;
    t5.age = 60;

    list = SeqList_Create(10);
    if (list == NULL) {
        printf("SeqList_Create fail ret =%d", ret);
        return;
    }
    else {
        printf("Create success");
    }

    ret = SeqList_Insert(list, (SeqListNode*)&t1, 0);
    ret = SeqList_Insert(list, (SeqListNode*)&t2, 0);
    ret = SeqList_Insert(list, (SeqListNode*)&t3, 0);
    ret = SeqList_Insert(list, (SeqListNode*)&t4, 0);
    ret = SeqList_Insert(list, (SeqListNode*)&t5, 0);

    for (int i = 0; i < SeqList_Length(list); i++) {
        Teacher*temp = (Teacher*)SeqList_Get(list, i);
        if (temp == NULL) {
            return;
        }
        printf("temp->age:%d", temp->age);
    }

    SeqList_Delete(list, 0);
    for (int i = 0; i < SeqList_Length(list); i++) {
        Teacher* temp = (Teacher*)SeqList_Get(list, i);
        if (temp == NULL) {
            return;
        }
        printf("temp2->age:%d", temp->age);
    }
    system("pause");
}

线性表链式存储

test.c

#include 
#include
#include 
#include "seqlist.h"
#include "linklist.h"

typedef struct Teacher{
    LinkListNode node;
    int age;
}Teacher;

void main() {
    LinkList* list = LinkList_Create();
    if (list == NULL) {
        printf("创建链表失败");
        return;
    }
    Teacher t1, t2, t3;
    t1.age = 10;
    t2.age = 20;
    t3.age = 30;

    LinkList_Insert(list, (LinkListNode*)& t1, 0);
    LinkList_Insert(list, (LinkListNode*)& t2, 0);
    LinkList_Insert(list, (LinkListNode*)& t3, 0);
     
    for (int i = 0; i < LinkList_Length(list); i++) {
        Teacher * node = (Teacher*)LinkList_Get(list, i);
        if (node == NULL) {
            continue;
        }
        printf("node.age = %d\n", node->age);
    }

    int length = LinkList_Length(list);
    printf("链表长度为%d\n", length);

    LinkListNode* node = LinkList_Delete(list, 0);
    for (int i = 0; i < LinkList_Length(list); i++) {
        Teacher* node = (Teacher*)LinkList_Get(list, i);
        if (node == NULL) {
            continue;
        }
        printf("node.age = %d\n", node->age);
    }

    LinkList_Destroy(list);
    system("pause");
}

linklist.h

#pragma once
#include 

typedef void LinkList;

typedef struct _tag_LinkListNode {
    struct _tag_LinkListNode* next;
}LinkListNode;

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList*list, LinkListNode* node, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

linklist.c

#include "linklist.h"

typedef struct _tag_LinkList {
    int length;
    LinkListNode header;
}TLinkList;

LinkList* LinkList_Create() {
    TLinkList* tList = (TLinkList*)malloc(sizeof(TLinkList));
    memset(tList, 0, sizeof(TLinkList));
    tList->header.next = NULL;
    tList->length = 0;
    return tList;
}

void LinkList_Destroy(LinkList* list) {
    if (list != NULL) {
        free(list);
        list = NULL;
    }
    return;
}

void LinkList_Clear(LinkList* list) {
    TLinkList* tList = NULL;
    if (list == NULL) {
        return;
    }
    tList = (TLinkList*)list;
    tList->header.next = NULL;
    tList->length = 0;
    return;
}

int LinkList_Length(LinkList* list) {
    TLinkList* tList = NULL;
    if (list == NULL) {
        return;
    }
    tList = (TLinkList*)list;
    return tList->length;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) {
    int ret = 0, i = 0;
    LinkListNode* current = NULL;
    if (list == NULL || node == NULL || pos < 0) {
        return ret = -1;
    }
    TLinkList* tList = list;
    //定义一个指针指向链表的头节点
    current = (LinkListNode*)&(tList->header);
    //将指针移动到pos位置
    for (i = 0; i < pos; i++) {
        current = current->next;
    }

    //插入节点
    node->next = current->next;
    current->next = node;
    tList->length++;
    return 0;
}

LinkListNode* LinkList_Get(LinkList* list, int pos) {
    if (list == NULL || pos < 0) {
        return NULL;
    }
    TLinkList* tList = list;
    LinkListNode* current = (LinkListNode*)&(tList->header);
    for (int i = 0; i < pos; i++) {
        current = current->next;
    }

    return current->next;
}

LinkListNode* LinkList_Delete(LinkList* list, int pos) {
    if (list == NULL || pos < 0) {
        return NULL;
    }
    TLinkList* tList = list;
    LinkListNode* current = &(tList->header);
    for (int i = 0; i < pos; i++) {
        current = current->next;
    }
    LinkListNode* temp = current->next;
    current->next = current->next->next;
    return temp;
}

循环单链表

CircleList.h

#pragma once

typedef void CircleList;

typedef struct _tag_CircleListNode {
    struct _tag_CircleListNode* next;
}CircleListNode;

CircleList* CircleListCreate();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list,int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

CircleListNode* CircleList_Delete_Node(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

CircleList.c

#include "CircleList.h"
#include 

typedef struct _tag_CircleList {
    CircleListNode header;
    CircleListNode* slider;
    int length;
}TCircleList;

CircleList* CircleListCreate() {
    TCircleList* list = (TCircleList*)malloc(sizeof(TCircleList));
    if (list == NULL) {
        return NULL;
    }
    list->header.next = NULL;
    list->slider = NULL;
    list->length = 0;
    return list;
}

void CircleList_Destroy(CircleList* list) {
    if (list == NULL) {
        return;
    }
    free(list);
}

void CircleList_Clear(CircleList* list) {
    if (list == NULL) {
        return;
    } 
    TCircleList* tList = (TCircleList*)list;
    tList->header.next = NULL;
    tList->length = 0;
    tList->slider = NULL;
    return;
}

int CircleList_Length(CircleList* list) {
    if (list == NULL) {
        return 0;
    }
    TCircleList* tList = (TCircleList*)list;
    return tList->length;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos) {
    
    TCircleList* tList = (TCircleList*)list;
    if (tList == NULL || node == NULL || pos<0) {
        return -1;
    }
    //CircleListNode* current = (CircleListNode*)(&(tList->header));
    CircleListNode* current = (CircleListNode*)tList;
    for (int i = 0; i < pos; i++) {
        current = current->next;
    }
    node->next = current->next;
    current->next = node;

    //如果是第一次插入节点
    if (tList->length == 0)
    {
        tList->slider = node;
    }

    tList->length++;

    //如果是头插法插入，current仍然指向头部，
    if (current == (CircleListNode*)tList) {
        CircleListNode*last = CircleList_Get(tList, tList->length - 1);
        last->next = current->next;
    }
    return 0;
}

CircleListNode* CircleList_Get(CircleList* list, int pos) {
    TCircleList* tList = (TCircleList*)list;
    if (tList == NULL || pos < 0) {
        return -1;
    }
    CircleListNode* current = (CircleListNode*)(&(tList->header));
    for (int i = 0; i < pos; i++) {
        current = current->next;
    }
    return current->next;
}

CircleListNode* CircleList_Delete(CircleList* list, int pos) {
    TCircleList* tList = (TCircleList*)list;
    CircleListNode* temp = NULL;
    if (tList == NULL || tList->length == 0|| pos < 0) {
        return -1;
    }
    CircleListNode* last = NULL;
    CircleListNode* current = (CircleListNode*)(&(tList->header));
    for (int i = 0; i < pos; i++) {
        current = current->next;
    }
    //如果删除的是第一个元素(pos == 0)
    if (current == (CircleListNode*)tList) {
        last = (CircleListNode*)CircleList_Get(tList, tList->length - 1);
    }

    //记录要删除的元素
    temp = current->next;
    current->next = temp->next;
    tList->length--;

    //链表不为空
    if (last != NULL) {
        tList->header.next = temp->next;
        last->next = temp->next;
    }

    //如果删除的元素是游标所指的元素
    if (tList->slider = temp) {
        tList->slider = temp->next;
    }

    //如果删除后长度变为0
    if (tList->length == 0) {
        tList->header.next = NULL;
        tList->slider = NULL;
    }
    return temp;
}

CircleListNode* CircleList_Delete_Node(CircleList* list, CircleListNode* node) {

}

CircleListNode* CircleList_Reset(CircleList* list) {

    //邮标重新指向头部位置
    TCircleList* tList = (TCircleList*)list;
    CircleListNode* ret=NULL;
    if (tList == NULL) {
        return -1;
    }
    tList->slider = tList->header.next;
    ret = tList->slider;
    return ret;
}

CircleListNode* CircleList_Current(CircleList* list) {
    TCircleList* tList = (TCircleList*)list;
    if (tList == NULL) {
        return NULL;
    }
    return tList->slider;
}

//把当前位置返回并且游标下移
CircleListNode* CircleList_Next(CircleList* list) {
    TCircleList* tList = (TCircleList*)list;
    CircleListNode* ret = NULL;
    if (tList == NULL || tList->slider == NULL) {
        return NULL;
    }
    ret = tList->slider;
    tList->slider = ret->next;
    return ret;
}

test.c

#include 
#include
#include 
#include "seqlist.h"
#include "linklist.h"
#include "CircleList.h"

struct Value
{
    CircleListNode circleListNode;
    int v;
};

void main() {
    CircleList* list = CircleListCreate();
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    struct Value v6;

    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    v6.v = 6;
    printf("开始插入元素\n");
    CircleList_Insert(list, &v1,0);
    CircleList_Insert(list, &v2, 0);
    CircleList_Insert(list, &v3, 0);
    CircleList_Insert(list, &v4, 0);
    CircleList_Insert(list, &v5, 0);
    CircleList_Insert(list, &v6, 0);

    for (int i = 0; i < 2 * CircleList_Length(list); i++) {
        struct Value* v = CircleList_Get(list, i);
        printf("打印元素：%d\n", v->v);
    }

    while (CircleList_Length(list) > 0) {
        struct Value* v = CircleList_Delete(list, 0);
        printf("删除元素：%d\n", v->v);
    }

    printf("\n");

    printf("销毁\n");
    CircleList_Destroy(list);

    printf("完成\n");
    system("pause");
}


typedef struct Teacher {
    LinkListNode node;
    int age;
}Teacher;

void main2() {
    LinkList* list = LinkList_Create();
    if (list == NULL) {
        printf("创建链表失败");
        return;
    }
    Teacher t1, t2, t3;
    t1.age = 10;
    t2.age = 20;
    t3.age = 30;

    LinkList_Insert(list, (LinkListNode*)& t1, 0);
    LinkList_Insert(list, (LinkListNode*)& t2, 0);
    LinkList_Insert(list, (LinkListNode*)& t3, 0);

    for (int i = 0; i < LinkList_Length(list); i++) {
        Teacher* node = (Teacher*)LinkList_Get(list, i);
        if (node == NULL) {
            continue;
        }
        printf("node.age = %d\n", node->age);
    }

    int length = LinkList_Length(list);
    printf("链表长度为%d\n", length);

    LinkListNode* node = LinkList_Delete(list, 0);
    for (int i = 0; i < LinkList_Length(list); i++) {
        Teacher* node = (Teacher*)LinkList_Get(list, i);
        if (node == NULL) {
            continue;
        }
        printf("node.age = %d\n", node->age);
    }

    LinkList_Destroy(list);
    system("pause");
}

你可能感兴趣的:(16C++ 数据结构)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 【Python】数据结构,链表,算法详解 AIAdvocate python数据结构链表排序算法广度优先深度优先
    今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.​背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
  • AI教你学Python 第4天：函数和模块 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • Rust中的所有权和借用规则详解 代码云1 rust开发语言后端
    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
  • 二叉树--python 电子海鸥 Python数据结构与算法python开发语言数据结构
    二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
  • 使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
    什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池） 爱打怪的小魔女 java线程池队列封装
    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
  • html 周华华 html
    js 1，数组的排列 var arr=[1,4,234,43,52,]; for(var x=0;x<arr.length;x++){    for(var y=x-1;y<arr.length;y++){      if(arr[x]<arr[y]){     &
  • 【Struts2 四】Struts2拦截器 bit1129 struts2拦截器
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。   Struts2中自定义拦截器的步骤是：
  • make:cc 命令未找到解决方法 daizj linux命令未知make cc
    安装rz sz程序时，报下面错误：   [root@slave2 src]# make posix cc   -O -DPOSIX -DMD=2 rz.c -o rz make: cc：命令未找到 make: *** [posix] 错误 127   系统：centos 6.6 环境：虚拟机   错误原因：系统未安装gcc，这个是由于在安
  • Oracle之Job应用 周凡杨 oracle job
    最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。   一：查看相关job信息    1、相关视图  dba_jobs  all_jobs  user_jobs  dba_jobs_running 包含正在运行
  • 多线程机制 朱辉辉33 多线程
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 程序、进程和线程： 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一） 老A不折腾 web报表finereportjava报表报表工具
    FineReport使用中遇到的常见报错及解决办法（一） 这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。   1、address pool is full： 含义：地址池满，连接数超过并发数上
  • mysql rpm安装后没有my.cnf 林鹤霄 没有my.cnf
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题 aigo root
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/   Step 4: Run ADB command from your PC   On the PC, you need install Amazon Fire ADB driver and instal
  • javascript 中var提升的典型实例 alxw4616 JavaScript
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧 myname = 'global'; var fn = function () { console.log(myname); // undefined var myname = 'local'; console.log(myname); // local }; fn() // 上述代码实际上等同于以下代码 m
  • 定时器和获取时间的使用 百合不是茶 时间的转换定时器
    定时器:定时创建任务在游戏设计的时候用的比较多   Timer();定时器 TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。       定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
  • JDK1.5 Queue bijian1013 javathreadjava多线程Queue
    JDK1.5 Queue LinkedList： LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
  • http认证原理和https bijian1013 httphttps
    一.基础介绍         在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。         Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
  • 【Java范型五】范型继承 bit1129 java
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2   package com.tom.lang.generics; public abstract class SuperGenerics<T1, T2> { private T1 t1; private T2 t2; public abstract void doIt(T
  • 【Nginx六】nginx.conf常用指令(Directive) bit1129 Directive
    1. worker_processes    8; 表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行   nobody 53879 118449 0 Apr22 ? 00:26:15 nginx: worker process
  • lua 遍历Header头部 ronin47 lua header 遍历　
    local headers = ngx.req.get_headers()   ngx.say("headers begin", "<br/>")   ngx.say("Host : ", he
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。 bylijinnan java
    import java.util.Arrays; public class MinSumASumB { /** * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序. * * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 * 例如: * int[] a = {100,99,98,1,2,3
  • redis 开窍的石头 redis
    在redis的redis.conf配置文件中找到# requirepass foobared 把它替换成requirepass 12356789 后边的12356789就是你的密码 打开redis客户端输入config get requirepass 返回 redis 127.0.0.1:6379> config get requirepass 1) "require
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？ comsci java语言
          无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情       
  • 安装ubuntu14.04登录后花屏了怎么办 cuiyadll ubuntu
    这个情况，一般属于显卡驱动问题。 可以先尝试安装显卡的官方闭源驱动。 按键盘三个键：CTRL + ALT  +  F1 进入终端，输入用户名和密码登录终端： 安装amd的显卡驱动 sudo  apt-get  install  fglrx 安装nvidia显卡驱动 sudo  ap
  • SSL 与 数字证书 的基本概念和工作原理 darrenzhu 加密ssl证书密钥签名
    SSL 与 数字证书 的基本概念和工作原理 http://www.linuxde.net/2012/03/8301.html SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 http://www.ibm.com/developerworks/cn/webspher
  • Ubuntu设置ip的步骤 dcj3sjt126com ubuntu
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 转载不是错： Ubuntu命令行修改网络配置方法 /etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 1. 以D
  • php包管理工具推荐 dcj3sjt126com PHPComposer
    http://www.phpcomposer.com/   Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。 中文文档  入门指南  下载  安装包列表 Composer 中国镜像
  • Gson使用四（TypeAdapter） eksliang jsongsonGson自定义转换器gsonTypeAdapter
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述        Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例        例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
  • JQM控件之Navbar和Tabs gundumw100 htmlxmlcss
    在JQM中使用导航栏Navbar是简单的。 只需要将data-role="navbar"赋给div即可： <div data-role="navbar"> <ul> <li><a href="#" class="ui-btn-active&qu
  • 利用归并排序算法对大文件进行排序 iwindyforest java归并排序大文件分治法Merge sort
      归并排序算法介绍，请参照Wikipeida zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 基本思想： 大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 低于限制行数的子文件直接排序 两个排序好的子文件归并到父文件 直到最后所有排序好的父文件归并到输入
  • iOS UIWebView URL拦截 啸笑天 UIWebView
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
  • 索引的碎片整理SQL语句 macroli sql
    SET NOCOUNT ON DECLARE @tablename VARCHAR (128) DECLARE @execstr VARCHAR (255) DECLARE @objectid INT DECLARE @indexid INT DECLARE @frag DECIMAL DECLARE @maxfrag DECIMAL --设置最大允许的碎片数量,超过则对索引进行碎片
  • Angularjs同步操作http请求with $promise qiaolevip 每天进步一点点学习永无止境AngularJS纵观千象
    // Define a factory app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) { var deferred = $q.defer(); AccountService.getProfile().then(function(res) {
  • hibernate联合查询问题 sxj19881213 sqlHibernateHQL联合查询
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2）   1 几个常识：  （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。  （2）hql的默认查询策略，在进行联合查询时，会产
  • struts2.xml wuai struts
    <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他