1.插入元素 2.删除元素 3.获取第i个结点的数据元素 4.判断元素是否存在5.获取某个元素的下一个元素;NextElem（L， cur_e， &next_e）main函数里面怎么写

next_e）6.获取某个元素的前一个元素;PriorElem（L， cur_e， prior_e）7.获取线性表的长度;ListLength（L）8.清空线性表;ClearList（L）9.判断线性表是否为空;ListEmpty（L）10.遍历线性表;ListTraverse（L， visit）

相关问题

编程实现单向链表的基本操作： 1.插入元素 2.删除元素 3.获取第i个结点的数据元素 4.判断元素是否存在 5.获取某个元素的下一个元素；

C++代码实现单向链表的基本操作：

#include<iostream>
using namespace std;

struct ListNode{
    int data;
    ListNode *next;
};

// 插入元素
ListNode* insert(ListNode* head, int newData){
    ListNode *newNode = new ListNode;
    newNode->data = newData;
    newNode->next = NULL;
    if(head==NULL){
        head = newNode;
    }
    else{
        ListNode *p = head;
        while(p->next!=NULL){
            p = p->next;
        }
        p->next = newNode;
    }
    return head;
}

// 删除元素
ListNode* remove(ListNode* head, int key){
    if(head==NULL){
        return NULL;
    }
    else if(head->data == key){
        ListNode *temp = head;
        head = head->next;
        delete temp;
    }
    else{
        ListNode *p = head;
        while(p->next!=NULL && p->next->data!=key){
            p = p->next;
        }
        if(p->next!=NULL){
            ListNode *temp = p->next;
            p->next = temp->next;
            delete temp;
        }
    }
    return head;
}

// 获取第i个结点的数据元素
int getElement(ListNode* head, int i){
    int count = 0;
    ListNode *p = head;
    while(p!=NULL && count<i){
        p = p->next;
        count++;
    }
    if(p!=NULL){
        return p->data;
    }
    else{
        return -1; // 若不存在第i个结点，返回-1
    }
}

// 判断元素是否存在
bool contains(ListNode* head, int key){
    ListNode *p = head;
    while(p!=NULL && p->data!=key){
        p = p->next;
    }
    if(p!=NULL){
        return true;
    }
    else{
        return false;
    }
}

// 获取某个元素的下一个元素
int getNextElement(ListNode* head, int key){
    ListNode *p = head;
    while(p!=NULL && p->data!=key){
        p = p->next;
    }
    if(p!=NULL && p->next!=NULL){
        return p->next->data;
    }
    else{
        return -1; // 若key不存在或key是最后一个结点，返回-1
    }
}

int main(){
    ListNode *head = NULL;
    head = insert(head, 1);
    head = insert(head, 3);
    head = insert(head, 5);
    head = insert(head, 7);

    cout<<"链表的元素为：";
    ListNode *p = head;
    while(p!=NULL){
        cout<<p->data<<" ";
        p = p->next;
    }

    head = remove(head, 3);

    cout<<"\n删除元素3后，链表的元素为：";
    p = head;
    while(p!=NULL){
        cout<<p->data<<" ";
        p = p->next;
    }

    int element = getElement(head, 2);
    cout<<"\n获取第2个结点的元素为："<<element<<endl;

    bool flag = contains(head, 5);
    cout<<"是否存在元素5："<<flag<<endl;

    int nextElement = getNextElement(head, 7);
    cout<<"元素7的下一个元素为："<<nextElement<<endl;

    return 0;
}

输出结果：

链表的元素为：1 3 5 7 
删除元素3后，链表的元素为：1 5 7 
获取第2个结点的元素为：5
是否存在元素5：1
元素7的下一个元素为：-1

编程实现单向链表的基本操作： 1.插入元素 2.删除元素 3.获取第i个结点的数据元素 4.判断元素是否存在 5.获取某个元素的下一个元素；C++

typedef struct node {
int data; //数据元素
struct node *next; //指向下一个结点的指针
} Node;

Node *head = NULL; //链表头结点

//在链表末尾插入元素
void insert(int value) {
//创建新结点
Node *new_node = (Node*) malloc(sizeof(Node));
new_node->data = value;
new_node->next = NULL;

//判断链表是否为空
if(head == NULL) {
head = new_node;
return;
}

//遍历链表，找到末尾结点
Node *current = head;
while(current->next != NULL) {
current = current->next;
}

//将新结点插入到末尾
current->next = new_node;
}

//删除值为value的结点
void delete(int value) {
//判断链表是否为空
if(head == NULL) return;

//判断头结点是否为要删除的结点
if(head->data == value) {
Node *temp = head;
head = head->next;
free(temp);
return;
}

//遍历链表，找到要删除的结点
Node *current = head;
while(current->next != NULL && current->next->data != value) {
current = current->next;
}

//判断要删除的结点是否存在
if(current->next == NULL) return;

//将要删除的结点从链表中删除
Node *temp = current->next;
current->next = current->next->next;
free(temp);
}

//获取第i个结点的数据元素
int get(int i) {
//判断链表是否为空
if(head == NULL) return -1;

//遍历链表，找到第i个结点
Node *current = head;
int index = 1;
while(current != NULL && index != i) {
current = current->next;
index++;
}

//判断第i个结点是否存在
if(current == NULL) return -1;

//返回第i个结点的数据元素
return current->data;
}

//判断元素是否存在
int contains(int value) {
//判断链表是否为空
if(head == NULL) return 0;

//遍历链表，查找元素是否存在
Node *current = head;
while(current != NULL) {
if(current->data == value) return 1;
current = current->next;
}

//元素不存在
return 0;
}

//获取值为value的结点的下一个元素
int getNext(int value) {
//判断链表是否为空
if(head == NULL) return -1;

//遍历链表，查找值为value的结点
Node *current = head;
while(current != NULL) {
if(current->data == value) {
//返回下一个结点的数据元素
if(current->next != NULL) return current->next->data;
else return -1;
}
current = current->next;
}

//结点不存在
return -1;
}