顺序表作业

#include <stdio.h>
#include <stdlib.h>
 
#define LIST_MAX_LENGTH 10
 
typedef struct SequentialList {
    int actualLength;
    int data[LIST_MAX_LENGTH];
} *SequentialListPtr;
 
void outputList(SequentialListPtr paraList) {
    for(int i = 0; i < paraList->actualLength; i ++) {
        printf("%d ", paraList->data[i]);
    }
    printf("\r\n");
}
 
void outputMemory(SequentialListPtr paraListPtr) {
    printf("结构体的地址: %p\r\n", (void*)paraListPtr);
    printf("actualLength 的地址: %p\r\n", (void*)&paraListPtr->actualLength);
    printf("data 的地址: %p\r\n", (void*)&paraListPtr->data);
    printf("第一个数据元素的地址: %p\r\n", (void*)&paraListPtr->data[0]);
    printf("第二个数据元素的地址: %p\r\n", (void*)&paraListPtr->data[1]);
}
 
SequentialListPtr sequentialListInit(int paraData[], int paraLength) {
    SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(struct SequentialList));
    if (resultPtr == NULL) {
        perror("内存分配失败");
        return NULL;
    }
 
    if (paraLength > LIST_MAX_LENGTH) {
        printf("警告：输入长度超过最大允许长度。\n");
        paraLength = LIST_MAX_LENGTH;
    }
 
    for (int i = 0; i < paraLength; i++) {
        resultPtr->data[i] = paraData[i];
    }
    resultPtr->actualLength = paraLength;
    
    return resultPtr;
}
 
int sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) {
    if (paraListPtr->actualLength >= LIST_MAX_LENGTH) {
        printf("无法插入元素：列表已满。\r\n");
        return -1;
    }
 
    if (paraPosition < 0 || paraPosition > paraListPtr->actualLength) {
        printf("无法插入元素：无效位置。\n");
        return -1;
    }
 
    for (int i = paraListPtr->actualLength; i > paraPosition; i--) {
        paraListPtr->data[i] = paraListPtr->data[i - 1];
    }
 
    paraListPtr->data[paraPosition] = paraValue;
    paraListPtr->actualLength++;
 
    return 0;
}
 
void sequentialInsertTest() {
    int i;
    int tempArray[5] = {3, 5, 2, 7, 4};
 
    printf("---- sequentialInsertTest 开始. ----\r\n");
 
    SequentialListPtr tempList = sequentialListInit(tempArray, 5);
    if (tempList == NULL) return;
 
    printf("初始化后，列表是：");
    outputList(tempList);
 
    printf("现在插入到第一个位置，列表是：");
    sequentialListInsert(tempList, 0, 8);
    outputList(tempList);
 
    printf("现在插入到最后一个位置，列表是：");
    sequentialListInsert(tempList, tempList->actualLength, 9);
    outputList(tempList);
 
    printf("现在插入到超出尾部的位置。\r\n");
    if (sequentialListInsert(tempList, LIST_MAX_LENGTH + 1, 9) == -1) {
        printf("超出尾部插入失败，符合预期。\n");
    }
    printf("列表是：");
    outputList(tempList);
 
    for (i = 0; i < 5; i++) {
        printf("插入 %d。\r\n", (i + 10));
        sequentialListInsert(tempList, 0, (i + 10));
        outputList(tempList);
    }
 
    printf("---- sequentialInsertTest 结束. ----\r\n");
 
    free(tempList);
}
 
int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition) {
    if (paraPosition < 0 || paraPosition >= paraListPtr->actualLength) {
        printf("无效位置: %d。\r\n", paraPosition);
        return -1;
    }
 
    int resultValue = paraListPtr->data[paraPosition];
    for (int i = paraPosition; i < paraListPtr->actualLength - 1; i++) {
        paraListPtr->data[i] = paraListPtr->data[i + 1];
    }
 
    paraListPtr->actualLength--;
    return resultValue;
}
 
void sequentialDeleteTest() {
    int tempArray[5] = {3, 5, 2, 7, 4};
 
    printf("---- sequentialDeleteTest 开始. ----\r\n");
 
    SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	if (tempList == NULL) return;
 
    printf("初始化后，列表是：");
    outputList(tempList);
 
    printf("现在删除第一个元素，列表是：");
    sequentialListDelete(tempList, 0);
    outputList(tempList);
 
    printf("现在删除最后一个元素，列表是：");
    sequentialListDelete(tempList, tempList->actualLength -1);
    outputList(tempList);
 
    printf("现在删除第二个元素，列表是：");
    sequentialListDelete(tempList, 1);
    outputList(tempList);
 
    printf("现在尝试删除无效位置的元素：");
		if (sequentialListDelete(tempList, 5) == -1) {
			printf("删除无效位置的元素失败。\n");
		}
    outputList(tempList);
 
    printf("---- sequentialDeleteTest 结束. ----\r\n");
 
	outputMemory(tempList);
    free(tempList);
}
 
int locateElement(SequentialListPtr paraListPtr, int paraValue) {
    for (int i = 0; i < paraListPtr->actualLength; i++) {
        if (paraListPtr->data[i] == paraValue) {
            return i;
        }
    }
    return -1;
}
 
int getElement(SequentialListPtr paraListPtr, int paraPosition) {
    if (paraPosition < 0 || paraPosition >= paraListPtr->actualLength) {
        printf("无效位置: %d。\r\n", paraPosition);
        return -1;
    }
    return paraListPtr->data[paraPosition];
}
 
void clearList(SequentialListPtr paraListPtr) {
    paraListPtr->actualLength = 0;
}
 
int main() {
    sequentialInsertTest();
    sequentialDeleteTest();
    return 0;
}

结果:

10 8 3 5 2 7 4 9
插入 11。
11 10 8 3 5 2 7 4 9
插入 12。
12 11 10 8 3 5 2 7 4 9
插入 13。
无法插入元素：列表已满。
12 11 10 8 3 5 2 7 4 9
插入 14。
无法插入元素：列表已满。
12 11 10 8 3 5 2 7 4 9
---- sequentialInsertTest 结束. ----
---- sequentialDeleteTest 开始. ----
初始化后，列表是：3 5 2 7 4
现在删除第一个元素，列表是：5 2 7 4
现在删除最后一个元素，列表是：5 2 7
现在删除第二个元素，列表是：5 7
现在尝试删除无效位置的元素：无效位置: 5。
删除无效位置的元素失败。
5 7
---- sequentialDeleteTest 结束. ----
结构体的地址: 0000000000A013D0
actualLength 的地址: 0000000000A013D0
data 的地址: 0000000000A013D4
第一个数据元素的地址: 0000000000A013D4
第二个数据元素的地址: 0000000000A013D8
 
--------------------------------
Process exited after 0.02935 seconds with return value 0
请按任意键继续. . .