SQLIST

已于 2023-09-14 00:01:36 修改
阅读量45 收藏
点赞数
文章标签： 算法 数据结构 c++
于 2023-09-13 22:30:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63957897/article/details/132865753
版权

目录

静态

#include <stdio.h>
#include <malloc.h>

#define N 10

void staticList(){
    int iList[N]={9,8,7,6,5,4,3,2,1,0};
    printf("%d,%d",iList[0],iList[1]);
    
}

void dynamicList(){
    int * pList = (int *)malloc(sizeof(int)*N);
    pList = (int *)malloc(sizeof(int)*2*N);
    printf("%d\n",pList[2]);
    pList[2]=3;
    printf("%d\n",pList[2]);
    int * pNew = (int *)malloc(sizeof(int)*2*N);
    free(pList);
    pList = pNew;
    pList[N+1]= 6;
}


typedef struct Sqlist{
    int iList[N];
    int length;
}Sqlist;

int main(){

    staticList();
    dynamicList();

    return 0;
}

动态存储

​

#include <stdio.h>
#include <malloc.h>

#define N 10


void dynamicList(){
    int * pList = (int *)malloc(sizeof(int)*N);
    pList = (int *)malloc(sizeof(int)*2*N);
    printf("%d\n",pList[2]);
    pList[2]=3;
    printf("%d\n",pList[2]);
    int * pNew = (int *)malloc(sizeof(int)*2*N);
    free(pList);
    pList = pNew;
    pList[N+1]= 6;
}


typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

int main(){

    dynamicList();
    Sqlist L; 
    for(int i=0;i<L.length-1;i++)
        printf("%d,%d",L.pList[i],L.pList[i+1]);

    return 0;
}

循环的索引问题

​

void indexTrouble(){
    Sqlist L; 
    for(int i=0;i<L.length;i++){//依次访问每个元素
        printf("%d",L.pList[i]);
    }
    for(int i=0;i<L.length-1;i++){//访问每一组前驱与后继
        printf("%d,%d",L.pList[i],L.pList[i+1]);
    }
}

顺序表

1.顺序表创建

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    printf("length:%d\n",L.length);
    L.length = 0;
    printf("length:%d\n",L.length);    
    

}
int main(){
    Sqlist L;
    initial(L);

    return 0;
}

​

2.第i个位置插入元素

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    printf("length:%d\n",L.length);
    L.length = 0;
    printf("length:%d\n",L.length);    
}

int insert(ElemType e,int i,Sqlist &L){
    //step1 判断是否合法
    if(i<1||i>L.length)
        return 0;
    //step2 判断插入空间是否充足，不充足申请新的空间，并将老表元素复制过去
    if(L.length>=L.listsize){
        ElemType * pNew = (ElemType*)malloc(sizeof(ElemType)*(2*L.listsize));
        for(int index=0;index<L.length;index++){
            pNew[index]=L.pList[index];
        } 
        L.pList = pNew;
        L.listsize= 2*L.listsize;
    }
    //step3 插入
    for(int index=L.length-1;index>=i;index--)
        L.pList[index+1]=L.pList[index];
    L.pList[i-1]=e;
    L.length+=1;
    return 1;
}
void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
}
void value(Sqlist &L){
    L.length = N;
    for(int i =0 ;i<L.length;i++){
        if(i==3){
            L.pList[i]=L.length-3;
        }
        else if(i==6){
            L.pList[i]=L.length-2;
        }
        else{
            L.pList[i]=L.length-1;
        }
    }
    print(L);

}

int main(){
    Sqlist L;
    initial(L);
    value(L);
    int ret =insert(100,1,L);
    if(ret == 1)
        print(L);

    return 0;
}

​

3.删除第i个元素

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    printf("length:%d\n",L.length);
    L.length = 0;
    printf("length:%d\n",L.length);    
}

int insert(ElemType e,int i,Sqlist &L){
    //step1 判断是否合法
    if(i<1||i>L.length)
        return 0;
    //step2 判断插入空间是否充足，不充足申请新的空间，并将老表元素复制过去
    if(L.length>=L.listsize){
        ElemType * pNew = (ElemType*)malloc(sizeof(ElemType)*(2*L.listsize));
        for(int index=0;index<L.length;index++){
            pNew[index]=L.pList[index];
        } 
        L.pList = pNew;
        L.listsize= 2*L.listsize;
    }
    //step3 插入
    for(int index=L.length-1;index>=i;index--)
        L.pList[index+1]=L.pList[index];
    L.pList[i-1]=e;
    L.length+=1;
    return 1;
}
int deleteList(int i,Sqlist &L){
    if(i<1||i>L.length-1){
        return 0;
    }
    for(int index =i;index<L.length;index++){
        L.pList[index-1]=L.pList[index];
    }
    L.length-=1;
    return 1;

}
void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
}
void value(Sqlist &L){
    L.length = N;
    for(int i =0 ;i<L.length;i++){
        if(i==3){
            L.pList[i]=L.length-3;
        }
        else if(i==6){
            L.pList[i]=L.length-2;
        }
        else{
            L.pList[i]=L.length-1;
        }
    }
    print(L);

}

int main(){
    Sqlist L;
    initial(L);
    value(L);
    int ret =insert(100,1,L);
    if(ret == 1)
        print(L);
    int ret1=deleteList(1,L);
    if(ret1==1)
        print(L);
    return 0;
}

​

删除最小元素，空位由最后一个元素填补

​​
最小值的查找问题:
1、数据是给定的，查找范围是有限的，初始化任意元素
2、数据没有给定，未知且随机，查找范围是无限的，初始化为一个不可能出现的无穷大值INFminValue = 100;
{101，102，…}
100压根就不存在于数据集合中，但是你却初始化了最小值为100，以为100为最小值

​
void deleteMin(Sqlist &L){
    int minIndex=0;
    for(int i=0;i<L.length;i++){
        if(L.pList[minIndex]>L.pList[i])
            minIndex = i;
    }
    L.pList[minIndex]=L.pList[L.length-1];
    --L.length;
}

​

当前访问子序列长度>=当前结果子序列的长度分析:
1、访问一个，然后通过后面元素往前移动来执行删除，这样时间复杂度太高。
2、开创一个临时空间，将满足要求的元素放入，不满足要求的过滤，这样空间复杂度太高。
3、返现在执行第2种方法时，过滤后的元素集合是读取的元素集合的子集，即过滤后的元素集合不会占用未访问元素的集合,不会发生数据覆盖，从而可以在原有空间上进行过滤操作。
我们称这种在原存储空间上依次访问元素并对访问元素进行过滤来达到对特定一些(–个以上)元素删除的方法成为过滤法。

【过滤算法】

在无序表中删除值在s和t之间的所有元素

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    L.length = 0;
 
}

void deleteElem(int s,int t,Sqlist &L){
    int curLength = 0;//当前结果子序列长度
    for(int i=0,j=0;i<L.length;i++){
        if(L.pList[i]<s||L.pList[i]>t){
            L.pList[curLength]=L.pList[i];
            curLength++;
        }
    }
    L.length=curLength;
}

void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
}
void value(Sqlist &L){
    L.length = N;
    for(int i =0 ;i<L.length;i++){
        if(i==3){
            L.pList[i]=L.length-3;
        }
        else if(i==6){
            L.pList[i]=L.length-2;
        }
        else{
            L.pList[i]=L.length-i;
        }
    }
    print(L);

}

int main(){
    Sqlist L;
    initial(L);
    value(L);
    deleteElem(3,5,L);
    print(L);

    return 0;
}

​

【偏移法】

非递减顺序表中删除值在s和t之间的元素

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    L.length = 0;
 
}

int deleteElem(int s,int t,Sqlist &L){
    int sIndex = -1;
    for(int i = 0;i<L.length;i++){
        if(L.pList[i]>=s&&L.pList[i]<=t){
            sIndex = i;
            break;
        }
    }
    if(sIndex == -1){
        return 0;
    }

    int tIndex = -1;
    for(int i = L.length-1;i>=0;i--){
        if(L.pList[i]>=s&&L.pList[i]<=t){
            tIndex = i;
            break;
        }
    }
    //偏移量t-s+1
    int delta = tIndex - sIndex + 1;    
    for(int i =tIndex+1;i<L.length;i++){
        L.pList[i-delta]=L.pList[i];
    }
    L.length-=delta;

    return 1;
}

void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
}
void value(Sqlist &L){
    L.length = N;
    for(int i= 0;i<L.length;i++){
        L.pList[i]=i+1;
    }
    print(L);

}

int main(){
    Sqlist L;
    initial(L);
    value(L);
    int ret = deleteElem(4,7,L);
    if(ret = 1)
        print(L);
    else 
        printf("no");

    return 0;
}

​

min

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = N;
    L.length = 0;
 
}

void combine(Sqlist &La,Sqlist &Lb,Sqlist &Lc){
    Lc.pList = (ElemType*)malloc(sizeof(ElemType)*(La.length+Lb.length));
    Lc.listsize= La.length+Lb.length;
    Lc.length = 0;
    int i = 0; int j = Lb.length -1;
    while(i<La.length&&j>=0){
        if(La.pList[i]<Lb.pList[j]){
            Lc.pList[Lc.length]=La.pList[i];
            Lc.length++;
            i++;
        }
        else{
            Lc.pList[Lc.length]=Lb.pList[j];
            Lc.length++;
            j--;
        }
    }
    while(i<La.length){
        Lc.pList[Lc.length]=La.pList[i];
        Lc.length++;
        i++;
    }
    while(j>=0){
        Lc.pList[Lc.length]=Lb.pList[i];
        Lc.length++;
        j--;
    }
    free(La.pList);    
    free(Lb.pList);    
    La.length=Lb.length =0;
}   

void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
    printf("\n");
}
void value(Sqlist &L){
    L.length = N;
    for(int i= 0;i<L.length;i++){
        L.pList[i]=2*i;
    }
    print(L);

}
void value1(Sqlist &L){
    L.length = 5;
    for(int i= 0;i<L.length;i++){
        L.pList[i]=10-i;
    }
    print(L);

}
int main(){
    Sqlist La,Lb,Lc;
    initial(La);
    initial(Lb);
    value(La);
    value1(Lb);
    combine(La,Lb,Lc);

    print(Lc);



    return 0;
}

​

max

​
#include <stdio.h>
#include <malloc.h>

#define N 10
typedef int ElemType;

typedef struct Sqlist{
    int* pList;
    int length;
    int listsize;
}Sqlist;

void initial(Sqlist &L){
    L.pList = (ElemType*) malloc(sizeof(ElemType)*N);
    L.listsize = 15;
    L.length = 0;
 
}

void combine(Sqlist &La,Sqlist &Lb){
    int i = La.length-1; 
    int j = 0;
    int curlength = 0;
    while(j<Lb.length&&i>=0){//每次取max
        if(La.pList[i]>Lb.pList[j]){
            La.pList[La.listsize-curlength-1]=La.pList[i];
            curlength++;
            i--;
        }
        else{
            La.pList[La.listsize-curlength-1]=Lb.pList[j];
            curlength++;
            j++;
        }
    }
    // while(i>=0){//A表剩余不用动
    //     La.pList[La.listsize-curlength-1]=La.pList[i];
    //     Lc.length++;
    //     i--;
    // }    
    while(j<Lb.length){
        La.pList[La.listsize-curlength-1]=Lb.pList[j];
        curlength++;
        j++;
    }
    La.length+=Lb.length;
    Lb.length= 0;

}   

void print(Sqlist L){
    for(int i = 0;i<L.length;i++){
        printf("%d ",L.pList[i]);
    }
    printf("\n");
}
void value(Sqlist &L){
    L.length = N;
    for(int i= 0;i<L.length;i++){
        L.pList[i]=2*i;
    }
    print(L);

}
void value1(Sqlist &L){
    L.length = 5;
    for(int i= 0;i<L.length;i++){
        L.pList[i]=10-i;
    }
    print(L);

}
int main(){
    Sqlist La,Lb;
    initial(La);
    initial(Lb);
    value(La);
    value1(Lb);
    combine(La,Lb);
    print(La);



    return 0;
}

​

insertsort

​
#include <iostream>


// 假设 ElemType 是 int 类型
typedef int ElemType;

// 定义 Sqlist 结构
struct Sqlist {
    ElemType *pList;
    int length;
};

// 插入排序算法
void insertsort(int r, Sqlist &L) {
    int insertIndex = r; // 待排序
    while (insertIndex < L.length) {
        int i = insertIndex - 1; // 排好序的最后一个元素
        ElemType e = L.pList[insertIndex];
        while (i >= 0) {
            if (L.pList[i] <= e) { // 找到插入位置
                break;
            }
            L.pList[i + 1] = L.pList[i];
            i--;
        }
        L.pList[i + 1] = e;
        insertIndex += 1;
    }
}

int main() {
    // 创建一个包含递增和递减元素的 Sqlist 结构
    ElemType arr[] = {1, 2, 3, 7, 6, 5, 4};
    int r = 3; // 前3个元素递增有序
    int n = 7; // 总共有7个元素

    Sqlist L;
    L.pList = arr;
    L.length = n;

    // 输出排序前的数组
    std::cout << "排序前的数组：";
    for (int i = 0; i < n; i++) {
        std::cout << L.pList[i] << " ";
    }
    std::cout << std::endl;

    // 调用插入排序算法
    insertsort(r, L);

    // 输出排序后的数组
    std::cout << "排序后的数组：";
    for (int i = 0; i < n; i++) {
        std::cout << L.pList[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

​

交集算法

#include <iostream>

// 假设 Sqlist 是如下定义的结构
struct Sqlist {
    int *pList; // 顺序表的指针
    int length; // 顺序表的长度
};

// 交集函数的定义
void intersection(Sqlist& La, Sqlist Lb) {
    int curlength = 0;
    int i = 0;
    int j = 0;
    while (i < La.length && j < Lb.length) {
        if (La.pList[i] < Lb.pList[j]) {
            i++;
        } else if (Lb.pList[j] < La.pList[i]) {
            j++;
        } else {
            if (curlength == 0 || La.pList[curlength - 1] != La.pList[i]) {
                La.pList[curlength++] = La.pList[i];
            }
            i++;
            j++;
        }
    }
    La.length = curlength;
}

int main() {
    // 创建两个非递减顺序表
    Sqlist La;
    Sqlist Lb;

    // 假设你已经为 La 和 Lb 分配了内存，并将数据存入顺序表中
    // 以下是示例数据，你可以根据需要修改
    int dataLa[] = {1, 3, 5, 7, 9};
    int dataLb[] = {3, 5, 7, 8, 10};
    
    La.pList = dataLa;
    La.length = sizeof(dataLa) / sizeof(int);
    
    Lb.pList = dataLb;
    Lb.length = sizeof(dataLb) / sizeof(int);

    // 输出原始数据
    std::cout << "顺序表 La: ";
    for (int i = 0; i < La.length; i++) {
        std::cout << La.pList[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "顺序表 Lb: ";
    for (int i = 0; i < Lb.length; i++) {
        std::cout << Lb.pList[i] << " ";
    }
    std::cout << std::endl;

    // 调用交集函数
    intersection(La, Lb);

    // 输出交集结果
    std::cout << "交集为: ";
    for (int i = 0; i < La.length; i++) {
        std::cout << La.pList[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

差集算法

#include <iostream>


struct Sqlist {
    int *pList; // 顺序表的指针
    int length; // 顺序表的长度
};


void exception(Sqlist La, Sqlist Lb, Sqlist& Lc) {
    int i = 0;
    int j = 0;
    while (i < La.length && j < Lb.length) {
        if (La.pList[i] < Lb.pList[j]) {
            Lc.pList[Lc.length] = La.pList[i];
            Lc.length++;
            i++;
        } else if (Lb.pList[j] < La.pList[i]) {
            Lc.pList[Lc.length] = Lb.pList[j];
            Lc.length++;
            j++;
        } else {
            i++;
            j++;
        }
    }
    while (i < La.length) {
        Lc.pList[Lc.length] = La.pList[i];
        Lc.length++;
        i++;
    }
    while (j < Lb.length) {
        Lc.pList[Lc.length] = Lb.pList[j];
        Lc.length++;
        j++;
    }
}

int main() {
    // 创建三个升序顺序表表示集合 La、Lb 和 Lc
    Sqlist La;
    Sqlist Lb;
    Sqlist Lc;

    // 填充集合 La 和 Lb 的数据，假设已经按升序排列
    int dataLa[] = {1, 3, 7, 8};
    int dataLb[] = {3, 6, 8,10};

    La.pList = dataLa;
    La.length = sizeof(dataLa) / sizeof(int);

    Lb.pList = dataLb;
    Lb.length = sizeof(dataLb) / sizeof(int);

    // 为集合 Lc 分配足够的内存空间
    Lc.pList = new int[La.length];
    Lc.length = 0;

    // 调用求差集函数
    exception(La, Lb, Lc);

    // 输出差集结果
    std::cout << "差集为: ";
    for (int i = 0; i < Lc.length; i++) {
        std::cout << Lc.pList[i] << " ";
    }
    std::cout << std::endl;

    // 释放内存
    delete[] Lc.pList;

    return 0;
}

循环左移

逆置顺序表实现

#include <iostream>


struct Sqlist {
    int *pList; // 顺序表的指针
    int length; // 顺序表的长度
};

// 逆置顺序表的函数
void reverse(Sqlist &L, int low, int high) {
    while (low < high) {
        int e = L.pList[low];
        L.pList[low] = L.pList[high];
        L.pList[high] = e;
        low++;
        high--;
    }
}

// 循环左移顺序表的函数
void leftShift(Sqlist &L, int r) {
    int n = L.length;
    if (n == 0 || r <= 0 || r >= n) {
        return; // 无需移动
    }
    
    reverse(L, 0, n - 1);        // 全部逆置
    reverse(L, 0, n - r - 1);   // 逆置前半部分
    reverse(L, n - r, n - 1);   // 逆置后半部分
}

int main() {
    Sqlist L;
    
    // 填充顺序表的数据，假设已经分配内存和初始化
    int data[] = {1, 2, 3, 4, 5};
    L.pList = data;
    L.length = sizeof(data) / sizeof(int);
    
    int r = 2; // 左移的位数
    
    // 调用循环左移函数，使用引用传递
    leftShift(L, r);
    
    // 输出左移后的顺序表
    std::cout << "左移后的顺序表: ";
    for (int i = 0; i < L.length; i++) {
        std::cout << L.pList[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}
丰川祥子
关注
SqList.cpp
06-27
(1) void InitList(SqList &L, int n) //建立一个表长为n的顺序表 (2) void ListInsert(SqList &L, int i, ElemType e) //在顺序表中第i个位置插入元素函数e (3) void ListDelete(SqList&L, int i, ElemType &e) //...
sqlist（C++）.rar
03-11
标题 "sqlist（C++）.rar" 暗示我们正在处理一个使用 C++ 编程语言实现的单链表（singly linked list）数据结构。从描述中没有获得更多的信息，但我们可以根据文件名推测`sqlist_main.cpp`是主程序文件，而`sqlist.h...
Sqlist
weixin_52653118的博客
09-19 321
顺序表**
SQList
qq_44834369的博客
04-10 1740
线性表的顺序实现/动态数组(C语言实现) /** * 线性表的顺序实现 * 逻辑关系上相邻的两个元素物理上也相邻 * 优点在于可以随机存取 * 缺点在于插入或删除元素需要移动大量的元素 */ /*导入必要的头文件*/ #include "stdlib.h" //malloc, realloc #include "stdio.h" //printf, scanf /*通用的定义*/ #define TR
SqList
qq_43981607的博客
09-22 1421
以后每天都要坚持 不可一日间断！ #include<stdio.h> #include<stdlib.h> #include<algorithm> using namespace std; #define INIT_SIZE 20 #define ADD_SIZE 10 typedef struct { int *elem; int count; ...
sqlist
m0_63957897的博客
08-31 63
在无序表中删除值在s和t之间的所有元素 【过滤算法】非递减顺序表中删除值在s和t之间的元素 【偏移法】删除最小元素，空位由最后一个元素填补。
c语言sqlist结构体,c语言里 sqlist
weixin_35908791的博客
05-22 3025
满意答案cielkong2018.08.12采纳率：43%等级：9已帮助：463人c语言里 sqlist？//定义顺序表L的结构体typedef struct{Elemtype data[MaxSize]；int length;}SqList;//建立顺序表void CreateList(SqList * &L,ElemType a[ ],int n){int i;L = (SqL...
关于被调函数形参：SqList L、SqList &L、SqList *L 的区别
热门推荐
一个搬运知识的笨小孩
07-23 1万+
C语言中没有引用，只有取地址& C++语言中有引用&，也有取地址& （引用就是给变量起别名，对别名的操作就是对原变量的操作） 首先要明白的两点： 对顺序表的取值、查找操作，不需要对表内数据元素进行修改 对顺序表的初始化、插入、删除操作，需要对表内数据元素进行修改 1.某函数不需要对表内数据元素进行修改时，形参就使用 SqList L 对顺序表的取值操作 Status GetElem(SqList L,int i,ElemType *e) //此函数没有对L作出改动，使用普通类型
c语言sqlist头文件,C语言实现顺序表的基本操作
weixin_36459547的博客
05-23 2631
数据结构C语言实现顺序表的基本操作2009-09-19 11:42:39| 分类： C语言实现数据结 |字号 订阅头文件Sqlist1.h#include#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW 0#define LIST_INIT_SIZE 10//线性表存储...
SQList数据库存储
qq_53911070的博客
04-03 337
创建SQList数据库：创建一个类继承SQListOpenHelper类，并重写该类的构造方法inCreate() onUpgrade() 通过super()调用父类SQLiteOpenHelper的构造方法，并传入4个参数 ：上下文对象、数据库名称、游标【一般是null】、数据库版本 重写之后还要调用？ ...
数据结构——顺序表（SqList）
m0_73513334的博客
06-23 581
【代码】数据结构——顺序表（SqList）
java中的sqlist,JAVA连接SQList数据库 | 学步园
weixin_42393342的博客
03-09 462
文件式数据库是一种很特别的数据库。因为他们没有网络接口，通常不可以分布式调用。但是他们有很巨大的优点，如果用于数据的配置和数据的缓存就可以提高软件的效率。这么多种的文件数据库，我比较青睐SQList，1、是一个稳定的数据库；2、不分数据类型，减少开发时候遇到数据类型的转换；3、比access等其他文本数据更加稳定；sqlitejdbc-v056.jar：www.sqlite.org下载下面是一些...
0201_SqList.zip
06-27
《线性表与顺序存储结构—— SqList 数据结构解析》 在计算机科学中，数据结构是组织、管理和处理数据的方式，它是算法设计的基础。本文将深入探讨一种常见且基础的数据结构——线性表（Linear List），以及其在...
sqlist.zip
12-27
在Linux环境下编译这段代码，遵循描述中的方法，即运行`gcc sqlist.h sqlist.c main.c -o sqlist`，编译器会生成名为`sqlist`的可执行文件。执行这个文件，我们就可以在控制台看到顺序表的操作结果，验证其功能是否...
SQList 数据库
03-01
【SQList 数据库】 在计算机领域，数据库是用于存储、管理、检索数据的重要工具，而SQList数据库是一种基于SQLite的数据管理解决方案。SQLite是一款轻量级的、开源的关系型数据库管理系统，广泛应用于移动设备、...
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 442
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1289
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 210
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 275
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
SQlist java
09-20
SQlist java 是指使用Java语言操作SQL数据库。在Java中，可以通过使用JDBC（Java Database Connectivity）来连接和操作SQL数据库。首先，需要使用JDBC的API来连接到数据库。可以使用如下代码来建立与数据库的连接： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值