线性表及其应用C语言实现（数据结构复习最全笔记）

一、顺序表的表示与实现

1.线性表的顺序结构定义

#define LIST_INIT_SIZE  100 //线性表存储空间的初始分配量
#define LISTINCREMENT   10 //线性表存储空间的分配增量
typedef struct
{
    ElemType* elem;   //存储空间基地址
    int length;       //表中元素的个数（表长）
    int listsize;     //表容量大小（以sizeof（ElemType）为单位）
} SqList;   //顺序表类型定义

2.顺序表的初始化（构建空的线性表）

Status InitList_Sq(SqList &L){
  //初始化L为一个空的有序顺序表
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!L.elem)
        exit(OVERFLOW);//存储分配失败
    L.listsize = LIST_INIT_SIZE;//初始存储容量
    L.length = 0;//空表长度为0
    return OK;
}

3.顺序表的插入操作

Status ListInsert_Sq(SqList &L, int pos, ElemType e)
{
    ElemType *newbase;
    if(pos>=1&&pos<=L.length+1)//注意这个范围
    {
        if(L.length>=L.listsize)//此时要扩容
        {
            newbase = (ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
            if(!newbase)
                return ERROR;
            L.elem = newbase;//新分配空间的基地址
            L.listsize+=LISTINCREMENT;
        }
        //即将进行插入操作
        ElemType *p,*q;
        p = &(L.elem[pos-1]);//将原来pos位置元素的地址分配给指针p，即p为插入位置
        for(q = &(L.elem[L.length-1]);q>=p;--q)
            *(q+1) = *q;//将原来顺序表最后一个位置数据的地址分配给q，然后从后往前依次将数据向后移动一位
        *p = e;
        ++L.length;
        return OK;
    }
    else
        return OVERFLOW;
}

4.顺序表的删除操作


Status ListDelete_Sq(SqList &L, int pos, ElemType &e)
{
    if(pos>=1&&pos<=L.length)//注意范围
    {
        ElemType *p;
        e = L.elem[pos-1];//先将e赋值，也就是返回删掉了哪个数,因为要返回引用
        for(p = &(L.elem[pos-1]);p<=&(L.elem[L.length-1]);p++)
            *p = *(p+1);
        --L.length;
        return OK;
    }
    else
        return OVERFLOW;
}

5.顺序表的查找操作

int ListLocate_Sq(SqList L, ElemType e)
{
    int a = -1;//给a赋初值，无论查找的数据在第几个，都不可能是第-1个，所以赋值-1
    for(int i = 0;i<=L.length-1;i++)
    {
        if(L.elem[i] == e)
        {
            a = i;
            break;
        }
    }
    if(a>=0&&a<=L.length-1)
        return a+1;
    else
        return ERROR;
}

6.顺序表常见的输出函数

void ListPrint_Sq(SqList L)
{
    ElemType *p = L.elem;//遍历元素用的指针
    for(int i = 0; i < L.length; ++i){
        if(i == L.length - 1){
            printf("%d", *(p+i));
        }
        else{
            printf("%d ", *(p+i));
        }
    }
}

7.顺序表的就地逆置

void ListReverse_Sq(SqList &L)
{
    int tmp;
    //int n;
    for(int i = 0;i< n/2;i++)
    {
        tmp = L.elem[i];
        L.elem[i]=L.elem[n-i-1];
        L.elem[n-i-1] = tmp;
    }
}

8.顺序表的合并

<1>顺序表的无序合并

SqList bingji(SqList &S1,SqList &S2)
{
    SqList S;
    SqListInit(S);
    int i,j;
    for(i = 0;i<S1.length;i++)
    {
        S.elem[i] = S1.elem[i];
        S.length++;
    }
    for(j=0;j<S2.length;j++)
    {
        int flag = 1;
        for(int k = 0;k<S.length;k++)
        {
            if(S2.elem[j] == S.elem[k])
            {
                flag = 0;
                break;
            }
        }
        if(flag)
        {
            S.elem[i++] = S2.elem[j];
            S.length++;
        }
    }
    return S;

}

<2>顺序表的有序合并（升序）

void MergeList_sq(SqList La,SqList Lb,SqList &Lc)
{
    //实现代码
    pa = La.elem;pb = Lb.elem;
    Lc.listsize = Lc.length = La.length+Lb.length;
    pc = Lc.elem = (ElemType*)malloc(Lc.listsize*sizeof(ElemType));
    if(!Lc.elem)
        exit(OVERFLOW);
    pa_last = La.elem + La.length - 1;
    pb_last = Lb.elem + Lb.length - 1;
    while(pa<=pa_last&&pb<=pb_last)
    {
        if(*pa<=*pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    while(pa<=pa_last)
        *pc++ = *pa++;
    while(pb<=pb_last)
        *pc++ = *pb++;
    /*
    //算法大致代码
    InitList(Lc);
    i = j =1;k = 0;
    La_len = ListLength(La);
    Lb_Len = ListLength(Lb);
while(i<=La_len&&j<=Lb_len)
{
    GetElem(La,i,ai);GetElem(Lb,j,bj);
    if(ai<=bj)
    {
        ListInsert(Lc,++k,ai);
        i++;
    }
    else
    {
        ListInsert(Lc,++k,bj);
        j++;
    }
}
while(i<=La_len)
{
    GetElem(La,i,ai);
    ListInsert(Lc,++k,ai);
}
while(j<=Lb_len)
{
    GetElem(Lb,j,bj);
    ListInsert(Lc,++k,bj);
}
    */
}

<2>（单）链表的表示与实现

1.单链表的链式结构定义

typedef struct LNode
{  
    ElemType data;  //数据域
    struct LNode *next; //指针域
}LNode,*LinkList; //循环单链表类型定义与单链表定义相同，区别在尾节点next取值

2.单链表的读取操作（获取第i个元素位置）

Status GetElem(LinkList &L,int i,ElemType &e)
{
    LinkList p = L->next;//p指向第一个结点
    int j = 1;//计数器j
    while(p&&j<i)
    {
        p = p->next;//就是遍历，往后挪
        j++;
    }
    if(j>i||!p)
        return 0;
    e = p->data;
    return OK;
}

3.单链表的插入操作

Status LinkListInsert(LinkList &L,int pos,ElemType e)
{
    LinkList p = L->next,s;
    int j = 1;
    while(p&&j<pos-1)
    {
        p = p->next;
        j++;
    }
    if(!p&&j>pos-1)
        return 0;
    s = (LinkList)malloc(sizeof(LNode));
    s->data = e;
    s->next =p->next;//这两部是插入操作的核心
    p->next =s;
    return 1;
}

4.单链表的删除操作

Status ListDelete(LinkList &L,int i,ElemType &e)
{
    LinkList p = L->next,q;
    int j = 1;
    while(p&&j<i-1)
    {
        p = p->next;
        j++;
    }
    if(!p||j>i-1)
        return 0;
    q = p->next;//这两步是删除操作的核心
    p->next = q->next;
    e = q->data;
    free(q);//别忘了free
    return 1;
}

5.单链表的求表长操作

Status ListLength(LinkList &L)
{
    LinkList p = L->next;
    int j = 0;
    while(p)
    {
        p = p->next;
        j++;
    }
    return j;
}

6.单链表常用打印操作

void ListPrint(LinkList &L)
{
    LinkList p = L->next;//p指向第一个元素结点
    int flag = 1;
    while(p!=NULL)
    {
        if(flag)
        {
            cout<<p->data;
            flag = 0;
        }
        else
        {
            cout<<" "<<p->data;
        }
        p = p->next;
    }
    cout<<endl;
}

7.单链表的判空操作

Status JudgeEmpty(LinkList &L)
{
    LinkList p = L->next;
    if(p)
        return false;
    else
        return true;
}

8.单链表的元素定位操作

Status ListLocate(LinkList &L,ElemType e)
{
    LinkList p = L->next;
    int j = 1;
    while(p&&e!=p->data)
    {
        p = p->next;
        j++;
    }
    if(!p)
        return 0;
    else
        return j;
}

8.单链表常用free函数

void ListFree(LinkList &L)//最好自己写free函数
{
    LinkList p = L->next;
    //LinkList rear;
    //rear = L;
    while(p)
    {
        free(p);
        //rear = p;
        p = p->next;
    }
    free(p);
}

9.单链表的整表创建

a.头插法

Status ListCreate_CL(LinkList &CL，int n)
{
    LinkList p;
    int i;
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = 0;i<n;i++)
    {
        p = (LinkList)malloc(sizeof(LNode));
        scanf("%d",&p->data);
        p->next = L->next;
        L->next = p;//插入到表头
    }
}

b.尾插法（正常思路，最常见）（两种）

Status ListCreate_L(LinkList &L,int n)
{
    LinkList rear,p;   //一个尾指针，一个指向新节点的指针
    L=(LinkList)malloc(sizeof (LNode));
    if(!L)exit(OVERFLOW);
    L->next=NULL;               //先建立一个带头结点的单链表
    rear=L;  //初始时头结点为尾节点,rear指向尾巴节点
    for (int i=1;i<=n;i++){  //每次循环都开辟一个新节点，并把新节点拼到尾节点后
        p=(LinkList)malloc(sizeof(LNode));//生成新结点
        if(!p)exit(OVERFLOW);
        scanf("%d",&p->data);//输入元素值
        p->next=NULL;  //最后一个节点的next赋空
        rear->next=p;
        rear=p;
    }
    return OK;
}

//或者

Status ListCreate_CL(LinkList &CL)
{
    CL = (LinkList)malloc(sizeof(LNode));
    //LinkList head = CL;
    LinkList rear = CL;
    rear->next = NULL;
    int t;
    while(cin>>t&&t!=-1)
    {
        LinkList p = (LinkList)malloc(sizeof(LNode));
        p->data = t;
        rear->next = p;//把p插入尾部,指针移到最后
        rear = p;//数值移到最后
    }
    rear->next = NULL;//让最后的尾指针指向NULL，否则链表创建无法停止
    return 0;
}

10.单链表的整表删除

算法思路：

声明两个结点p和q

将第一个结点赋值给p

循环：

将下一个结点赋值给q

释放p

将q赋值给p

Status ClearList(LinkList &L)
{
    LinkList p = L->next,q;
    while(p)
    {
        q = p->next;
        free(p);
        q = p;
    }
    L->next = NULL;
    return OK;
}

11.单链表的就地逆置（较难）

算法思想：逆置链表初始为空，表中节点从原链表中依次“删除”，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的“新”的第一个结点，如此循环，直至原链表为空。

void ListReverse_L(LinkList &L)//L为头结点
{
    LinkList p,q;
    p = L->next;
    L->next = NULL;
    while(p)
    {
        //向后挪
        q = p;//
        p = p->next;
        //头插
        q->next = L->next;//非常重要，相当于p和q之间没有了指针连接
        L->next = q;//把q接到头的后面
    }
}

详细图解参考一位大佬的文章：https://blog.csdn.net/v_xchen_v/article/details/53067448

12.单链表的合并

void merge(LinkList La,LinkList Lb,LinkList &Lc){
    LinkList pa,pb,pc;
    pa=La->next;pb=Lb->next;
    Lc=pc=La;
    while(pa&&pb){
        if(pa->data<=pb->data){
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else{
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
    }
    pc->next=pa?pa:pb;
    free(Lb);
}

13.单链表的递归创建

Status ListCreate_L_Rec(LinkList &L,int n)
{
//递归边界：创建空表时只需将L赋空即可；
//递归关系：创建非空表时，将链表看做两部分：首元素组成的子表La， 第二个元素及其后元素构成的子表Lb。
//子表La容易创建(只需开辟一个节点)
//子表Lb由于规模小可以递归创建完成（类似数学归纳法的假设，只要小的都可以建设能完成）
//最后将两个子表拼接即可。
  LNode *La, *Lb;
  if(n==0) L=NULL;
  else{
    La=(LNode *)malloc(sizeof(LNode));  //开辟子表La
    if(!La) exit(OVERFLOW);
    scanf("%d",&La->data);
    ListCreate_L_Rec(Lb,n-1 ); //递归创建子表Lb
    La->next = Lb;  //两个子表拼结
    L=La;  //第一个子表的地址赋给L。请思考为什这样处理不会使得主函数中的L取错值？
  }
  return OK;
}

14.单链表的递归输出

方法1：递归法

void ListPrint_L_Rec(LinkList L)
{
    if(!L)
        return;
    printf(" %d",L->data);
        ListPrint_L_Rec(L->next);
        return;
}

方法2：直接输出法

void ListPrint_L_Rec(LinkList L)
{
    LinkList p = L;
    //int flag = 1;
    while(p)
    {
        //int flag = 1;
            printf(" %d",p->data);
        p = p->next;
    }
    printf("\n");
}

之后还会更新静态链表，循环链表，双向链表的笔记。

如果哪里代码有问题欢迎指正

线性表及其应用C语言实现（数据结构复习最全笔记）

猜你喜欢