在单链表中第i元素赋值给e

在单链表中，如果要将第i个元素赋值给变量e，首先需要遍历链表找到这个位置。假设我们有一个指向头节点的指针`head`：

1. 首先检查i是否越界。如果i等于0，那么直接将头节点的值赋给e；因为链表的索引是从0开始的。

2. 如果i大于0，则创建一个新的指针`current`，初始化为头节点。然后进入一个循环：
- 每次迭代，更新`current`指向`current.next`，即移动到下一个节点，直到`current`到达第i个节点。
- 当`current`不是null并且`i`大于0时，`i--`表示已经访问了当前节点，继续下一次迭代。
- 当`i`变为0时，说明找到了目标节点，将`current.data`的值赋给`e`，然后退出循环。

以下是伪代码形式：

if i == 0:
    e = head.data
else:
    current = head
    while i > 0 and current is not None:
        current = current.next
        i--
    if current is not None:
        e = current.data

相关问题

用单链表存储线性表，写出在带头结点的单链表中插入数据元素e作为单链表的第i个元素的算法和求单链表长度ListLength()的算法。 Typedef struct Lnode { ElemType data; //数据域 struct Lnode *next; //指针域 }Lnode, *LinkList; bool ListInsert(LinkList &L, int i, ElemType e){ int ListLength( LinkList L ){

好的，我明白了。以下是您提出的问题的答案：

插入数据元素e作为单链表的第i个元素的算法：

1. 首先，需要判断i的合法性，如果i<=0或者i>链表长度+1，则插入位置不合法，返回false。
2. 创建一个新节点s，并将e赋值给s的data域。
3. 找到第i-1个节点p，将s的next指向p的next节点。
4. 将p的next指向s节点。
5. 返回true表示插入成功。

具体实现如下：

bool ListInsert(LinkList &L, int i, ElemType e){
    //判断插入位置是否合法
    if(i<=0 || i>ListLength(L)+1){
        return false;
    }
    //创建新节点s
    Lnode *s = new Lnode;
    s->data = e;
    //找到第i-1个节点p
    Lnode *p = L;
    for(int j=1; j<i; j++){
        p = p->next;
    }
    //插入节点s
    s->next = p->next;
    p->next = s;
    //插入成功，返回true
    return true;
}

求单链表长度ListLength()的算法：

遍历链表，统计节点个数即可。

具体实现如下：

int ListLength(LinkList L){
    int count = 0;
    Lnode *p = L->next;
    while(p){
        count++;
        p = p->next;
    }
    return count;
}

构造一个单链表，要求：（1）构造一个空的单链表L，其基本操作为LinkListInit(LinkList *L)。 （2）单链表L已存在，销毁单链表L，其基本操作为DestroyLinkList (LinkList *L)。 （3）单链表L已存在，若单链表L为空表，则返回0，否则返回1，调用函数可通过判断函数返回值确定结果状态，其基本操作为LinkListEmpty(LinkList *L)。 （4）单链表L已存在，返回单链表L中数据元素个数，其基本操作为LinkListLength (LinkList *L)。 （5）L为带头结点的单链表的头指针。当第i个元素存在时，返回其值，若这样的数据元素不存在，则给出相应的提示，其基本操作为GetLinkListElem(LinkList *L)。 （6）单链表L已存在，返回单链表L中第i个与e值相同的数据元素的位序，若这样的数据元素不存在，则给出相应的提示，其基本操作为LocateLinkListElem (LinkList *L, ElemType e)。 （7）在带头结点的单链表L中第i个位置之前插入元素e，若这样的数据元素不存在，则给出相应的提示，其基本操作为LinkListInsert(LinkList *L, int i, ElemType e)。 （8）在带头结点的单链表L中删除第i个元素，若这样的数据元素不存在或i值不符合要求，则给出相应的提示，其基本操作为LinkListDelete(LinkList *L, int i)。 （9）单链表L已存在，输出显示单链表L中的各个元素，其基本操作为DispLinkList(LinkList *L)。 （10） 头插法建立单链表L，其基本操作为CreateLinkListF(LinkList *L, ElemType d[ ], int n)。 （11） 尾插法建立单链表L，其基本操作为CreateLinkListR(LinkList *L, ElemType d[ ], int n)。

好的，我来依次回答你的问题。

1. 构造一个空的单链表L，其基本操作为LinkListInit(LinkList *L)。

typedef struct LNode {
    ElemType data; //数据域
    struct LNode *next; //指针域
} LNode, *LinkList;

//初始化链表
void LinkListInit(LinkList *L) {
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    (*L)->next = NULL; //头结点的指针域置空
}

2. 单链表L已存在，销毁单链表L，其基本操作为DestroyLinkList (LinkList *L)。

//销毁链表
void DestroyLinkList(LinkList *L) {
    LinkList p, q;
    p = (*L)->next; //p指向第一个结点
    while (p) {
        q = p->next; //q指向下一个结点
        free(p); //释放p结点
        p = q; //p指向下一个结点
    }
    free(*L); //释放头结点
    *L = NULL; //头指针置空
}

3. 单链表L已存在，若单链表L为空表，则返回0，否则返回1，调用函数可通过判断函数返回值确定结果状态，其基本操作为LinkListEmpty(LinkList *L)。

//判断链表是否为空
int LinkListEmpty(LinkList *L) {
    if ((*L)->next == NULL) {
        return 0; //空表
    }
    else {
        return 1; //非空表
    }
}

4. 单链表L已存在，返回单链表L中数据元素个数，其基本操作为LinkListLength (LinkList *L)。

//获取链表长度
int LinkListLength(LinkList *L) {
    int len = 0;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        len++; //长度加1
        p = p->next; //p指向下一个结点
    }
    return len;
}

5. L为带头结点的单链表的头指针。当第i个元素存在时，返回其值，若这样的数据元素不存在，则给出相应的提示，其基本操作为GetLinkListElem(LinkList *L)。

//获取指定位置的结点元素值
int GetLinkListElem(LinkList *L, int i, ElemType *e) {
    int j = 1;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!p || j > i) {
        return 0; //未找到指定位置的结点
    }
    *e = p->data; //获取结点元素值
    return 1;
}

6. 单链表L已存在，返回单链表L中第i个与e值相同的数据元素的位序，若这样的数据元素不存在，则给出相应的提示，其基本操作为LocateLinkListElem (LinkList *L, ElemType e)。

//查找指定元素值的结点位序
int LocateLinkListElem(LinkList *L, ElemType e) {
    int i = 1;
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        if (p->data == e) {
            return i; //返回结点位序
        }
        p = p->next; //p指向下一个结点
        i++; //计数器加1
    }
    return 0; //未找到指定元素值的结点
}

7. 在带头结点的单链表L中第i个位置之前插入元素e，若这样的数据元素不存在，则给出相应的提示，其基本操作为LinkListInsert(LinkList *L, int i, ElemType e)。

//在指定位置插入结点
int LinkListInsert(LinkList *L, int i, ElemType e) {
    int j = 1;
    LinkList p = (*L), s;
    while (p && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!p || j > i) {
        return 0; //未找到指定位置的结点
    }
    s = (LinkList)malloc(sizeof(LNode)); //创建新结点
    s->data = e; //新结点赋值
    s->next = p->next; //新结点指向原来的结点
    p->next = s; //前一个结点指向新结点
    return 1;
}

8. 在带头结点的单链表L中删除第i个元素，若这样的数据元素不存在或i值不符合要求，则给出相应的提示，其基本操作为LinkListDelete(LinkList *L, int i)。

//删除指定位置的结点
int LinkListDelete(LinkList *L, int i) {
    int j = 1;
    LinkList p = (*L), q;
    while (p->next && j < i) {
        p = p->next; //p指向下一个结点
        j++; //计数器加1
    }
    if (!(p->next) || j > i) {
        return 0; //未找到指定位置的结点
    }
    q = p->next; //q指向要删除的结点
    p->next = q->next; //前一个结点指向后一个结点
    free(q); //释放结点
    return 1;
}

9. 单链表L已存在，输出显示单链表L中的各个元素，其基本操作为DispLinkList(LinkList *L)。

//输出链表元素
void DispLinkList(LinkList *L) {
    LinkList p = (*L)->next; //p指向第一个结点
    while (p) {
        printf("%d ", p->data); //输出结点元素
        p = p->next; //p指向下一个结点
    }
    printf("\n");
}

10. 头插法建立单链表L，其基本操作为CreateLinkListF(LinkList *L, ElemType d[ ], int n)。

//头插法建立链表
void CreateLinkListF(LinkList *L, ElemType d[], int n) {
    LinkList p;
    int i;
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    (*L)->next = NULL; //头结点的指针域置空
    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(LNode)); //创建新结点
        p->data = d[i]; //新结点赋值
        p->next = (*L)->next; //新结点指向第一个结点
        (*L)->next = p; //头结点指向新结点
    }
}

11. 尾插法建立单链表L，其基本操作为CreateLinkListR(LinkList *L, ElemType d[ ], int n)。

//尾插法建立链表
void CreateLinkListR(LinkList *L, ElemType d[], int n) {
    LinkList p, r;
    int i;
    *L = (LinkList)malloc(sizeof(LNode)); //创建头结点
    r = *L; //r指向头结点
    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(LNode)); //创建新结点
        p->data = d[i]; //新结点赋值
        r->next = p; //尾结点指向新结点
        r = p; //r指向新结点
    }
    r->next = NULL; //尾结点的指针域置空
}

以上就是单链表的各种基本操作啦，希望能对你有所帮助！