1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <assert.h>
4
#define INIT_SIZE 5  // 初始容量
5

6
typedef struct {
7
    int* head;    // 动态数组基地址
8
    int length;   // 当前元素个数
9
    int size;     // 总存储容量
10
} Table;
11

12
// 初始化顺序表
13
void initTable(Table* t) {
14
    t->head = (int*)malloc(INIT_SIZE * sizeof(int));
15
    if (!t->head) {
16
        printf("内存分配失败\n");
17
        exit(EXIT_FAILURE);
18
    }
19
    t->length = 0;
20
    t->size = INIT_SIZE;
21
}
22

23
// 插入元素（位置从1开始）
24
void insertTable(Table* t, int elem, int pos) {
25
    if (pos < 1 || pos > t->length + 1) {
26
        printf("非法插入位置: %d\n", pos);
27
        return;
28
    }
29

30
    // 容量检查与扩容
31
    if (t->length == t->size) {
32
        int new_size = t->size * 2;  // 容量翻倍
33
        int* new_head = (int*)realloc(t->head, new_size * sizeof(int));
34
        if (!new_head) {
35
            printf("扩容失败\n");
36
            return;
37
        }
38
        t->head = new_head;
39
        t->size = new_size;
40
        printf("已扩容至 %d\n", new_size);
41
    }
42

43
    // 元素后移
44
    for (int i = t->length; i >= pos; i--) {
45
        t->head[i] = t->head[i - 1];
46
    }
47

48
    t->head[pos - 1] = elem;
49
    t->length++;
50
}
51

52
// 删除元素（位置从1开始）
53
void delTable(Table* t, int pos) {
54
    if (pos < 1 || pos > t->length) {
55
        printf("非法删除位置: %d\n", pos);
56
        return;
57
    }
58

59
    // 元素前移覆盖
60
    for (int i = pos; i < t->length; i++) {
61
        t->head[i - 1] = t->head[i];
62
    }
63
    t->length--;
64
}
65

66
// 查找元素（返回位置，从1开始）
67
int selectTable(Table* t, int elem) {
68
    for (int i = 0; i < t->length; i++) {
69
        if (t->head[i] == elem) {
70
            return i + 1;// 返回元素位置
71
        }
72
    }
73
    return -1;  // 未找到
74
}
75

76
// 修改元素值
77
void amendTable(Table* t, int old_elem, int new_elem) {
78
    int pos = selectTable(t, old_elem); // 查找元素
79
    if (pos == -1) {
80
        printf("元素 %d 不存在\n", old_elem);
81
        return;
82
    }
83
    t->head[pos - 1] = new_elem;
84
}
85

86
// 逆序顺序表
87
void reverseTable(Table* t) {
88
    for (int i = 0; i < t->length / 2; i++) {
89
        int temp = t->head[i];
90
        t->head[i] = t->head[t->length - 1 - i];
91
        t->head[t->length - 1 - i] = temp;
92
    }
93
}
94

95
// 销毁顺序表
96
void destroyTable(Table* t) {
97
    free(t->head);
98
    t->head = NULL;
99
    t->length = 0;
100
    t->size = 0;
101
}
102

103
// 打印顺序表
104
void displayTable(Table* t) {
105
    printf("[当前表长: %d, 总容量: %d]\n", t->length, t->size);
106
    for (int i = 0; i < t->length; i++) {
107
        printf("%d ", t->head[i]);
108
    }
109
    printf("\n\n");
110
}
111

112
int main() {
113
    Table my_table; //声明一个名为 my_table 的变量，其类型为 Table 结构体
114

115
    // 1. 初始化
116
    initTable(&my_table);
117
    //&my_table的作用是将结构体的地址传递给函数，使函数能通过指针直接修改原始变量
118
    printf("=== 初始化顺序表 ===\n");
119
    displayTable(&my_table);
120

121
    // 2. 插入初始元素
122
    for (int i = 1; i <= 5; i++) {
123
        insertTable(&my_table, i, i);
124
    }
125
    printf("=== 插入5个元素 ===\n");
126
    displayTable(&my_table);
127

128
    // 3. 测试扩容插入
129
    insertTable(&my_table, 6, 3);  // 在第3位插入6
130
    printf("=== 插入第6个元素触发扩容 ===\n");
131
    displayTable(&my_table);
132

133
    // 4. 删除元素
134
    delTable(&my_table, 2);  // 删除第2个元素
135
    printf("=== 删除第2个元素 ===\n");
136
    displayTable(&my_table);
137

138
    // 5. 查找元素
139
    int target = 6;
140
    int pos = selectTable(&my_table, target);
141
    printf("=== 查找元素 %d ===\n", target);
142
    if (pos != -1) {
143
        printf("元素 %d 位于第 %d 位\n", target, pos);
144
    } else {
145
        printf("元素不存在\n");
146
    }
147

148
    // 6. 修改元素
149
    amendTable(&my_table, 6, 66);
150
    printf("=== 修改元素 6 → 66 ===\n");
151
    displayTable(&my_table);
152

153
    // 7. 逆序操作
154
    reverseTable(&my_table);
155
    printf("=== 逆序顺序表 ===\n");
156
    displayTable(&my_table);
157

158
    // 8. 销毁顺序表
159
    destroyTable(&my_table);
160
    printf("=== 销毁后的状态 ===\n");
161
    printf("指针状态: %s\n", (my_table.head == NULL) ? "已释放" : "未释放");
162

163
    return 0;
164
}