王道数据结构源码实战ch2线性表（顺序表+单链表+双链表）

已于 2022-02-22 07:48:01 修改
阅读量625 收藏 5
点赞数
分类专栏： 竞赛+考研 王道数据结构源码实战 文章标签： 数据结构 链表 散列表
于 2022-02-21 03:18:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45601540/article/details/122917315
版权

王道数据结构源码实战ch2线性表

顺序表

顺序的表结构体定义

typedef struct SqList   //和链表定义的单个节点不同，顺序表定义的结构体就是整个完整的表
{
    ElemType data[MaxSize];
    int length;
} SqList;

在顺序表L的第i个位置插入元素e

bool ListInsert(SqList &L,int i,ElemType e)  //在第i个位置插入e
{
    if(i<1||i>L.length+1)     //插入位置越界，失败
        return false;
    if(L.length>=MaxSize)  //长度已经达到上限，插入失败
        return false;
//i已经用作参数，使用j作为循环变量
    for(int j=L.length; j>=i; j--)  //data[length]开始是空的，所以从最右边元素开始依次右移，直到原来第i个元素（下标为i-1）变为第i+1（下标为i）个元素
    {
        L.data[j]=L.data[j-1];   //每轮都是小的给大的
    }
    L.data[i-1]=e;              //在现在空出来的第i个位置（下标为i-1）插入
    L.length++;                //插入后，长度+1
    return true;

}

删除顺序表L第i个位置的元素，并用e取出

bool ListDelete(SqList &L,int i,ElemType &e)  //删除第i个位置的元素，删之前用e保存
{
    if(i<1||i>L.length)    //删除位置越界，失败
        return false;
    if(L.length==0)     //顺序表为空，无法删除，失败
        return false;
    e=L.data[i-1];   //取出第i个元素（下标为i-1）
    for(int j=i; j<L.length; j++)  //开始第i个位置（下标为i-1）是空的，所以从第i+1(下标为i)个位置开始向左填充
        L.data[j-1]=L.data[j];   //每轮都是大的给小的
    L.length--;   //删除后，顺序表长度-1
    return true;
}

在顺序表L中查找e是第几个元素

int ListLocate(SqList &L,ElemType e)  //查找e是第几个元素
{
    for(int i=0; i<L.length; i++)
        if(L.data[i]==e)
            return i+1;     //下表为i代表第i+1个元素
    return 0;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

#define MaxSize 50
typedef int ElemType;

typedef struct SqList   //和链表定义的单个节点不同，顺序表定义的结构体就是整个完整的表
{
    ElemType data[MaxSize];
    int length;
} SqList;

bool ListInsert(SqList &L,int i,ElemType e)  //在第i个位置插入e
{
    if(i<1||i>L.length+1)     //插入位置越界，失败
        return false;
    if(L.length>=MaxSize)  //长度已经达到上限，插入失败
        return false;
//i已经用作参数，使用j作为循环变量
    for(int j=L.length; j>=i; j--)  //data[length]开始是空的，所以从最右边元素开始依次右移，直到原来第i个元素（下标为i-1）变为第i+1（下标为i）个元素
    {
        L.data[j]=L.data[j-1];   //每轮都是小的给大的
    }
    L.data[i-1]=e;              //在现在空出来的第i个位置（下标为i-1）插入
    L.length++;                //插入后，长度+1
    return true;

}
bool ListDelete(SqList &L,int i,ElemType &e)  //删除第i个位置的元素，删之前用e保存
{
    if(i<1||i>L.length)    //删除位置越界，失败
        return false;
    if(L.length==0)     //顺序表为空，无法删除，失败
        return false;
    e=L.data[i-1];   //取出第i个元素（下标为i-1）
    for(int j=i; j<L.length; j++)  //开始第i个位置（下标为i-1）是空的，所以从第i+1(下标为i)个位置开始向左填充
        L.data[j-1]=L.data[j];   //每轮都是大的给小的
    L.length--;   //删除后，顺序表长度-1
    return true;
}

int ListLocate(SqList &L,ElemType e)  //查找e是第几元素
{
    for(int i=0; i<L.length; i++)
        if(L.data[i]==e)
            return i+1;     //下表为i代表第i+1个元素
    return 0;
}
void PrintList(SqList L)   //打印
{
    for(int i=0; i<L.length; i++)
        printf("%3d",L.data[i]);  //每个数字占三个字符，右对齐，左边用空格占位
    cout<<endl;                    //%md 表示：如果数据的位数小于 m，则左端补以空格，若大于 m，则按实际位数输出。
}                                            //%-md  左对齐
//%0md 右对齐，左边补0

int main()
{
    SqList L;
    bool ret;
    ElemType del;

    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;

    ret=ListInsert(L,2,60); //第二个位置插入60
    if(ret)
    {
        cout<<"insert success!"<<endl;
        PrintList(L);
    }
    else
    {
        cout<<"insert fail!"<<endl;
    }

    ret=ListDelete(L,1,del);
    if(ret)
    {
        cout<<"delete success!"<<endl;
        PrintList(L);
    }
    else
    {
        cout<<"delete fail!"<<endl;
    }

    int elem_pos;  //用来接收元素的位置
    elem_pos=ListLocate(L,60);
    if(elem_pos)
    {
        cout<<"search success!"<<endl;
        cout<<elem_pos<<endl;
    }
    else
    {
        cout<<"search fail!"<<endl;
    }

    return 0;
}

单链表

单链表节点的定义

typedef struct LNode  //因为在定义内需要定义节点类型的指针，所以这里必须对类型命名
{
    //结构体定义链表的节点，与顺序表的定义整个表不同
    ElemType data;
    struct LNode *next;  //定义的递归，内部用到了结构体的类型
} LNode,*LinkList;        //定义了结构体类型，与指向该结构体的指针，前者从名字上更强调的是一个节点，后者强调的是一个链表

头插法建立单链表L

LinkList List_Head_Insert(LinkList &L) //头插法一次插入多个
{
    LNode*s;  //临时变量，暂时指向待插入的节点
    int x;  //临时变量，暂存数据

    L=(LinkList)malloc(sizeof(LNode));  //只有指针，要先生成头结点,L指向新生成的头结点
    L->next=NULL;  //至此，初始化完成，只有一个头结点

    scanf("%d",&x);        //第一次先读入x，才能进入while循环
    while(x!=9999)           //9999为约定的终止输入符号
    {
        s=(LNode*)malloc(sizeof(LNode));   //创建新的节点，用临时指针s指向
        s->data=x;     //给新节点放入数据

        s->next=L->next;  //挂右
        L->next=s;     //挂左
        scanf("%d",&x);
    }
    return L;
}

尾插法建立单链表L

LinkList List_Tail_Insert(LinkList &L)//尾插法一次插入多个
{
    int x;   //临时变量，暂存数据
    LNode*s,*r; //生成临时指针s,尾指针r

    L=(LinkList)malloc(sizeof(LNode));  //只有指针，要先生成头结点
    r=L;  //r指向尾部节点（第一次写时写错了）
    L->next=NULL;  //初始化完成，此时有且仅有，一个头结点和一个尾指针

    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;

        //可省略挂右，s->next=NULL;，因为只有最后一个插入的节点需要置NULL
        r->next=s;  //只需挂左
        r=s;  //r=r->next更能表明指针后移一位
        scanf("%d",&x);
    }
    r->next=NULL;  //重要，最后一个节点 置NULL，否则会异常。
    //不是NULL的话，默认指针的值为0xCDCDCDCD,不可访问，无法继续执行
    return L;
}

获取单链表L第i个节点的指针

LNode* GetElem(LinkList L,int i)  //获取第i个节点的指针
{
    LNode*p=L->next; //临时指针指向头结点后第一个元素 ，作为遍历的开始
    int j=1;   //设定p现在的位置为第一个

    if(i==0)   //第0个节点是头结点
        return L;
    if(i<0)    //越界，失败
        return NULL;

    while(p &&j<i)  //当前节点不为NULL，最后停留在i前一个位置。
    {
        p=p->next;
        j++;
    }
    return p;     //最后一次循环中，p又后移一个位置，正好就是第i个。
}

获取单链表L中元素value第一次出现的位置

int LocateElem(LinkList L,ElemType value) //找到第一个相等的值的位置就结束，不考虑后面有相同的值
{
    LNode*p=L->next;   //从头结点后一个元素开始
    int j=1;
    while(p&&(p->data)!=value)
    {
        p=p->next;
        j++;
    }
    return j;
}

在单链表L的第i个位置插入新节点（数据域为e）

bool ListFrontInsert(LinkList L,int i,ElemType e) //在第i个位置插入新节点（数据域为e）
{
    LNode* p=GetElem(L,i-1);    //p指向插入位置前一个节点的位置，作为开始
    if(p==NULL)
        return false;

    LNode* s=(LNode*)malloc(sizeof(LNode));  //s临时指向新生成的节点
    s->data=e;

    s->next=p->next;    //挂右
    p->next=s;    //挂左
    return true;
}

删除单链表L的第i个元素

bool ListDelete(LinkList L,int i)   //删除第i个元素
{
    LNode* p=GetElem(L,i-1);    //p指向删除位置前一个节点的位置
    if(p==NULL) return false;

    LNode* q=p->next;  //必须暂存待删除节点的指针，因为后一歩改变了P的后继，找不到待删除节点了，无法free空间
    if(q==NULL) return false;

    p->next=q->next;    //挂右

    free(q);  //暂存了待删除元素的位置，才能free
    q==NULL;   //处理野指针
    return true;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

typedef int ElemType;

typedef struct LNode  //因为在定义内需要定义节点类型的指针，所以这里必须对类型命名
{
    //结构体定义链表的节点，与顺序表的定义整个表不同
    ElemType data;
    struct LNode *next;  //定义的递归，内部用到了结构体的类型
} LNode,*LinkList;        //定义了结构体类型，与指向该结构体的指针，前者从名字上更强调的是一个节点，后者强调的是一个链表

LinkList List_Head_Insert(LinkList &L) //头插法一次插入多个
{
    LNode*s;  //临时变量，暂时指向待插入的节点
    int x;  //临时变量，暂存数据

    L=(LinkList)malloc(sizeof(LNode));  //只有指针，要先生成头结点,L指向新生成的头结点
    L->next=NULL;  //至此，初始化完成，只有一个头结点

    scanf("%d",&x);        //第一次先读入x，才能进入while循环
    while(x!=9999)           //9999为约定的终止输入符号
    {
        s=(LNode*)malloc(sizeof(LNode));   //创建新的节点，用临时指针s指向
        s->data=x;     //给新节点放入数据

        s->next=L->next;  //挂右
        L->next=s;     //挂左
        scanf("%d",&x);
    }
    return L;
}

LinkList List_Tail_Insert(LinkList &L)//尾插法一次插入多个
{
    int x;   //临时变量，暂存数据
    LNode*s,*r; //生成临时指针s,尾指针r

    L=(LinkList)malloc(sizeof(LNode));  //只有指针，要先生成头结点
    r=L;  //r指向尾部节点（第一次写时写错了）
    L->next=NULL;  //初始化完成，此时有且仅有，一个头结点和一个尾指针

    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;

        //可省略挂右，s->next=NULL;，因为只有最后一个插入的节点需要置NULL
        r->next=s;  //只需挂左
        r=s;  //r=r->next更能表明指针后移一位
        scanf("%d",&x);
    }
    r->next=NULL;  //重要，最后一个节点 置NULL，否则会异常。
    //不是NULL的话，默认指针的值为0xCDCDCDCD,不可访问，无法继续执行
    return L;
}

LNode* GetElem(LinkList L,int i)  //得到第i个节点的指针
{
    LNode*p=L->next; //临时指针指向头结点后第一个元素 ，作为遍历的开始
    int j=1;   //设定p现在的位置为第一个

    if(i==0)   //第0个节点是头结点
        return L;
    if(i<0)    //越界，失败
        return NULL;

    while(p &&j<i)  //当前节点不为NULL，最后停留在i前一个位置。
    {
        p=p->next;
        j++;
    }
    return p;     //最后一次循环中，p又后移一个位置，正好就是第i个。
}

int LocateElem(LinkList L,ElemType value) //找到第一个相等的值的位置就结束，不考虑后面有相同的值
{
    LNode*p=L->next;   //从头结点后一个元素开始
    int j=1;
    while(p&&(p->data)!=value)
    {
        p=p->next;
        j++;
    }
    return j;
}

//不需要引用，因为头结点L不变
bool ListFrontInsert(LinkList L,int i,ElemType e) //在第i个位置插入新节点（数据域为e）
{
    LNode* p=GetElem(L,i-1);    //p指向插入位置前一个节点的位置，作为开始
    if(p==NULL)
        return false;

    LNode* s=(LNode*)malloc(sizeof(LNode));  //s临时指向新生成的节点
    s->data=e;

    s->next=p->next;    //挂右
    p->next=s;    //挂左
    return true;
}

bool ListDelete(LinkList L,int i)   //删除第i个元素
{
    LNode* p=GetElem(L,i-1);    //p指向删除位置前一个节点的位置
    if(p==NULL) return false;

    LNode* q=p->next;  //必须暂存待删除节点的指针，因为后一歩改变了P的后继，找不到待删除节点了，无法free空间
    if(q==NULL) return false;

    p->next=q->next;    //挂右

    free(q);  //暂存了待删除元素的位置，才能free
    q==NULL;   //处理野指针
    return true;
}

void ShowList1(LinkList L)  //打印链表
{
    L=L->next;    //先移动一次
    while(L)     //此后每次先打印再移动
    {
        cout<<L->data<<" ";
        L=L->next;
    }
    cout<<endl;
}

void ShowList2(LinkList L)//打印链表方法二，自己想的
{
    while(L->next!=NULL)  //每次先移动，再打印
    {
        L=L->next;
        cout<<L->data<<" ";
    }
    cout<<endl;
}

int main()
{
    LinkList L;  //定义单链表
    LNode* searching;  //用来保存指向第i个节点的指针，要操作的节点的前驱

    //List_Head_Insert(L);    //前插法建立单链表
    //cout<<endl<<"------------linked list generated by head insertion：------------"<<endl;
    //ShowList1(L);

    List_Tail_Insert(L);   //后插法建立单链表
    cout<<endl<<"------------linked list generated by tail insertion：------------"<<endl;
    ShowList1(L);

    ListFrontInsert(L,3,666);   //在第3个位置插入666
    cout<<endl<<"------------Insert 666 in the 3rd position：------------"<<endl;
    ShowList1(L);

    ListDelete(L,2); //删除第2个元素
    cout<<endl<<"------------delete the second element：------------"<<endl;
    ShowList1(L);

    searching=GetElem(L,2);    //得到第2个位置的指针
    cout<<endl<<"------------data element in 2nd position：------------"<<endl;
    cout<<(searching->data)<<endl;  //打印第二个位置的数据元素

    int pos=LocateElem(L,5);   //查找5第一次出现的位置
    cout<<endl<<"------------The position 5 where it first appears：------------"<<endl;
    cout<<pos<<endl;   //打印5第一次出现的位置

    //Test Data:
    //5 6 96  85 65 9999
    return 0;
}

双链表

双链表节点的定义

typedef struct DLNode
{
    ElemType data;
    struct DLNode *prior;
    struct DLNode *next;
} DLNode,*DLinkList;

头插法建立双链表DL

DLinkList Dlist_Head_Insert(DLinkList &DL)  //头插法
{
    int x;            //临时变量，暂存数据
    DLNode  * s;//临时变量，暂时指向待插入的节点


    DL=(DLinkList)malloc(sizeof(DLNode));
    DL->next=NULL;
    DL->prior=NULL;    //至此，初始化完成，只有一个头结点，两个指针域都为空

    cin>>x;   //先输入第一个元素，才能进入while循环
    while(x!=9999)     //9999为约定的终止输入符号
    {
        s=(DLNode*)malloc(sizeof(DLNode));    //创建新节点
        s->data=x;
//插入过程为：先挂右，右返回；再挂左边，左返回
        s->next=DL->next;   //挂右
        if(DL->next!=NULL)   //右边没有元素时，不需要返回挂上
        {
            DL->next->prior=s;   //右边有元素时，挂右(返回）
        }

        s->prior=DL;   //挂左
        DL->next=s;    //挂左（返回）

        cin>>x;
    }
    return DL;
}

尾插法建立单链表L

DLinkList Dlist_Tail_Insert(DLinkList &DL) //尾插法
{
    int x;            //临时变量，暂存数据
    DLNode * s; //临时变量，暂时指向待插入的节点

    DL=(DLinkList)malloc(sizeof(DLNode));  //先创建头结点，才能定义尾指针
    DLNode*r=DL;   //尾插法需要额外一个尾指针
    DL->prior=NULL;
    DL->next=NULL;  //至此，初始化完成，只有一个头结点，两个指针域都为空

    cin>>x;
    while(x!=9999)
    {
        s=(DLNode*)malloc(sizeof(DLNode));  //创建新节点
        s->data=x;

        r->next=s;   //挂左（返回）
        s->prior=r;   //挂左
        r=s; //r=r->next; 尾指针后移

        cin>>x;
    }
    r->next=NULL;
    return DL;
}

获取双链表DL第i个节点的指针

DLNode* GetElem(DLinkList DL,int i)  //获取第i个节点的指针
{
    DLNode*p=DL->next; //临时指针指向头结点后第一个元素 ，作为遍历的开始
    int j=1;   //设定p现在的位置为第一个

    if(i==0)  //第0个元素，返回头结点
        return DL;
    if(i<0)  //越界
        return NULL;

    while(p &&j<i)  //当前节点不为NULL，最后停留在i前一个位置。
    {
        p=p->next;
        j++;
    }
    return p;     //最后一次循环中，p又后移一个位置，正好就是第i个。
}

在双链表DL的第i个位置插入新节点（数据域为e）

bool DList_Front_Insert(DLinkList &DL,int i,int e)  //在第i个位置插入
{
    DLNode*p=GetElem(DL,i-1);   //找到待插入位置的前一个节点
    if(p==NULL) return false;

    DLNode*s=(DLNode*)malloc(sizeof(DLNode));  //创建新节点
    s->data=e;

//第一种方式
    s->next=p->next;   //挂右
    p->next->prior=s;  //挂右（返回）     //若在第一个位置插入，且此时只有头结点，需要特判这一句，此处忽略
    s->prior=p;   //挂左
    p->next=s;    //挂左（返回）

    //另一种挂新节点的方式
    /*
    s->next=p->next;  //挂右
    s->prior=p;   //挂左
    p->next=s;     //挂左（返回）
    s->next->prior=s  挂右（返回）
    */

    return true;
}

双链表的两种插入方式详解（王道和天勤）：

在这里插入图片描述

在这里插入图片描述

删除单链表DL的第i个元素

bool DListDelete(DLinkList &DL,int i)  //删除第i个位置的元素
{
    DLNode*p =GetElem(DL,i-1);  //找到待删除位置的前一个节点
    if(p==NULL) return false;

    DLNode*q=p->next;   //保存待删除节点的指针，不然无法free空间
    if(q==NULL)  return false;

    p->next=q->next;     //挂右（可以指向NULL）
    if(q->next!=NULL)   //判断删除的是否最后一个节点
    {
        q->next->prior=p;  //挂左
    }
    free(q);
    q=NULL;   //处理野指针

    return true;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

typedef int ElemType ;

typedef struct DLNode
{
    ElemType data;
    struct DLNode *prior;
    struct DLNode *next;
} DLNode,*DLinkList;

DLinkList Dlist_Head_Insert(DLinkList &DL)  //头插法
{
    int x;            //临时变量，暂存数据
    DLNode  * s;//临时变量，暂时指向待插入的节点


    DL=(DLinkList)malloc(sizeof(DLNode));
    DL->next=NULL;
    DL->prior=NULL;    //至此，初始化完成，只有一个头结点，两个指针域都为空

    cin>>x;   //先输入第一个元素，才能进入while循环
    while(x!=9999)     //9999为约定的终止输入符号
    {
        s=(DLNode*)malloc(sizeof(DLNode));    //创建新节点
        s->data=x;
//插入过程为：先挂右，右返回；再挂左边，左返回
        s->next=DL->next;   //挂右
        if(DL->next!=NULL)   //右边没有元素时，不需要返回挂上
        {
            DL->next->prior=s;   //右边有元素时，挂右(返回）
        }

        s->prior=DL;   //挂左
        DL->next=s;    //挂左（返回）

        cin>>x;
    }
    return DL;
}

DLinkList Dlist_Tail_Insert(DLinkList &DL) //尾插法
{
    int x;            //临时变量，暂存数据
    DLNode * s; //临时变量，暂时指向待插入的节点

    DL=(DLinkList)malloc(sizeof(DLNode));  //先创建头结点，才能定义尾指针
    DLNode*r=DL;   //尾插法需要额外一个尾指针
    DL->prior=NULL;
    DL->next=NULL;  //至此，初始化完成，只有一个头结点，两个指针域都为空

    cin>>x;
    while(x!=9999)
    {
        s=(DLNode*)malloc(sizeof(DLNode));  //创建新节点
        s->data=x;

        r->next=s;   //挂左（返回）
        s->prior=r;   //挂左
        r=s; //r=r->next; 尾指针后移

        cin>>x;
    }
    r->next=NULL;
    return DL;
}

DLNode* GetElem(DLinkList DL,int i)  //查找第i个节点的值
{
    DLNode*p=DL->next; //临时指针指向头结点后第一个元素 ，作为遍历的开始
    int j=1;   //设定p现在的位置为第一个

    if(i==0)  //第0个元素，返回头结点
        return DL;
    if(i<0)  //越界
        return NULL;

    while(p &&j<i)  //当前节点不为NULL，最后停留在i前一个位置。
    {
        p=p->next;
        j++;
    }
    return p;     //最后一次循环中，p又后移一个位置，正好就是第i个。
}

bool DList_Front_Insert(DLinkList &DL,int i,int e)  //在第i个位置插入
{
    DLNode*p=GetElem(DL,i-1);   //找到待插入位置的前一个节点
    if(p==NULL) return false;

    DLNode*s=(DLNode*)malloc(sizeof(DLNode));  //创建新节点
    s->data=e;

//第一种方式
    s->next=p->next;   //挂右
    p->next->prior=s;  //挂右（返回）     //若在第一个位置插入，且此时只有头结点，需要特判这一句，此处忽略
    s->prior=p;   //挂左
    p->next=s;    //挂左（返回）

    //另一种挂新节点的方式
    /*
    s->next=p->next;  //挂右
    s->prior=p;   //挂左
    p->next=s;     //挂左（返回）
    s->next->prior=s  挂右（返回）
    */

    return true;
}

bool DListDelete(DLinkList &DL,int i)  //删除第i个位置的元素
{
    DLNode*p =GetElem(DL,i-1);  //找到待删除位置的前一个节点
    if(p==NULL) return false;

    DLNode*q=p->next;   //保存待删除节点的指针，不然无法free空间
    if(q==NULL)  return false;

    p->next=q->next;     //挂右（可以指向NULL）
    if(q->next!=NULL)   //判断删除的是否最后一个节点
    {
        q->next->prior=p;  //挂左
    }
    free(q);
    q=NULL;   //处理野指针

    return true;
}

void ShowList2(DLinkList L)//自己想的
{
    while(L->next!=NULL)
    {
        L=L->next;
        cout<<L->data<<" ";
    }
    cout<<endl;
}

int main()
{
    DLinkList DL;  //定义双链表
    DLNode* searching;  //用来保存指向第i个节点的指针，要操作的节点的前驱

    Dlist_Head_Insert(DL);   //头插法
    cout<<endl<<"------------Double linked list generated by head insertion：------------"<<endl;
    ShowList2(DL);

    //cout<<endl<<"-----------Double linked list generated by tail insertion：-----------"<<endl;
    //Dlist_Tail_Insert(DL);    //尾插法
    //ShowList2(DL);

    searching=GetElem(DL,3);  //得到第3个位置的指针
    cout<<endl<<"----------------The data element in the 3rd position is：----------------"<<endl;
    cout<<(searching->data)<<endl;  //打印第3个位置的数据元素

    DList_Front_Insert(DL,2,666);  //在第2个位置插入666
    cout<<endl<<"--------------------Insert 666 in the 2nd position：--------------------"<<endl;
    ShowList2(DL);

    DListDelete(DL,666);   //删除666
    cout<<endl<<"-------------------------------Delete 666 ：------------------------------"<<endl;
    ShowList2(DL);

    //Test Data:
    //5 6 96  85 65 9999
    return 0;
}

#define与typedef的区别

关键字typedef在编译阶段有效，由于是在编译阶段，因此typedef有类型检查的功能。

#define则是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查

WYF19999
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数据结构代码实例实现(王道)
Mas的博客
01-07 4962
王道数据结构顺序表的代码实现： 讲道理，实现才有意思。 #include<stdio.h> #include<stdlib.h> //静态分配 #define MaxSize 50 typedef int ElemType; //typedef struct{ // ElemType data[MaxSize]; // int length; //}SqLis...
考研王道数据结构代码.zip
11-26
里面是2020王道数据结构课后习题可执行代码。https://blog.csdn.net/qq_40285036 可以参考这个博客一起学习。
王道数据结构——单链表
UncleJokerly
08-05 393
单链表
王道数据结构代码---第二章：线性表（顺序表+单链表+双链表）
jinzhi66的博客
07-15 830
线性表：顺序表，单链表，双链表
2023王道考研数据结构第二章---单链表
最新发布
weixin_52572034的博客
08-17 1290
2023王道考研数据结构第二章---单链表
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
### 数据结构C++ 线性表——顺序表和单链表基本操作 #### 一、概述 在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并...
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
实验内容： （1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度...编写一个算法将此表改为循环双链表。
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构学习--线性表及其应用--顺序表
06-25
线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种存储方式具有随机访问的优势，因为可以通过元素的索引来直接访问数组中的...
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
王道数据结构源码实战自学-链表(C++版)
希望可以给你点帮助
07-10 533
王道数据结构c语言训练营 源码实战 个人学习笔记 不适合小白，适合有一定c语言基础和数据结构基础
王道数据结构——链表、循环单链表实现
qq_42242452的博客
04-29 1162
王道考研单链表、循环单链表代码实现。
本科课程【数据结构与算法】实验2——单链表与双向循环链表的插入、删除操作(C++实现）
1+1=王的博客
03-01 1875
大家好，我是【1+1=王】， 热爱java的计算机（人工智能）渣硕研究生在读。 如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！ Good better best, never let it rest, until good is better, and better best. 近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。 持续更新。。。。。。。 一、 实验目的 掌握线性表的链表表示； 实现单链表的插入操作 实现单链表的删除操作 实现.
王道《数据结构考研复习指导》代码
a524633094的博客
09-17 9107
线性表__顺序表示 #include&amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;gt; //静态分配 #define MaxSize 50 typedef int ElemType; typedef struct{ ElemType data[Max
顺序表---增删查
anshengla的博客
04-26 237
王道c顺序表
数据结构实验——实验二链表实验
qq_65814357的博客
06-10 1914
一、 实验任务编写算法实现下列问题的求解。(1)在第i个结点位置插入值为x的结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2第二组数据：单链表长度n=0，x=100，i=5(2)删除单链表中第i个元素结点。实验测试数据基本要求：第一组数据：单链表长度n≥10，i分别为5,n,1,n+1,0第二组数据：单链表长度n=0， i=5(3)在一个递增有序的单链表L中插入一个值为x的元素，并保持其递增有序特性。实验测试数据基本要求：单链表元素为 （10
数据结构 考研 代码总结 【基本完善】
热门推荐
lzs_lazy
07-16 1万+
2.2.10 左移循环数组p位 Source：2010统考真题 题目：将一个n元素的数组，进行左移p位，数组是可以循环的。 设计思想：先将a0a1...ap−1a_0 a_1 ... a_{p-1}a0​a1​...ap−1​部分原地翻转，然后将apap+1...an−1a_p a_{p+1} ... a_{n-1}ap​ap+1​...an−1​也原地翻转，最后在将整个序列进行翻转 代码： vo...
由f(x)=arcsinx幂级数展开收敛域端点处情况的一些思考
qq_45601540的博客
08-29 6373
前言 在计算如下两个幂级数展开时，遇到了一些疑问 f(x)=arcsinx 展开成x的幂级数 f(x)= 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns impo
王道数据结构实战ch5二叉树
qq_45601540的博客
02-23 1034
#include<bits/stdc++.h> using namespace std; typedef char ElemType; typedef struct BiTNode //树的节点 { ElemType c; struct BiTNode *lchild; struct BiTNode *rchild; } BiTNode,*BiTree; typedef struct tag //辅助链队的节点，为了节省空间，数据域存放的是树某个节点的指针！
数据结构实验：线性表的顺序表与单链表实现
"该文档是关于数据结构中线性表的实现与应用的实验报告，主要涵盖顺序表和单链表两种实现方式，旨在通过实验加深对线性表特性和操作的理解，并能解决实际问题。" 在计算机科学中，数据结构是组织和存储数据的方式，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WYF19999

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值