【数据结构】顺序表定义和基本操作

最新推荐文章于 2023-12-08 19:03:39 发布
最新推荐文章于 2023-12-08 19:03:39 发布
阅读量3.6k 收藏 31
点赞数 9
分类专栏： 数据结构 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z_sea/article/details/84956372
版权

线性表主要两种结构：

顺序存储  和  链式存储：

这次写的顺序表，指的是线性表的顺序存储模式；

定义类型：

#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

（1）、初始化操作：InitSqList ( &L ) 

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

（2）、判断是否为空表 ListIsEmpty（L）

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

（3）、求顺序表的长度ListLength（L）

int ListLength(Sqlist &L){
    return L.length;
}

 （4）、取顺序表中的第i个元素GetElem（L,i,&e）

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

（5）、查找元素e在线性表中的位序LocateElem（L，e）

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

（6）、插入操作ListInsert（&L，i，e）

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

（7）、删除操作ListDelete（&L，i，&e）

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}

 

调试代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

int ListLength(Sqlist &L){
    return L.length;
}

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}

int main()
{
    Sqlist L;
    InitSqList(L);
    int n,x;
    printf("input n : \n");
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",&x);
        ListInsert(L,L.length+1,x);
    }
    ListDelete( L , L.length/2);
    for(int i=0;i<L.length;i++){
        int e,pos;
        GetElem(L,i+1,e);
        pos=LocateElem(L,e);
        printf("序列中第%d个位： %d\n",pos,e);
    }
    return 0;
}

 

以上就是线性表-顺序表的基本操作：

7个函数其中有2个其实没有用，因为线性表里面都需要这个函数，所以才出现的。

判断是否为空表，判断是否线性表的长度。

因为只要知道L.length的大小就可以。

 

例题2-1：将两个按值递增有序的线性表La和Lb合并成一个按值递增有序的线性表Lc,

假设La=(5,9,18,25),Lb=(6,9,12,18,24,39)，则Lc=(5,6,9,9,12,18,18,24,25,39)

 

思路：因为两个线性表都是递增有序的，然后用两个标志位放在两个线性表的前面。

不断移动两个标志位，一直比较，组成一个递增的，最后如果有哪一个剩下来的直接接上去即可。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

int ListLength(Sqlist &L){
    return L.length;
}

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}
void ListOutput(SqList &L){
    for(int i=0;i<L.length;i++){
        printf("%d%c",L.base[i],i==L.length-1?'\n':' ' );
    }
}
int a[]={5,9,18,25};
int b[]={6,9,12,18,24,39};
void MergeList(SqList La,SqList Lb,SqList &Lc)
{
    int ia,ib,ta,tb,cnt=0,k=0;
    ia=ib=1;
    while( ia<=ListLength(La) && ib<=ListLength(Lb) ){
        GetElem(La,ia,ta);
        GetElem(Lb,ib,tb);
        if(ta<=tb){
            ListInsert(Lc,++k,ta);
            ia++;
        }else{
            ListInsert(Lc,++k,tb);
            ib++;
        }
    }
    while(ia<=ListLength(La)){
        GetElem(La,ia,ta);

        ListInsert(Lc,++k,ta),ia++;
    }
    while(ib<=ListLength(Lb)){
        GetElem(Lb,ib,tb);
        ListInsert(Lc,++k,tb),ib++;
    }
}
int main()
{
    Sqlist La,Lb,Lc;
    InitSqList(La);
    InitSqList(Lb);
    InitSqList(Lc);
    for(int i=0;i<4;i++){
        ListInsert(La,La.length+1,a[i]);
    }
    ListOutput(La);
    for(int i=0;i<6;i++){
        ListInsert(Lb,Lb.length+1,b[i]);
    }
    ListOutput(Lb);
    MergeList(La,Lb,Lc);
    ListOutput(Lc);
}

 

例题2-2 将两个顺序表合并成一个顺序表，请设计算法实现之

(1)、表中元素有序 ——SetMerge

(2)、表中元素无序——SetUnion     /    SetUnion_diff

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

int ListLength(Sqlist &L){
    return L.length;
}

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}
void ListOutput(SqList &L){
    for(int i=0;i<L.length;i++){
        printf("%d%c",L.base[i],i==L.length-1?'\n':' ' );
    }
}
int a[]={5,9,18,25};
int b[]={6,9,12,12,18,24,39};
void SetMerge(SqList La,SqList Lb,SqList &Lc)
{
    int Len_C=La.length+Lb.length+10;
    // 因为可能访问length_c+1的位置，防止越界加10
    InitSqList(Lc,Len_C);
    int ia,ib,ta,tb,cnt=0,k=0;
    ia=ib=1;
    while( ia<=ListLength(La) && ib<=ListLength(Lb) ){
        GetElem(La,ia,ta);
        GetElem(Lb,ib,tb);
        if(ta<=tb){
            ListInsert(Lc,++k,ta);
            ia++;
        }else{
            ListInsert(Lc,++k,tb);
            ib++;
        }
    }
    while(ia<=ListLength(La)){
        GetElem(La,ia,ta);

        ListInsert(Lc,++k,ta),ia++;
    }
    while(ib<=ListLength(Lb)){
        GetElem(Lb,ib,tb);
        ListInsert(Lc,++k,tb),ib++;
    }
}
void SetUnion(SqList &La, SqList Lb){//就地处理
// 设两个顺序表La和Lb中的元素无序,将这个表合并成一个表
// 假设La表的存储空间足够大
    int Len_a=La.length,i,j;
    for(j=0;j<Lb.length ;j++){
        for(i=0;i<Len_a;i++){
            if(La.base[i]==Lb.base[j]){
                break;
            }
        }
        if(i>=Len_a){
            La.base[Len_a++]=Lb.base[j];
        }
    }
    La.length=Len_a;
}
void SetUnion_diff(SqList La, SqList Lb,SqList &Lc){//异地处理
// 设两个顺序表La和Lb中的元素无序,将这个表合并成一个表

    int Len_c=La.length+Lb.length+2,i,j;
    InitSqList(Lc,Len_c);
    Len_c=La.length;
    memcpy(Lc.base,La.base,sizeof(La.base)*La.length);
    ListOutput(Lc);
    for(j=0;j<Lb.length ;j++){
        for(i=0;i<Len_c;i++){
            if(Lc.base[i]==Lb.base[j]){
                break;
            }
        }
        if(i>=Len_c){
            Lc.base[Len_c++]=Lb.base[j];
        }
    }
    Lc.length=Len_c;
}
int main()
{
    Sqlist La,Lb,Lc;
    InitSqList(La);
    InitSqList(Lb);
    for(int i=0;i<4;i++){
        ListInsert(La,La.length+1,a[i]);
    }
    printf("线性表La:  \n");
    ListOutput(La);
    for(int i=0;i<7;i++){
        ListInsert(Lb,Lb.length+1,b[i]);
    }
    printf("线性表Lb:  \n");
    ListOutput(Lb);

    printf("两个有序的线性表合并 : \n");
    SetMerge(La,Lb,Lc);
    ListOutput(Lc);

    printf("两个无序的线性表合并_去重后 集合(就地处理):  \n");
    SetUnion(La,Lb);
    ListOutput(La);

    printf("两个无序的线性表合并_去重后 集合(异地处理):  \n");
    SetUnion_diff(La,Lb,Lc);
    ListOutput(Lc);
    return 0;
}

 

例题2-3

顺序表L中的元素递增有序，请设计算法完成最少时间在表中查找数值为X的元素，
若找到将其雨后级元素位置相交换,若找不到将其插入表中元素仍递增有序。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

int ListLength(Sqlist &L){
    return L.length;
}

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}
void ListOutput(SqList &L){
    for(int i=0;i<L.length;i++){
        printf("%d%c",L.base[i],i==L.length-1?'\n':' ' );
    }
}
//顺序表L中的元素递增有序，请设计算法完成最少时间在表中查找数值为X的元素，
//若找到将其雨后级元素位置相交换,若找不到将其插入表中元素仍递增有序。
void SearchElement(SqList &L , LElemType x){
    LElemType Low=0,High=L.length-1,flag=0,mid;
    while(Low<=High&&!flag){
        mid=(Low+High)>>1;
        if(x<L.base[mid]){
            High=mid-1;
        }else if(x==L.base[mid]){
            flag=1;
        }else{
            Low=mid+1;
        }
    }
    if(flag){
        if(mid+1>=L.length){
            printf("值为x的元素为表中的最后一个元素，没有后继。\n");
        }else{
            LElemType temp=L.base[mid];
            L.base[mid]=L.base[mid+1];
            L.base[mid+1]=temp;
        }
    }else{
        int i;
        for(i=L.length-1;i>=Low&&L.base[i]>x;i--){
            L.base[i+1]=L.base[i];
        }
        L.base[i+1]=x;
        L.length++;
    }
}
int main()
{
    Sqlist L;
    InitSqList(L);
    int n,x;
    for(int i=0;i<5;i++){
        ListInsert(L,L.length+1,i*2);
    }
    ListOutput(L);
    printf("查找 “ 3 ” :\n");
    SearchElement(L,3);
    ListOutput(L);
    printf("查找 “ 4 ” :\n");
    SearchElement(L,4);
    ListOutput(L);
    return 0;
}

例题2-4：假设一组整数(包括正整数和负整数)存储在一个顺序表中,
请设计算法在O(n)的时间范围内将所有的负整数放在所有正整数的前面

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ListInitSize 100
#define ListIncrement 10
#define LElemType int

typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;

void InitSqList(SqList &L,LElemType InitSize = ListInitSize )
{
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}

int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}

int ListLength(Sqlist &L){
    return L.length;
}

void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}

int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}

void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}

void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}
void ListOutput(SqList &L){
    for(int i=0;i<L.length;i++){
        printf("%d%c",L.base[i],i==L.length-1?'\n':' ' );
    }
}
//假设一组整数(包括正整数和负整数)存储在一个顺序表中,
//请设计算法在O(n)的时间范围内将所有的负整数放在所有正整数的前面
void Divide(SqList &L ){
    int Low=0,High=L.length-1;
    LElemType tmp;
    tmp=L.base[Low];
    while(Low<High){
        while(Low<High&&L.base[High]>0){
            High--;
        }
        if(Low<High){
            L.base[Low]=L.base[High];
            Low++;
        }
        while(Low<High&&L.base[Low]<0){
            Low++;
        }
        if(Low<High){
            L.base[High]=L.base[Low];
            High--;
        }
    }
    L.base[Low]=tmp;

}
int main()
{
    Sqlist L;
    InitSqList(L);
    int n,x,sign=1;
    for(int i=1;i<=5;i++){
        sign=-sign;
        ListInsert(L,L.length+1,sign*i*2);
    }
    ListOutput(L);
    Divide(L);
    ListOutput(L);
    return 0;
}

例题2-5：设计算法，将顺序表中的所有元素就地逆置

例题2-5：设计算法，将顺序表中的所有元素就地逆置
#include<stdio.h
>#include<stdlib.h
>#include<string.h
>#define ListInitSize 100
#define ListIncrement 10
#define LElemType int
typedef struct Sqlist{
    LElemType *base;
    int length;
    int listsize;
}SqList;
void InitSqList(SqList &L,LElemType InitSize = ListInitSize ){
    L.base=new LElemType [ InitSize ] ;
    L.length=0;
    L.listsize=InitSize;
}
int ListIsEmpty(SqList L){
    return L.length==0?0:1;
}
int ListLength(Sqlist &L){
    return L.length;
}
void GetElem(SqList &L,int i,LElemType &e){
    if ( i<1 || i>L.length ) {
        printf("GetElem : Index error \n");
        return ;
    }
    e=L.base[i-1];
}
int LocateElem(SqList L , LElemType e ){
    int i = 0 ;
    while( i< L.length && e != L.base[i]){
        i++;
    }
    if(i==L.length){
        return 0;
    }
    return i+1;
}
void ListInsert( SqList &L , int pos , LElemType e ){
    int Tmp=L.listsize+ListIncrement;
    LElemType* tL;
    if(pos<1||pos>L.length+1){
        printf("insert index %d  .is illegal\n",pos);
        printf("error\n");
        return ;
    }
    if(L.listsize==L.length+1){
        tL=new LElemType[Tmp];
        memcpy(tL,L.base,sizeof(L.base));
        L.base=tL;
        delete []tL;
        L.listsize+=ListIncrement;

    }
    L.length++;
    for(int i=L.length-1;i>pos;i--){
        L.base[i]=L.base[i-1];
    }
    L.base[pos-1]=e;
    return ;
}
void ListDelete(Sqlist &L , int pos){
    if(pos<1||pos>L.length){
        printf("ListDelete index : %d illegal \n" , pos);
        return ;
    }
    for(int i=pos-1;i<L.length-1;i++){
        L.base[i]=L.base[i+1];
    }
    L.length--;
    return ;
}void ListOutput(SqList &L){
    for(int i=0;i<L.length;i++){
        printf("%d%c",L.base[i],i==L.length-1?'\n':' ' );
    }
}//设计算法：将顺序表中的所有元素就地逆置void ListReverse(SqList &L){
    int Low=0,High=L.length-1;
    while(Low<High){
        LElemType temp=L.base[Low];
        L.base[Low]=L.base[High];
        L.base[High]=L.base[Low];
        Low++;High--;
    }
}void Listreverse(SqList &L){
    for(int i=0;i<L.length/2;i++){
        LElemType temp=L.base[i];
        L.base[i]=L.base[L.length-1-i];
        L.base[L.length-1-i]=temp;
    }
}int main(){
    Sqlist L;
    InitSqList(L);
    int n,x,sign=1;
    for(int i=1;i<=5;i++){
        sign=-sign;
        ListInsert(L,L.length+1,sign*i*2);
    }
    ListOutput(L);
    Listreverse(L);
    ListOutput(L);
    return 0;
}

 

 

 

Z_sea
关注
  • 9
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
结构体Sqlist L与Sqlist &L的区别
weixin_43624310的博客
10-31 7962
结构体Sqlist L与Sqlist &L的区别 Sqlist &L只可用于c++中；其中&表示引用的意思，而在C中&只表示取址，因此C++中下列顺序表插入函数中的L实际就是原结构体 1.证明Sqlist &L就是k: bool ListInsert(SeqList &L,int i,ElemType e){ if(i<1||i>L.length+1) return false; if(L.length>=L.MaxSize) r
顺序表的定义
jinghang2000的博客
11-13 5099
1.顺序表的定义 顺序表——用顺序存储的方式实现线性表顺序存储 eg: A1-A2-A3-A4-A5 如果第一个位置是location(L)，那么第二个就是location(L)+数据元素大小 [sizeof(ElemType)可以查看数据元素大小] 2.顺序表的实现——静态分配 #define MaxSize 10 //定义最大长度 typedef struct { ElemType data[MaxSize]; //ElemType是数据类型 实际用可以换成int stru
顺序表中SqList &L，SqList L和SqList *L
最新发布
Erorrs的博客
12-08 1062
1、顺序表的&和 * 类似，作用相同，都是为了改变实参。而且顺序表的&和 * 的使用，与变量的使用是一致的。eg：void swap(int &a,int &b) 交换a和b的值。2、链表中的&L，L：指针变量，则在需要改变指针变量的值（即指针的地址时使用&L）
数据结构（单链表，顺序结构）
Kerryliuyue的博客
09-20 1115
//顺序表基本运算算法 #include <stdio.h> #include <malloc.h> #define MaxSize 50 typedef int ElemType; typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 } SqList; //顺序表的类型 void CreateList(SqList *&L,ElemType a[
数据结构*线性表*创建一个基础的的顺序表
cool_without_you的博客
09-24 1827
优点缺点1.顺序表无需为表示元素之间的逻辑关系而增减额外的存储空间2.可以快速的存储表中任意位置的元素1.插入和删除操作需要移动大量的元素、2.当线性表长度变化较大时，难以确定储存空间的容量3.造成存储空间的“破碎”插入和删除的时间复杂度：插入和删除操作耗费的时间主要来自于元素的移动，最小的是删除或插入在末尾，时间复杂度为O（1）。但是这并不可靠，时间复杂度平均来算就为：(1+n)/2这样来看时间复杂度还是O（n）。
数据结构-顺序表的基本操作
iGoogle.ink
06-27 1315
数据结构-顺序表的基本操作编译器使用的是 VC++6.0 创建和输出顺序表 顺序表删除 顺序表查询 顺序表删除 顺序表排序 顺序表有序插入 删除X到Y之间的元素 #include "stdio.h"#define listSize 20 //默认表容量20 typedef int List;typedef struct { List data[listSize]; //数组data用于
数据结构C语言完成顺序表基本操作
04-25
数据结构是计算机科学中的...总之，理解并能熟练地在C语言中实现顺序表的基本操作是学习数据结构的关键步骤。通过这个过程，你可以深入理解数据结构的工作原理，为未来更复杂的数据结构和算法的学习打下坚实的基础。
C++数据结构顺序表删除操作
08-26
根据给定的信息，本文将详细解释C++中顺序表数据结构的删除操作。顺序表是一种基本的数据结构，它通过连续的内存空间来存储元素。在本篇内容中，我们将探讨如何实现顺序表中的删除功能，并深入理解其背后的逻辑与...
数据结构顺序表操作示例
01-20
1. **顺序表定义**： - 顺序表由一个结构体定义，包含一个固定大小的数组`data`用于存储数据，以及一个整型变量`last`记录数组中最后一个元素的索引。在这个例子中，数组的最大大小是`maxsize`，定义为1024，数据...
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
PTA—C语言数据结构：顺序表.ppt
10-11
在IT领域，数据结构是计算机科学中的核心概念之一，它涉及到如何有效地组织和...通过学习和实践PTA上的这些题目，你可以深入理解顺序表的数据结构，提升C语言编程能力，并为更高级的数据结构和算法学习打下坚实基础。
顺序表的基本操作
weixin_64084604的博客
11-18 1684
顺序表的基本操作
数据结构-顺序表（SqList）
qq_54429049的博客
10-22 8699
数据结构-顺序表的设计与实现
数据结构之线性表—数组描述
whhcs的博客
08-29 923
TOC 定义 线性表（linear list）：零个或多个数据元素的有限序列。 线性表也称有序表（ordered list），它的每一个实例都是元素的一个有序集合。每一个实例的形式为（e0e_0e0​, e1e_1e1​, …, en−1e_n-_1en​−1​），其中n是有穷自然数，是线性表的长度或大小，eie_iei​是线性表的元素，i是元素eie_iei​的索引。 元素本身的结构与线性表的结构无关，在较复杂的线性表中，一个数据元素可以由若干个数据项组成。 当n = 0时，线性表称为空表；当n >
数据结构-顺序表（动态分配存储空间）
快乐的小小程序猿
09-21 1万+
#include <stdio.h> #include <malloc.h> #include <stdlib.h> /** * 数组空间动态分配 */ #define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值 #define ListIncrement 10 //分配增量 typedef struct { int...
数据结构代码大全（简单版）
热门推荐
guangjie2333的博客
01-09 1万+
数据结构代码大全（简单版） 顺序表创建，插入，删除，打印 #include "stdio.h" #include "stdlib.h" #define MAX_INIT_SIZE 100 #define LISTINCREMENT 10 typedef struct { int* elem; int length; int listsize; }SqList; void InitL...
数据结构1-顺序表的基础实现
华数云图小分队的博客
06-03 880
/静态数组#define MaxSize 10 //定义最大长度int length;}Sqlist;可以看到，我们使用了#define关键字定义了顺序表的最大长度MaxSize，这样可以方便地在代码中引用。然后，我们定义了一个结构体类型Sqlistdata和length，分别表示存储数据元素的数组和当前顺序表中元素的个数。
【数据结构】队列的应用-舞伴配对问题
Z_sea的博客
12-22 9091
舞会的舞伴配对问题： 某单位举办周末友谊舞会，在舞会上，男、女各自排成一队。舞会开始时，依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等，则较长的那一队中未配对者等待下一轮舞曲。假设初始男、女人数已经固定，舞会的轮数表示舞曲数。试模拟解决上述舞伴配对问题。 核心代码： void PartnerPairing(CQueue &amp;Qm,CQueue &amp;Qw,int R...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值