1. 插入删除操作对比

1. 顺序表插入删除元素

插入策略:

在某个位置插入元素时, 把从该位置开始的所有元素都往后挪一个位置, 规定顺序表最后一个元素后面的位置也是一个可插入位置. 后面的元素先往后挪动位置.

删除策略:

在某位置删除元素, 把从该位置之后的所有元素都往前挪一个位置, 把要删除的元素覆盖掉即可. 前面的元素先往前挪动位置.

#include <iostream>

const int MAX_SIZE = 10;

//在C++中，整型数组是值类型。这意味着当你创建一个整型数组时，实际上会在内存中分配一块连续的内存来存储数组的元素。
//当你将整型数组分配给另一个变量或传递给函数时，会发生数组的拷贝，新数组的修改不会影响原始数组。

//在 C++ 中，不能直接返回整型数组。这是因为数组是一个连续的内存块，无法直接通过返回值的方式来传递。

/// <summary>
/// 初始化数组
/// </summary>
void initArr(int *arr, int length) {
    if (length > MAX_SIZE) {
        printf("数组长度超过最大长度!");
        return;
    }

    for (int i = 0; i < length; i++)
    {
        arr[i] = i;
    }

}

/// <summary>
/// 打印数组元素
/// </summary>
/// <param name="arr"></param>
void printArr(int *arr, int length) {
    //在 C++ 中，指针变量的初始值为 nullptr，而不是 NULL。
    //因此，应该将判断条件修改为 arr == nullptr，以检查数组是否为空。
    //if (arr[0] == NULL)
    if (arr == nullptr) {
        printf("数组为空!\n");
        return;
    }

    //另外，计算数组长度的方式也是错误的。在 C++ 中，数组作为函数参数传递时会被转换为指针，
    //因此无法通过 sizeof 运算符来获取数组的长度。你可以通过传递数组的长度作为额外的参数来解决这个问题。
    //int length = sizeof(arr) / sizeof(arr[0]);

    for (int i = 0; i < length; i++)
    {
        printf("数组元素: %d\n", arr[i]);
    }
}

/// <summary>
/// 数组插入元素
/// </summary>
/// <param name="arr">要插入的数组</param>
/// <param name="length">数组插入元素前的长度</param>
/// <param name="index">要插入的位置</param>
/// <param name="data">要插入的值</param>
void insertElement(int arr[], int &length, int index, int data) {
    if (index < 0 || index > length) {
        printf("索引越界!\n");
        return;
    }

    if (length >= MAX_SIZE) {
        printf("数组元素已满!\n");
        return;
    }

    for (int i = length + 1; i > index; i--)
    {
        arr[i] = arr[i - 1];
    }
    arr[index] = data;
    length++;
}

/// <summary>
/// 数组删除元素
/// </summary>
/// <param name="arr">要删除的数组</param>
/// <param name="length">数组删除元素前的长度</param>
/// <param name="index">要删除的元素的索引</param>
/// <returns></returns>
int deleteElement(int arr[], int &length, int index) {
    if (index < 0 || index >= length) {
        printf("索引越界!\n");
        return -1;
    }

    if (length <= 0) {
        printf("数组长度为空\n");
        return-1;
    }
    int temp = arr[index];
    for (int i = index; i < length; i++)
    {
        arr[i] = arr[i + 1];
    }
    length--;
    return temp;
}

int main()
{
    int arr[MAX_SIZE];              //为数组开辟的存储空间的大小为MAX_SIZE
    int length = 6;
    initArr(arr, length);
    printArr(arr, length);

    insertElement(arr, length, 1, 9999);
    printf("--------------插入元素后--------------\n");
    printArr(arr, length);

    int element = deleteElement(arr, length, 5);
    if (element != -1) {
        printf("--------------删除元素后--------------\n");
        printf("删除的元素: %d\n", element);
        printArr(arr, length);
    }
    
}

代码1: 顺序表(数组)的插入删除操作

2. 单链表插入删除操作

插入策略:

单链表的插入操作

删除策略:

单链表的删除操作

#include <iostream>

typedef struct LNode {
    int data;
    struct LNode* next;
}LNode;


/// <summary>
/// 判断链表是否非空
/// </summary>
/// <param name="p"></param>
bool linkedListIsNotNull(LNode* p) {
    if (p == NULL) {
        return false;
    }
    return true;
}

/// <summary>
/// 遍历输出链表各个结点的值
/// </summary>
/// <param name="firstNode"></param>
void traverseLinkedList(LNode* p) {
    while (p != NULL) {
        // 对当前节点进行操作，打印节点的数据
        printf("%d\n", p->data);

        // 移动到下一个节点
        p = p->next;
    }
}

/// <summary>
/// 插入元素
/// </summary>
/// <param name="p">插入位置前面的元素</param>
/// <param name="q">要插入的元素</param>
void insertElement(LNode *p, LNode *q) {
    q->next = p->next;
    p->next = q;
}

/// <summary>
/// 删除元素
/// </summary>
/// <param name="p">要删除的元素的前一个元素</param>
/// <returns></returns>
LNode* deleteElement(LNode* p) {
    LNode* q = p->next;
    p->next = q->next;
    q->next = NULL;
    return q;
}

int main()
{
    LNode* A;
    A = new LNode;
    LNode* B;
    B = new LNode;
    LNode* C;
    C = new LNode;

    A->data = 10;
    B->data = 20;
    C->data = 30;

    A->next = B;
    B->next = NULL;
    C->next = NULL;

    LNode* p = A;        
    LNode* q = C;
    bool isNotNull = linkedListIsNotNull(p);
    if (isNotNull) {
        insertElement(p, q);
        traverseLinkedList(p);
        printf("---------------------------\n");
        LNode* q =deleteElement(p);
        free(q);
        traverseLinkedList(p);
    }
    else {
        printf("链表为空!");
    }
}

代码2: 单链表的插入删除操作

对比:

在顺序表中和删除元素可能(不是一定)会移动大量元素的连带操作(插入或删除操作发生在表尾位置例外), 而链表不会, 链表只需修改指针, 元素无需移动.