笔记:数据结构

线性表

一、顺序表

1.1 顺序表——定义

静态分配
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;
动态分配
#define InitMax 10
typedef struct{
    ElemType *data;
    int MaxSize;
    int length;
}SeqList;

1.2 顺序表——初始化

静态分配
void InitList(SqList &L){
    for(int i=0;i<MaxSize;i++){
        L.data[i]=0;
    }
    L.length=0;
}
动态分配
void InitList(SeqList &L){
    L.data=(ElemType*)malloc(InitSize*sizeof(ElemType));
    L.length=0;
    L.MaxSize=InitSize;
}

1.3 顺序表——增加长度

//增加动态数组的长度,增加长度为len
void IncreaseSize(SeqList &L,int len){
    int *p=L.data;
    L.data=(int*)malloc((L.MaxSize+len))*sizeof(int);
    for(int i=0;i<MaxSize;i++){
        L.data[i]=p[i];
    }
    L.MaxSize=L.MaxSize+len;
    free(p);
}

1.4 顺序表——插入

//在表L中的第i个位置/下标为i-1处插入指定元素e
void ListInsert(SqList &L,int i,int e){
    for(int j=L.length;j>i;j--){			//从后面的元素依次移动
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return true;
}
//bool类型实现插入操作——具有健壮性
bool ListInsert(SqList &L,int i,int e){
    if(i<1||i>L.length+1)
        return false;
    if(L.length>=MaxSize)
        return false;
    
    for(int j=L.length;j>i;j--){
        L.data[j]=L.data[j-1];
    }
    L.data[i-1]=e;
    L.length++;
    return true;
}

1.5 顺序表——删除

//删除表L中第i个位置的元素,并用e返回删除元素的值
void ListDelete(SqList &L,int i,int &e){
    if(i<1||i>L.length)
        return false;
    e=L.data[i-1];
    for(int j=i;j<L.length;j++){			//从前面的元素依次移动
        L.data[j-1]=L.data[j];
    }
    L.length--;
    return true;
}

1.6 顺序表——查找

按位查找
//查找表L中第i个位置的元素
ElemType GetElem(SqList &L,int i){
    return L.data[i-1];
}
按值查找
//查找表L中值为e的元素的位置
int LocateElem(SqList &L,ElemType e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e)
            return i-1
    }
    return 0;			//查找失败,退出循环返回0
}
//int、char、float等可直接比较,但若e为结构类型,需定义一个比较函数
bool isCustomerEqual(Customer a,Customer b){
    if(a.num==b.num&&a.people==b.people)
        return true;
    else
        return false;
}

二、单链表

2.1 单链表——定义

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

2.2 单链表——初始化

不带头结点
bool InitList(LinkList &L){
    L=NULL;
    return true;
}
带头结点
//带头结点的链表,操作更方便
bool InitList(SqList &L){
    L=(LNode*)malloc(sizeof(LNode));
    if(L==NULL)			//内存不足,分配失败
        return false;
    L->next=NULL;
    return true
}

2.3 单链表——插入

按位序插入(不带头结点)
//在表L中的第i个位置上插入元素e
bool ListInit(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    if(i==1){									//比带头结点多考虑插入第一个结点的情况
        LNode *s=(LNode*)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;
        return true;
    }
    
    LNode *p;				
    int j=1;			//不带头结点的单链表,设第一个结点下标为1(位置对应下标)
    p=L;
    while(p!=NULL&&j<i-1){			//p指向第i-1个结点,连接新结点到第i个位置
        p=p->next;
        j++;
    }
    if(p==NULL)			//插入位置不合法,可能i值过大
        return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
按位序插入(带头结点)
bool ListInit(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;			//带头结点的单链表,设头结点下标为0,使第一个结点下标为1(位置对应下标)
    p=L;
    while(p!=NULL&&j<i-1){			//p指向第i-1个结点,连接新结点到第i个位置
        p=p->next;
        j++;
    }
    if(p==NULL)			//插入位置不合法,可能i值过大
        return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
后插操作
bool InsertNextNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)			//内存分配失败,可能内存不足
        return false;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}
//用“封装”在第i个位置插入元素e也可以化简为
bool ListInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++
    }
    return InsertNextNode(p,e);
}
前插操作
//新结点后插操作,交换两结点数据
//p结点前插入元素e
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *s=(LNode)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->next=p->next;
    p->next=s;
    s->data=p->data;
    p->data=e;
    return true
}
//p结点前插入结点s
bool InsertPriorNode(LNode *p,LNode *s){
    if(p==NULL||s==NULL)
        return false;
    s->next=p->next;
    p->next=s;
    ElemType temp=s->data;			//引入temp交换数据域部分
    s->data=p->data;
    p->data=temp;
    return true;
}

2.4 单链表——删除

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值