笔记：数据结构

线性表

一、顺序表

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 单链表——删除