C语言-手写(自动分值排序集合)

前沿

很多的时候,我们需要根据(年龄,成绩,分值)等等进行插入的时候就排好顺序 ,这样我们想统计排名前10的或者排名后10的就非常方便,而且这个排序和我们插入的顺序没有关系完全取决于分值进行插入的,而且我们还可以利用这一个机制来做一个优先处理机制比如先创建的订单优先处理

实现代码

#ifndef STUDY_CHAR_KV_ORDERLY_LIST_H
#define STUDY_CHAR_KV_ORDERLY_LIST_H
typedef int boolean;//定义一个布尔类型
#define TRUE 1
#define FALSE 0
//定义数据节点
typedef struct charKvOrderlyListData {
    
    
    char *key;
    void *data;
    int sort;//排序
    struct charLinkedNode *next;
} CharKvOrderlyListData;

typedef struct charKvOrderlyList {
    
    
    CharKvOrderlyListData **data;
    int len;
    int capacity;
    int dilatationCount;
    int dilatationSum;
} CharKvOrderlyList;

CharKvOrderlyList *createCharKvOrderlyList(int size);

void addCharKvOrderlyList(CharKvOrderlyList *pCharList, char *key, void *data, int sort);

CharKvOrderlyListData *getCharKvOrderlyList(CharKvOrderlyList *pCharList, int index);

void removeCharKvOrderlyListByIndex(CharKvOrderlyList *pCharList, int index);

void removeCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key);

void removeCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data);

CharKvOrderlyListData *getCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key);

CharKvOrderlyListData *getCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data);

void setCharKvOrderlyList(CharKvOrderlyList *pCharList, int index, CharKvOrderlyListData *data);

void setCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key, CharKvOrderlyListData *data);

void setCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data1, CharKvOrderlyListData *data);

int getCharKvOrderlyListLen(CharKvOrderlyList *pCharList);

void clearCharKvOrderlyList(CharKvOrderlyList *pCharList);

void forEachCharKvOrderlyList(CharKvOrderlyList *pCharList, void (*func)(CharKvOrderlyListData *data));

int indexOfCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data);

int indexOfCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data);

int lastIndexOfCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data);

int lastIndexOfCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data);

int binarySearchCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key);

int binarySearchCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data);

void reverseCharKvOrderlyList(CharKvOrderlyList *pCharList);

void distinctCharKvOrderlyListByKey(CharKvOrderlyList *pCharList);

void distinctCharKvOrderlyListByData(CharKvOrderlyList *pCharList);

CharKvOrderlyList *copyCharKvOrderlyList(CharKvOrderlyList *pCharList);

CharKvOrderlyList *mergeCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2);

CharKvOrderlyList *differenceCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2);

CharKvOrderlyList *complementCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2);

CharKvOrderlyList *unionCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2);

CharKvOrderlyList *intersectionCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2);

CharKvOrderlyList *getFirstCharKvOrderlyList(CharKvOrderlyList *charList, int n);

CharKvOrderlyList *getLastCharKvOrderlyList(CharKvOrderlyList *charList, int n);

CharKvOrderlyList *getRangeCharKvOrderlyList(CharKvOrderlyList *charList, int start, int end);

CharKvOrderlyListData *popFirstCharKvOrderlyList(CharKvOrderlyList *charList);

CharKvOrderlyListData *popLastCharKvOrderlyList(CharKvOrderlyList *charList);

typedef struct charKvOrderlyListIterator {
    
    
    CharKvOrderlyList *charList;    // 迭代器所指向的集合
    int count;      // 迭代次数
} CharKvOrderlyListIterator;

// 创建哈希结构迭代器
CharKvOrderlyListIterator *createCharKvOrderlyListIterator(CharKvOrderlyList *charList);

// 迭代器是否有下一个
boolean hasNextCharKvOrderlyList(CharKvOrderlyListIterator *iterator);

// 迭代到下一次
CharKvOrderlyListData *nextCharKvOrderlyList(CharKvOrderlyListIterator *iterator);

#endif //STUDY_CHAR_KV_ORDERLY_LIST_H

#include <stdlib.h>
#include "char_kv_orderly_list.h"
#include <string.h>

//创建一个排序集合
CharKvOrderlyList *createCharKvOrderlyList(int size) {
    
    
    if (size < 10) {
    
    
        size = 10;
    }
    //初始化结构体和一个2级指针
    CharKvOrderlyList *charKvOrderlyList = (CharKvOrderlyList *) malloc(sizeof(CharKvOrderlyList));
    charKvOrderlyList->data = (CharKvOrderlyListData **) calloc(size, sizeof(CharKvOrderlyListData *));
    charKvOrderlyList->len = 0;
    charKvOrderlyList->dilatationCount = 0;
    charKvOrderlyList->dilatationSum = 0;
    charKvOrderlyList->capacity = size;
    return charKvOrderlyList;
}

//创建数据节点
CharKvOrderlyListData *createCharKvOrderlyListData(char *key, void *data, int sort) {
    
    
    CharKvOrderlyListData *charKvOrderlyListData = (CharKvOrderlyListData *) malloc(sizeof(CharKvOrderlyListData));
    charKvOrderlyListData->key = key;
    charKvOrderlyListData->data = data;
    charKvOrderlyListData->sort = sort;
    charKvOrderlyListData->next = NULL;
    return charKvOrderlyListData;
}

//扩容基数
static int expansionBase(CharKvOrderlyList *pCharList) {
    
    
    int len = pCharList->capacity;
    int dilatationCount = pCharList->dilatationCount;
    pCharList->dilatationSum++;
    //基础扩容
    len += (len >= 100000000 ? len * 0.2 :
            len >= 50000000 ? len * 0.3 :
            len >= 10000000 ? len * 0.4 :
            len >= 5000000 ? len * 0.5 :
            len >= 1000000 ? len * 0.6 :
            len >= 500000 ? len * 0.7 :
            len >= 100000 ? len * 0.8 :
            len >= 50000 ? len * 0.9 :
            len * 1.0);
    pCharList->dilatationCount++;
    //频率扩容
    if (dilatationCount >= 3) {
    
    
        len += (len >= 100000000 ? len * 1 :
                len >= 50000000 ? len * 2 :
                len >= 10000000 ? len * 3 :
                len >= 5000000 ? len * 4 :
                len >= 1000000 ? len * 5 :
                len >= 500000 ? len * 6 :
                len >= 100000 ? len * 7 :
                len >= 50000 ? len * 8 :
                len >= 10000 ? len * 9 :
                len >= 1000 ? len * 10 :
                len * 20);
        pCharList->dilatationCount = 0;
    }
    return len;
}

//扩容
static void dilatation(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int capacity1 = charList->capacity;//获取当前节点的容积
    int size = expansionBase(pCharList);//容积增加
    charList->capacity = size;//更新容积
    CharKvOrderlyListData **p1 = (CharKvOrderlyListData **) realloc(charList->data,
                                                                    size * sizeof(CharKvOrderlyListData *));
    charList->data = p1;
}

//添加一个值 ,容量不够会自动在原有基础上进行扩容
static void addCharKvOrderlyListData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    int capacity1 = charList->capacity;//获取数组的容量
    if (len1 == capacity1) {
    
    
        dilatation(pCharList);//扩容
    }
    //插入数据,并根据sort进行排序
    int sort = data->sort;
    int i = 0;//记录插入的位置
    for (i = 0; i < len1; i++) {
    
    
        if (sort < charList->data[i]->sort) {
    
    
            break;
        }
    }
    if (i == len1) {
    
    //插入到最后
        charList->data[len1] = data;
    } else {
    
    //插入到中间
        memmove(&charList->data[i + 1], &charList->data[i], (len1 - i) * sizeof(CharKvOrderlyListData *));//移动数据
        charList->data[i] = data;//插入数据
    }
    charList->len++;
}

void addCharKvOrderlyList(CharKvOrderlyList *pCharList, char *key, void *data, int sort) {
    
    
    CharKvOrderlyListData *data1 = createCharKvOrderlyListData(key, data, sort);
    addCharKvOrderlyListData(pCharList, data1);
}

//获取一个值
CharKvOrderlyListData *getCharKvOrderlyList(CharKvOrderlyList *pCharList, int index) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    if (index >= len1) {
    
    
        return NULL;
    }
    return charList->data[index];
}

//删除一个值
void removeCharKvOrderlyListByIndex(CharKvOrderlyList *pCharList, int index) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    if (index >= len1) {
    
    
        return;
    }
    CharKvOrderlyListData *data = charList->data[index];
    free(data);
    for (int i = index; i < len1 - 1; i++) {
    
    
        charList->data[i] = charList->data[i + 1];
    }
    charList->len--;
}

//删除一个值
void removeCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        if (strcmp(data->key, key) == 0) {
    
    
            free(data);
            for (int j = i; j < len1 - 1; j++) {
    
    
                charList->data[j] = charList->data[j + 1];
            }
            charList->len--;
            break;
        }
    }
}

//删除一个值
void removeCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (data1->data == data) {
    
    
            free(data1);
            for (int j = i; j < len1 - 1; j++) {
    
    
                charList->data[j] = charList->data[j + 1];
            }
            charList->len--;
            break;
        }
    }
}

//获取一个值
CharKvOrderlyListData *getCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        if (strcmp(data->key, key) == 0) {
    
    
            return data;
        }
    }
    return NULL;
}

//获取一个值
CharKvOrderlyListData *getCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (data1->data == data) {
    
    
            return data1;
        }
    }
    return NULL;
}

//修改一个值
void setCharKvOrderlyList(CharKvOrderlyList *pCharList, int index, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    if (index >= len1) {
    
    
        return;
    }
    charList->data[index] = data;
}

//修改一个值
void setCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (strcmp(data1->key, key) == 0) {
    
    
            charList->data[i] = data;
            break;
        }
    }
}

//修改一个值
void setCharKvOrderlyListByData(CharKvOrderlyList *pCharList, void *data1, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data2 = charList->data[i];
        if (data2->data == data1) {
    
    
            charList->data[i] = data;
            break;
        }
    }
}

//获取长度
int getCharKvOrderlyListLen(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    return charList->len;
}

//清空
void clearCharKvOrderlyList(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        free(data);
    }
    charList->len = 0;
    free(charList->data);
    free(charList);
}

//加工器
void forEachCharKvOrderlyList(CharKvOrderlyList *pCharList, void (*func)(CharKvOrderlyListData *data)) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        func(data);
    }
}

//查询指定元素的下标 ,没有找到返回-1
int indexOfCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (strcmp(data1->key, data->key) == 0) {
    
    
            return i;
        }
    }
    return -1;
}

//查询指定元素的下标 ,没有找到返回-1
int indexOfCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (data1->data == data->data) {
    
    
            return i;
        }
    }
    return -1;
}

//末尾查询指定元素下标 ,没有找到返回-1
int lastIndexOfCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = len1 - 1; i >= 0; i--) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (strcmp(data1->key, data->key) == 0) {
    
    
            return i;
        }
    }
    return -1;
}

//末尾查询指定元素下标 ,没有找到返回-1
int lastIndexOfCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = len1 - 1; i >= 0; i--) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        if (data1->data == data->data) {
    
    
            return i;
        }
    }
    return -1;
}

/**
 * 二分查询,没有找到返回-1  以ASCII码查询
 * @param pCharList
 * @param key
 * @return  找到返回下标,没有找到返回-1
 */
int binarySearchCharKvOrderlyListByKey(CharKvOrderlyList *pCharList, char *key) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    int low = 0;
    int high = len1 - 1;
    while (low <= high) {
    
    
        int mid = (low + high) / 2;
        CharKvOrderlyListData *data = charList->data[mid];
        if (strcmp(data->key, key) == 0) {
    
    
            return mid;
        } else if (strcmp(data->key, key) > 0) {
    
    
            high = mid - 1;
        } else {
    
    
            low = mid + 1;
        }
    }
    return -1;
}

/**
 * 二分查询,没有找到返回-1  以指针查询
 * @param pCharList
 * @param data   (只支持数值,不支持字符串等其他类型的数据)
 * @return  找到返回下标,没有找到返回-1
 */
int binarySearchCharKvOrderlyListByData(CharKvOrderlyList *pCharList, CharKvOrderlyListData *data) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    int low = 0;
    int high = len1 - 1;
    while (low <= high) {
    
    
        int mid = (low + high) / 2;
        CharKvOrderlyListData *data1 = charList->data[mid];
        if (data1->data == data->data) {
    
    
            return mid;
        } else if (data1->data > data->data) {
    
    
            high = mid - 1;
        } else {
    
    
            low = mid + 1;
        }
    }
    return -1;
}

//反转
void reverseCharKvOrderlyList(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1 / 2; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        CharKvOrderlyListData *data2 = charList->data[len1 - 1 - i];
        char *key = data1->key;
        data1->key = data2->key;
        data2->key = key;
        void *data = data1->data;
        data1->data = data2->data;
        data2->data = data;
    }
}

//去重
void distinctCharKvOrderlyListByKey(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1 - 1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        for (int j = i + 1; j < len1; j++) {
    
    
            CharKvOrderlyListData *data2 = charList->data[j];
            if (strcmp(data1->key, data2->key) == 0) {
    
    
                charList->len--;
                for (int k = j; k < len1; k++) {
    
    
                    charList->data[k] = charList->data[k + 1];
                }
                j--;
            }
        }
    }
}

//去重  不支持字符串等其他类型的数据只支持数值或者地址比对
void distinctCharKvOrderlyListByData(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1 - 1; i++) {
    
    
        CharKvOrderlyListData *data1 = charList->data[i];
        for (int j = i + 1; j < len1; j++) {
    
    
            CharKvOrderlyListData *data2 = charList->data[j];
            if (data1->data == data2->data) {
    
    
                charList->len--;
                for (int k = j; k < len1; k++) {
    
    
                    charList->data[k] = charList->data[k + 1];
                }
                j--;
            }
        }
    }
}

//数组复制,返回新数组
CharKvOrderlyList *copyCharKvOrderlyList(CharKvOrderlyList *pCharList) {
    
    
    CharKvOrderlyList *charList = pCharList;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(pCharList->len);
    int len1 = charList->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    return newCharList;
}

//数组合并,返回新数组
CharKvOrderlyList *mergeCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2) {
    
    
    CharKvOrderlyList *charList1 = pCharList1;
    CharKvOrderlyList *charList2 = pCharList2;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(charList1->len + charList2->len);
    int len1 = charList1->len;//获取当前节点的长度
    int len2 = charList2->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList1->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    for (int i = 0; i < len2; i++) {
    
    
        CharKvOrderlyListData *data = charList2->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    return newCharList;
}

//数组差集,返回新数组
CharKvOrderlyList *differenceCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2) {
    
    
    CharKvOrderlyList *charList1 = pCharList1;
    CharKvOrderlyList *charList2 = pCharList2;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(charList1->len);
    int len1 = charList1->len;//获取当前节点的长度
    int len2 = charList2->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList1->data[i];
        int index = binarySearchCharKvOrderlyListByKey(charList2, data->key);
        if (index == -1) {
    
    
            addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
        }
    }
    return newCharList;
}

//数组补集,返回新数组
CharKvOrderlyList *complementCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2) {
    
    
    CharKvOrderlyList *charList1 = pCharList1;
    CharKvOrderlyList *charList2 = pCharList2;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(charList1->len + charList2->len);
    int len1 = charList1->len;//获取当前节点的长度
    int len2 = charList2->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList1->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    for (int i = 0; i < len2; i++) {
    
    
        CharKvOrderlyListData *data = charList2->data[i];
        int index = binarySearchCharKvOrderlyListByKey(charList1, data->key);
        if (index == -1) {
    
    
            addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
        }
    }
    return newCharList;
}

//数组并集,返回新数组
CharKvOrderlyList *unionCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2) {
    
    
    CharKvOrderlyList *charList1 = pCharList1;
    CharKvOrderlyList *charList2 = pCharList2;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(charList1->len + charList2->len);
    int len1 = charList1->len;//获取当前节点的长度
    int len2 = charList2->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList1->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    for (int i = 0; i < len2; i++) {
    
    
        CharKvOrderlyListData *data = charList2->data[i];
        int index = binarySearchCharKvOrderlyListByKey(charList1, data->key);
        if (index == -1) {
    
    
            addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
        }
    }
    return newCharList;
}

//数组交集,返回新数组
CharKvOrderlyList *intersectionCharKvOrderlyList(CharKvOrderlyList *pCharList1, CharKvOrderlyList *pCharList2) {
    
    
    CharKvOrderlyList *charList1 = pCharList1;
    CharKvOrderlyList *charList2 = pCharList2;
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(charList1->len);
    int len1 = charList1->len;//获取当前节点的长度
    int len2 = charList2->len;//获取当前节点的长度
    for (int i = 0; i < len1; i++) {
    
    
        CharKvOrderlyListData *data = charList1->data[i];
        int index = binarySearchCharKvOrderlyListByKey(charList2, data->key);
        if (index != -1) {
    
    
            addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
        }
    }
    return newCharList;
}

CharKvOrderlyListIterator *createCharKvOrderlyListIterator(CharKvOrderlyList *charList) {
    
    
    CharKvOrderlyListIterator *iterator = malloc(sizeof(CharKvOrderlyListIterator));
    iterator->charList = charList;
    iterator->count = 0;
    return iterator;
}

boolean hasNextCharKvOrderlyList(CharKvOrderlyListIterator *iterator) {
    
    
    boolean b = iterator->count < iterator->charList->len ? TRUE : FALSE;
    if (!b) {
    
    //迭代完毕释放内存
        free(iterator);
    }
    return b;
}

//迭代下一个元素
CharKvOrderlyListData *nextCharKvOrderlyList(CharKvOrderlyListIterator *iterator) {
    
    
    if (!hasNextCharKvOrderlyList(iterator)) {
    
    
        return NULL;
    }
    CharKvOrderlyListData *p = iterator->charList->data[iterator->count];
    iterator->count++;
    return p;
}
//获取前n个元素
CharKvOrderlyList *getFirstCharKvOrderlyList(CharKvOrderlyList *charList, int n) {
    
    
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(n);
    for (int i = 0; i < n; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    return newCharList;
}
//获取后n个元素
CharKvOrderlyList *getLastCharKvOrderlyList(CharKvOrderlyList *charList, int n) {
    
    
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(n);
    int len = charList->len;
    for (int i = len - n; i < len; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    return newCharList;
}
//获取区间内的元素
CharKvOrderlyList *getRangeCharKvOrderlyList(CharKvOrderlyList *charList, int start, int end) {
    
    
    CharKvOrderlyList *newCharList = createCharKvOrderlyList(end - start);
    for (int i = start; i < end; i++) {
    
    
        CharKvOrderlyListData *data = charList->data[i];
        addCharKvOrderlyListData(newCharList, createCharKvOrderlyListData(data->key, data->data, data->sort));
    }
    return newCharList;
}
//弹出第一个元素(注意使用完后要释放内存)
CharKvOrderlyListData *popFirstCharKvOrderlyList(CharKvOrderlyList *charList) {
    
    
    CharKvOrderlyListData *data = malloc(sizeof(CharKvOrderlyListData));
    data = memccpy(data, charList->data[0], 0, sizeof(CharKvOrderlyListData));
    removeCharKvOrderlyListByIndex(charList, 0);
    return data;
}
//弹出最后一个元素
CharKvOrderlyListData *popLastCharKvOrderlyList(CharKvOrderlyList *charList) {
    
    
    CharKvOrderlyListData *data = malloc(sizeof(CharKvOrderlyListData));
    data = memccpy(data, charList->data[charList->len - 1], 0, sizeof(CharKvOrderlyListData));
    removeCharKvOrderlyListByIndex(charList, charList->len - 1);
    return data;
}

点赞 -收藏-关注-便于以后复习和收到最新内容 有其他问题在评论区讨论-或者私信我-收到会在第一时间回复 在本博客学习的技术不得以任何方式直接或者间接的从事违反中华人民共和国法律,内容仅供学习、交流与参考 免责声明：本文部分素材来源于网络，版权归原创者所有，如存在文章/图片/音视频等使用不当的情况，请随时私信联系我、以迅速采取适当措施，避免给双方造成不必要的经济损失。 感谢,配合,希望我的努力对你有帮助^_^