02 顺序表基本操作

顺序表基本操作实现

  1 #include<stdio.h>
  2 #define Capacity 5
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 //给空表添加元素
 43 void addElem(int e) {
 44     list.len += 1;
 45         list.ElemSet[list.len - 1] = e;
 46         printf("添加元素后得到的表是：\n");
 47         showList();
 48 }
 49 
 50 //在空表中插入元素
 51 void insertElem(int e, int insertIndex) {
 52     list.len++;
 53     /*for (int i = insertIndex;i <= list.len;i++) {
 54         list.ElemSet[i + 1] = list.ElemSet[i];
 55         showList();
 56     }
 57     list.ElemSet[insertIndex] = e;*/
 58     for (int i = list.len-1;i >=insertIndex;i--) {
 59         list.ElemSet[i+1] = list.ElemSet[i];
 60         //showList();
 61     }
 62     list.ElemSet[insertIndex] = e;
 63     printf("插入元素后得到的表是：\n");
 64     showList();
 65 }
 66 
 67 //顺序表删除元素
 68 void deleElem(int delIndex) {
 69     list.len--;
 70     for (int i = delIndex;i < list.len;i++) {
 71         list.ElemSet[i] = list.ElemSet[i+1];
 72     }
 73     printf("删除元素后得到的表是：\n");
 74     showList();
 75 }
 76 
 77 //顺序表查找元素
 78 int  searchElem(int e) {
 79     for (int i = 0;i < list.len;i++) {
 80         if (list.ElemSet[i] == e) {
 81             return i;
 82         }
 83     }
 84 }
 85 
 86 //寻找特定元素的前驱
 87 int preElem(int e) {
 88     int e_index = searchElem(e);
 89     return list.ElemSet[e_index - 1];
 90 }
 91 
 92 //寻找特定元素的后继
 93 int nextElem(int e) {
 94     int e_index = searchElem(e);
 95     return list.ElemSet[e_index + 1];
 96 }
 97 
 98 
 99 //顺序表更改元素
100 void changeElem(int e1, int e2) {  //用e2更改1
101     int e1_index = searchElem(e1);
102     list.ElemSet[e1_index] = e2;
103     printf("更改后得到的表是：\n");
104     showList();
105 }
106 
107 //将表重置为空表
108 void clearList() {
109     for (int i = 0;i < list.capacity;i++) {
110         list.ElemSet[i] = 0;
111     }
112     printf("表已经置空\n");
113     showList();
114 }
115 
116 //销毁表
117 void  destroyList() {
118     list.len = 0;
119     printf("表已经销毁\n");
120     showList();
121 }
122 
123 
124 void main() {
125     int add_e = 0;
126     initList();
127     showList();
128     printf("请输入你要添加的元素:");
129     scanf("%d", &add_e);
130     addElem(add_e);
131     insertElem(88, 2);
132     deleElem(0);
133     printf("查找元素3的索引：%d\n", searchElem(3));
134     printf("元素3的前驱是:%d\n", preElem(3));
135     printf("元素3的后继是:%d\n", nextElem(3));
136     changeElem(1, 11);
137     clearList();
138     destroyList();
139 }

 添加操作升级：

①数据改为用户输入

②添加限制

#include<stdio.h>
#define Capacity 5

//自定义顺序表
struct List{
    int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
    int len; //顺序表的长度
    int capacity; //顺序表的容量
}list;

//顺序表的初始化，即初步建立一个顺序表
//1,给ElemSet动态数组申请足够大小的物理空间
//2,给len和capacity赋初值
void initList() {
    list.len = 0; //空表的长度初始化为0
    list.capacity = 5; //空表的初始存储空间为10个int
    list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
    if (!list.ElemSet) {
        printf("初始化失败\n");
        return;
    }
    else {
        printf("成功创建动态数组\n");
        //给表中初始化5个数据
        for (int i = 0;i < 5;i++) {
            list.ElemSet[i] = i;
            list.len++;
        }
    }
}

//打印顺序表中的全部元素
void showList() {
    //printf("表中数据是：\n");
    for (int i = 0;i < list.len;i++) {
        printf("%d  ", list.ElemSet[i]);
    }
    printf("\n");
    
}

//给空表添加元素
void addElem(int e) {
    if (list.len == list.capacity) {
        printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
        list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
        list.capacity++;
        if (!list.ElemSet) {
            printf("重新开辟内存空间失败\n");
        }
        else {
            addElem( e);
        }
    }
    else {
        list.len += 1;
        list.ElemSet[list.len - 1] = e;
        printf("添加元素后得到的表是：\n");
        showList();
    }
}

//在空表中插入元素
void insertElem(int e, int insertIndex) {
    list.len++;
    /*for (int i = insertIndex;i <= list.len;i++) {
        list.ElemSet[i + 1] = list.ElemSet[i];
        showList();
    }
    list.ElemSet[insertIndex] = e;*/
    for (int i = list.len-1;i >=insertIndex;i--) {
        list.ElemSet[i+1] = list.ElemSet[i];
        //showList();
    }
    list.ElemSet[insertIndex] = e;
    printf("插入元素后得到的表是：\n");
    showList();
}

//顺序表删除元素
void deleElem(int delIndex) {
    list.len--;
    for (int i = delIndex;i < list.len;i++) {
        list.ElemSet[i] = list.ElemSet[i+1];
    }
    printf("删除元素后得到的表是：\n");
    showList();
}

//顺序表查找元素
int  searchElem(int e) {
    for (int i = 0;i < list.len;i++) {
        if (list.ElemSet[i] == e) {
            return i;
        }
    }
}

//寻找特定元素的前驱
int preElem(int e) {
    int e_index = searchElem(e);
    return list.ElemSet[e_index - 1];
}

//寻找特定元素的后继
int nextElem(int e) {
    int e_index = searchElem(e);
    return list.ElemSet[e_index + 1];
}


//顺序表更改元素
void changeElem(int e1, int e2) {  //用e2更改1
    int e1_index = searchElem(e1);
    list.ElemSet[e1_index] = e2;
    printf("更改后得到的表是：\n");
    showList();
}

//将表重置为空表
void clearList() {
    for (int i = 0;i < list.capacity;i++) {
        list.ElemSet[i] = 0;
    }
    printf("表已经置空\n");
    showList();
}

//销毁表
void  destroyList() {
    list.len = 0;
    printf("表已经销毁\n");
    showList();
}


void main() {
    int add_e = 0;
    initList();
    showList();
    printf("请输入你要添加的元素:");
    scanf("%d", &add_e);
    addElem(add_e);
    /*insertElem(88, 2);
    deleElem(0);
    printf("查找元素3的索引：%d\n", searchElem(3));
    printf("元素3的前驱是:%d\n", preElem(3));
    printf("元素3的后继是:%d\n", nextElem(3));
    changeElem(1, 11);
    clearList();
    destroyList();*/
}

 插入操作升级

①插入元素变成用户输入

②插入位置的判断

③空间不够的处理

  1 #include<stdio.h>
  2 #define Capacity 6
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 
 43 
 44 //给空表添加元素
 45 void addElem(int e) {
 46     if (list.len == list.capacity) {
 47         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 48         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 49         list.capacity++;
 50         if (!list.ElemSet) {
 51             printf("重新开辟内存空间失败\n");
 52         }
 53     }
 54     list.len += 1;
 55     list.ElemSet[list.len - 1] = e;
 56     printf("添加元素后得到的表是：\n");
 57     showList();
 58     printf("表的长度是:%d\n", list.len);
 59 }
 60 
 61 
 62 //在空表中插入元素
 63 void insertElem(int e, int insertIndex) {
 64     /*for (int i = insertIndex;i <= list.len;i++) {
 65         list.ElemSet[i + 1] = list.ElemSet[i];
 66         showList();
 67     }
 68     list.ElemSet[insertIndex] = e;*/
 69     if (insertIndex < 0 || insertIndex >= list.len) {
 70         printf("插入位置错误\n");
 71         return;
 72     }
 73     else if(list.len==list.capacity){
 74         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 75         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 76         if (!list.ElemSet) {
 77             printf("重新开辟空间失败\n");
 78         }
 79 
 80     }
 81     list.len++;
 82     for (int i = list.len-1;i >=insertIndex;i--) {
 83         list.ElemSet[i+1] = list.ElemSet[i];
 84         //showList();
 85     }
 86     list.ElemSet[insertIndex] = e;
 87     printf("插入元素后得到的表是：\n");
 88     showList();
 89     printf("表的长度是：%d", list.len);
 90 }
 91 
 92 //顺序表删除元素
 93 void deleElem(int delIndex) {
 94     list.len--;
 95     for (int i = delIndex;i < list.len;i++) {
 96         list.ElemSet[i] = list.ElemSet[i+1];
 97     }
 98     printf("删除元素后得到的表是：\n");
 99     showList();
100 }
101 
102 //顺序表查找元素
103 int  searchElem(int e) {
104     for (int i = 0;i < list.len;i++) {
105         if (list.ElemSet[i] == e) {
106             return i;
107         }
108     }
109 }
110 
111 //寻找特定元素的前驱
112 int preElem(int e) {
113     int e_index = searchElem(e);
114     return list.ElemSet[e_index - 1];
115 }
116 
117 //寻找特定元素的后继
118 int nextElem(int e) {
119     int e_index = searchElem(e);
120     return list.ElemSet[e_index + 1];
121 }
122 
123 
124 //顺序表更改元素
125 void changeElem(int e1, int e2) {  //用e2更改1
126     int e1_index = searchElem(e1);
127     list.ElemSet[e1_index] = e2;
128     printf("更改后得到的表是：\n");
129     showList();
130 }
131 
132 //将表重置为空表
133 void clearList() {
134     for (int i = 0;i < list.capacity;i++) {
135         list.ElemSet[i] = 0;
136     }
137     printf("表已经置空\n");
138     showList();
139 }
140 
141 //销毁表
142 void  destroyList() {
143     list.len = 0;
144     printf("表已经销毁\n");
145     showList();
146 }
147 
148 
149 void main() {
150     int add_e = 0;
151     int insert_e = 0;
152     int insert_index = 0;
153     initList();
154     showList();
155     /*printf("请输入你要添加的元素:");
156     scanf("%d", &add_e);
157     addElem(add_e);*/
158 
159     printf("请输入你要插入的元素:");
160     scanf("%d", &insert_e);
161     printf("请输入你要插入位置的索引:");
162     scanf("%d", &insert_index);
163     insertElem(insert_e,insert_index);
164     /*deleElem(0);
165     printf("查找元素3的索引：%d\n", searchElem(3));
166     printf("元素3的前驱是:%d\n", preElem(3));
167     printf("元素3的后继是:%d\n", nextElem(3));
168     changeElem(1, 11);
169     clearList();
170     destroyList();*/
171 }

 删除操作升级：

①删除元素改为用户输入

②删除元素判断（根据索引判断是否存在）

  1 #include<stdio.h>
  2 #define Capacity 6
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 
 43 
 44 //给空表添加元素
 45 void addElem(int e) {
 46     if (list.len == list.capacity) {
 47         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 48         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 49         list.capacity++;
 50         if (!list.ElemSet) {
 51             printf("重新开辟内存空间失败\n");
 52         }
 53     }
 54     list.len += 1;
 55     list.ElemSet[list.len - 1] = e;
 56     printf("添加元素后得到的表是：\n");
 57     showList();
 58     printf("表的长度是:%d\n", list.len);
 59 }
 60 
 61 
 62 //在空表中插入元素
 63 void insertElem(int e, int insertIndex) {
 64     /*for (int i = insertIndex;i <= list.len;i++) {
 65         list.ElemSet[i + 1] = list.ElemSet[i];
 66         showList();
 67     }
 68     list.ElemSet[insertIndex] = e;*/
 69     if (insertIndex < 0 || insertIndex >= list.len) {
 70         printf("插入位置错误\n");
 71         return;
 72     }
 73     else if(list.len==list.capacity){
 74         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 75         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 76         if (!list.ElemSet) {
 77             printf("重新开辟空间失败\n");
 78         }
 79 
 80     }
 81     list.len++;
 82     for (int i = list.len-1;i >=insertIndex;i--) {
 83         list.ElemSet[i+1] = list.ElemSet[i];
 84         //showList();
 85     }
 86     list.ElemSet[insertIndex] = e;
 87     printf("插入元素后得到的表是：\n");
 88     showList();
 89     printf("表的长度是：%d", list.len);
 90 }
 91 
 92 //顺序表删除元素
 93 void deleElem(int e) {
 94     int e_index = searchElem(e);
 95     if (e_index < 0 || e_index >= list.len) {
 96         printf("没有这个元素\n");
 97         return;
 98     }
 99     list.len--;
100     for (int i = e_index;i < list.len;i++) {
101         list.ElemSet[i] = list.ElemSet[i+1];
102     }
103     printf("删除元素后得到的表是：\n");
104     showList();
105     printf("表的长度是：%d\n", list.len);
106 }
107 
108 //顺序表查找元素
109 int  searchElem(int e) {
110     for (int i = 0;i < list.len;i++) {
111         if (list.ElemSet[i] == e) {
112             return i;
113         }
114     }
115 }
116 
117 //寻找特定元素的前驱
118 int preElem(int e) {
119     int e_index = searchElem(e);
120     return list.ElemSet[e_index - 1];
121 }
122 
123 //寻找特定元素的后继
124 int nextElem(int e) {
125     int e_index = searchElem(e);
126     return list.ElemSet[e_index + 1];
127 }
128 
129 
130 //顺序表更改元素
131 void changeElem(int e1, int e2) {  //用e2更改1
132     int e1_index = searchElem(e1);
133     list.ElemSet[e1_index] = e2;
134     printf("更改后得到的表是：\n");
135     showList();
136 }
137 
138 //将表重置为空表
139 void clearList() {
140     for (int i = 0;i < list.capacity;i++) {
141         list.ElemSet[i] = 0;
142     }
143     printf("表已经置空\n");
144     showList();
145 }
146 
147 //销毁表
148 void  destroyList() {
149     list.len = 0;
150     printf("表已经销毁\n");
151     showList();
152 }
153 
154 
155 void main() {
156     int add_e = 0;
157     int insert_e = 0;
158     int insert_index = 0;
159     int del_e = 0;
160     initList();
161     showList();
162     /*printf("请输入你要添加的元素:");
163     scanf("%d", &add_e);
164     addElem(add_e);*/
165 
166     /*printf("请输入你要插入的元素:");
167     scanf("%d", &insert_e);
168     printf("请输入你要插入位置的索引:");
169     scanf("%d", &insert_index);
170     insertElem(insert_e,insert_index);*/
171 
172     printf("请输入要删除元素：");
173     scanf("%d", &del_e);
174     deleElem(del_e);
175 
176     /*printf("查找元素3的索引：%d\n", searchElem(3));
177     printf("元素3的前驱是:%d\n", preElem(3));
178     printf("元素3的后继是:%d\n", nextElem(3));
179     changeElem(1, 11);
180     clearList();
181     destroyList();*/
182 }

 

 查找操作升级

①查找元素改为用户输入

②查找情况判断（不存在返回 -1）

  1 #include<stdio.h>
  2 #define Capacity 6
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 
 43 
 44 //给空表添加元素
 45 void addElem(int e) {
 46     if (list.len == list.capacity) {
 47         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 48         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 49         list.capacity++;
 50         if (!list.ElemSet) {
 51             printf("重新开辟内存空间失败\n");
 52         }
 53     }
 54     list.len += 1;
 55     list.ElemSet[list.len - 1] = e;
 56     printf("添加元素后得到的表是：\n");
 57     showList();
 58     printf("表的长度是:%d\n", list.len);
 59 }
 60 
 61 
 62 //在空表中插入元素
 63 void insertElem(int e, int insertIndex) {
 64     /*for (int i = insertIndex;i <= list.len;i++) {
 65         list.ElemSet[i + 1] = list.ElemSet[i];
 66         showList();
 67     }
 68     list.ElemSet[insertIndex] = e;*/
 69     if (insertIndex < 0 || insertIndex >= list.len) {
 70         printf("插入位置错误\n");
 71         return;
 72     }
 73     else if(list.len==list.capacity){
 74         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 75         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 76         if (!list.ElemSet) {
 77             printf("重新开辟空间失败\n");
 78         }
 79 
 80     }
 81     list.len++;
 82     for (int i = list.len-1;i >=insertIndex;i--) {
 83         list.ElemSet[i+1] = list.ElemSet[i];
 84         //showList();
 85     }
 86     list.ElemSet[insertIndex] = e;
 87     printf("插入元素后得到的表是：\n");
 88     showList();
 89     printf("表的长度是：%d", list.len);
 90 }
 91 
 92 //顺序表删除元素
 93 void deleElem(int e) {
 94     int e_index = searchElem(e);
 95     if (e_index < 0 || e_index >= list.len) {
 96         printf("没有这个元素\n");
 97         return;
 98     }
 99     list.len--;
100     for (int i = e_index;i < list.len;i++) {
101         list.ElemSet[i] = list.ElemSet[i+1];
102     }
103     printf("删除元素后得到的表是：\n");
104     showList();
105     printf("表的长度是：%d\n", list.len);
106 }
107 
108 //顺序表查找元素
109 int  searchElem(int e) {
110     for (int i = 0;i < list.len;i++) {
111         if (list.ElemSet[i] == e) {
112             return i;
113         }
114     }
115     return -1;
116 }
117 
118 //寻找特定元素的前驱
119 int preElem(int e) {
120     int e_index = searchElem(e);
121     return list.ElemSet[e_index - 1];
122 }
123 
124 //寻找特定元素的后继
125 int nextElem(int e) {
126     int e_index = searchElem(e);
127     return list.ElemSet[e_index + 1];
128 }
129 
130 
131 //顺序表更改元素
132 void changeElem(int e1, int e2) {  //用e2更改1
133     int e1_index = searchElem(e1);
134     list.ElemSet[e1_index] = e2;
135     printf("更改后得到的表是：\n");
136     showList();
137 }
138 
139 //将表重置为空表
140 void clearList() {
141     for (int i = 0;i < list.capacity;i++) {
142         list.ElemSet[i] = 0;
143     }
144     printf("表已经置空\n");
145     showList();
146 }
147 
148 //销毁表
149 void  destroyList() {
150     list.len = 0;
151     printf("表已经销毁\n");
152     showList();
153 }
154 
155 
156 void main() {
157     int add_e = 0;
158     int insert_e = 0;
159     int insert_index = 0;
160     int del_e = 0;
161     int search_e = 0;
162     initList();
163     showList();
164     /*printf("请输入你要添加的元素:");
165     scanf("%d", &add_e);
166     addElem(add_e);*/
167 
168     /*printf("请输入你要插入的元素:");
169     scanf("%d", &insert_e);
170     printf("请输入你要插入位置的索引:");
171     scanf("%d", &insert_index);
172     insertElem(insert_e,insert_index);*/
173 
174     /*printf("请输入要删除元素：");
175     scanf("%d", &del_e);
176     deleElem(del_e);*/
177 
178     printf("请输入要查找的元素:");
179     scanf("%d", &search_e);
180     if (searchElem(search_e) == -1) {
181         printf("没有找到该元素\n");
182     }
183     else {
184         printf("找到该元素的索引是：%d", searchElem(search_e));
185     }
186 
187     /*printf("元素3的前驱是:%d\n", preElem(3));
188     printf("元素3的后继是:%d\n", nextElem(3));
189     changeElem(1, 11);
190     clearList();
191     destroyList();*/
192 }

 

寻找前驱和后继操作的升级

①所寻找的元素改为用户输入

②前驱和后继存在的判断

  1 #include<stdio.h>
  2 #define Capacity 6
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 
 43 
 44 //给空表添加元素
 45 void addElem(int e) {
 46     if (list.len == list.capacity) {
 47         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 48         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 49         list.capacity++;
 50         if (!list.ElemSet) {
 51             printf("重新开辟内存空间失败\n");
 52         }
 53     }
 54     list.len += 1;
 55     list.ElemSet[list.len - 1] = e;
 56     printf("添加元素后得到的表是：\n");
 57     showList();
 58     printf("表的长度是:%d\n", list.len);
 59 }
 60 
 61 
 62 //在空表中插入元素
 63 void insertElem(int e, int insertIndex) {
 64     /*for (int i = insertIndex;i <= list.len;i++) {
 65         list.ElemSet[i + 1] = list.ElemSet[i];
 66         showList();
 67     }
 68     list.ElemSet[insertIndex] = e;*/
 69     if (insertIndex < 0 || insertIndex >= list.len) {
 70         printf("插入位置错误\n");
 71         return;
 72     }
 73     else if(list.len==list.capacity){
 74         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 75         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 76         if (!list.ElemSet) {
 77             printf("重新开辟空间失败\n");
 78         }
 79 
 80     }
 81     list.len++;
 82     for (int i = list.len-1;i >=insertIndex;i--) {
 83         list.ElemSet[i+1] = list.ElemSet[i];
 84         //showList();
 85     }
 86     list.ElemSet[insertIndex] = e;
 87     printf("插入元素后得到的表是：\n");
 88     showList();
 89     printf("表的长度是：%d", list.len);
 90 }
 91 
 92 //顺序表删除元素
 93 void deleElem(int e) {
 94     int e_index = searchElem(e);
 95     if (e_index < 0 || e_index >= list.len) {
 96         printf("没有这个元素\n");
 97         return;
 98     }
 99     list.len--;
100     for (int i = e_index;i < list.len;i++) {
101         list.ElemSet[i] = list.ElemSet[i+1];
102     }
103     printf("删除元素后得到的表是：\n");
104     showList();
105     printf("表的长度是：%d\n", list.len);
106 }
107 
108 //顺序表查找元素
109 int  searchElem(int e) {
110     for (int i = 0;i < list.len;i++) {
111         if (list.ElemSet[i] == e) {
112             return i;
113         }
114     }
115     return -1;
116 }
117 
118 //寻找特定元素的前驱
119 int preElem(int e) {
120     if (searchElem(e) == 0) {
121         return -1;
122     }
123     int e_index = searchElem(e);
124     return list.ElemSet[e_index - 1];
125 }
126 
127 //寻找特定元素的后继
128 int nextElem(int e) {
129     if (searchElem(e) == list.len-1) {
130         return -1;
131     }
132     int e_index = searchElem(e);
133     return list.ElemSet[e_index + 1];
134 }
135 
136 
137 //顺序表更改元素
138 void changeElem(int e1, int e2) {  //用e2更改1
139     int e1_index = searchElem(e1);
140     list.ElemSet[e1_index] = e2;
141     printf("更改后得到的表是：\n");
142     showList();
143 }
144 
145 //将表重置为空表
146 void clearList() {
147     for (int i = 0;i < list.capacity;i++) {
148         list.ElemSet[i] = 0;
149     }
150     printf("表已经置空\n");
151     showList();
152 }
153 
154 //销毁表
155 void  destroyList() {
156     list.len = 0;
157     printf("表已经销毁\n");
158     showList();
159 }
160 
161 
162 void main() {
163     int add_e = 0;
164     int insert_e = 0;
165     int insert_index = 0;
166     int del_e = 0;
167     int search_e = 0;
168     initList();
169     showList();
170     /*printf("请输入你要添加的元素:");
171     scanf("%d", &add_e);
172     addElem(add_e);*/
173 
174     /*printf("请输入你要插入的元素:");
175     scanf("%d", &insert_e);
176     printf("请输入你要插入位置的索引:");
177     scanf("%d", &insert_index);
178     insertElem(insert_e,insert_index);*/
179 
180     /*printf("请输入要删除元素：");
181     scanf("%d", &del_e);
182     deleElem(del_e);*/
183 
184     /*printf("请输入要查找的元素:");
185     scanf("%d", &search_e);
186     if (searchElem(search_e) == -1) {
187         printf("没有找到该元素\n");
188     }
189     else {
190         printf("找到该元素的索引是：%d", searchElem(search_e));
191     }*/
192 
193     printf("请输入要寻找哪个元素的前驱：");
194     scanf("%d", &search_e);
195     if (preElem(search_e) == -1) {
196         printf("该元素没有前驱\n");
197     }
198     else {
199         printf("该元素的前驱是：%d\n", preElem(search_e));
200     }
201     printf("请输入要寻找哪个元素的后继：");
202     scanf("%d", &search_e);
203     if (nextElem(search_e) == -1) {
204         printf("该元素没有后继\n");
205     }
206     else {
207         printf("该元素的后继是：%d\n", nextElem(search_e));
208     }
209     
210     
211     /*changeElem(1, 11);
212     clearList();
213     destroyList();*/
214 }

 

 更改元素操作升级

①被更改的值和更改后的值改为用户输入

②是否存在该元素可被更改判断

  1 #include<stdio.h>
  2 #define Capacity 6
  3 
  4 //自定义顺序表
  5 struct List{
  6     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
  7     int len; //顺序表的长度
  8     int capacity; //顺序表的容量
  9 }list;
 10 
 11 //顺序表的初始化，即初步建立一个顺序表
 12 //1,给ElemSet动态数组申请足够大小的物理空间
 13 //2,给len和capacity赋初值
 14 void initList() {
 15     list.len = 0; //空表的长度初始化为0
 16     list.capacity = 5; //空表的初始存储空间为10个int
 17     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 18     if (!list.ElemSet) {
 19         printf("初始化失败\n");
 20         return;
 21     }
 22     else {
 23         printf("成功创建动态数组\n");
 24         //给表中初始化5个数据
 25         for (int i = 0;i < 5;i++) {
 26             list.ElemSet[i] = i;
 27             list.len++;
 28         }
 29     }
 30 }
 31 
 32 //打印顺序表中的全部元素
 33 void showList() {
 34     //printf("表中数据是：\n");
 35     for (int i = 0;i < list.len;i++) {
 36         printf("%d  ", list.ElemSet[i]);
 37     }
 38     printf("\n");
 39     
 40 }
 41 
 42 
 43 
 44 //给空表添加元素
 45 void addElem(int e) {
 46     if (list.len == list.capacity) {
 47         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 48         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 49         list.capacity++;
 50         if (!list.ElemSet) {
 51             printf("重新开辟内存空间失败\n");
 52         }
 53     }
 54     list.len += 1;
 55     list.ElemSet[list.len - 1] = e;
 56     printf("添加元素后得到的表是：\n");
 57     showList();
 58     printf("表的长度是:%d\n", list.len);
 59 }
 60 
 61 
 62 //在空表中插入元素
 63 void insertElem(int e, int insertIndex) {
 64     /*for (int i = insertIndex;i <= list.len;i++) {
 65         list.ElemSet[i + 1] = list.ElemSet[i];
 66         showList();
 67     }
 68     list.ElemSet[insertIndex] = e;*/
 69     if (insertIndex < 0 || insertIndex >= list.len) {
 70         printf("插入位置错误\n");
 71         return;
 72     }
 73     else if(list.len==list.capacity){
 74         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 75         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 76         if (!list.ElemSet) {
 77             printf("重新开辟空间失败\n");
 78         }
 79 
 80     }
 81     list.len++;
 82     for (int i = list.len-1;i >=insertIndex;i--) {
 83         list.ElemSet[i+1] = list.ElemSet[i];
 84         //showList();
 85     }
 86     list.ElemSet[insertIndex] = e;
 87     printf("插入元素后得到的表是：\n");
 88     showList();
 89     printf("表的长度是：%d", list.len);
 90 }
 91 
 92 //顺序表删除元素
 93 void deleElem(int e) {
 94     int e_index = searchElem(e);
 95     if (e_index < 0 || e_index >= list.len) {
 96         printf("没有这个元素\n");
 97         return;
 98     }
 99     list.len--;
100     for (int i = e_index;i < list.len;i++) {
101         list.ElemSet[i] = list.ElemSet[i+1];
102     }
103     printf("删除元素后得到的表是：\n");
104     showList();
105     printf("表的长度是：%d\n", list.len);
106 }
107 
108 //顺序表查找元素
109 int  searchElem(int e) {
110     for (int i = 0;i < list.len;i++) {
111         if (list.ElemSet[i] == e) {
112             return i;
113         }
114     }
115     return -1;
116 }
117 
118 //寻找特定元素的前驱
119 int preElem(int e) {
120     if (searchElem(e) == 0) {
121         return -1;
122     }
123     int e_index = searchElem(e);
124     return list.ElemSet[e_index - 1];
125 }
126 
127 //寻找特定元素的后继
128 int nextElem(int e) {
129     if (searchElem(e) == list.len-1) {
130         return -1;
131     }
132     int e_index = searchElem(e);
133     return list.ElemSet[e_index + 1];
134 }
135 
136 
137 //顺序表更改元素
138 void changeElem(int e1, int e2) {  //用e2更改1
139     if (searchElem(e1) < 0 || searchElem(e1) >= list.len) {
140         printf("没有这个元素");
141         return;
142     }
143     int e1_index = searchElem(e1);
144     list.ElemSet[e1_index] = e2;
145     printf("更改后得到的表是：\n");
146     showList();
147 }
148 
149 //将表重置为空表
150 void clearList() {
151     for (int i = 0;i < list.capacity;i++) {
152         list.ElemSet[i] = 0;
153     }
154     printf("表已经置空\n");
155     showList();
156 }
157 
158 //销毁表
159 void  destroyList() {
160     list.len = 0;
161     printf("表已经销毁\n");
162     showList();
163 }
164 
165 
166 void main() {
167     int add_e = 0;
168     int insert_e = 0;
169     int insert_index = 0;
170     int del_e = 0;
171     int search_e = 0;
172     int change_e1 = 0,change_e2=0;
173     initList();
174     showList();
175     /*printf("请输入你要添加的元素:");
176     scanf("%d", &add_e);
177     addElem(add_e);*/
178 
179     /*printf("请输入你要插入的元素:");
180     scanf("%d", &insert_e);
181     printf("请输入你要插入位置的索引:");
182     scanf("%d", &insert_index);
183     insertElem(insert_e,insert_index);*/
184 
185     /*printf("请输入要删除元素：");
186     scanf("%d", &del_e);
187     deleElem(del_e);*/
188 
189     /*printf("请输入要查找的元素:");
190     scanf("%d", &search_e);
191     if (searchElem(search_e) == -1) {
192         printf("没有找到该元素\n");
193     }
194     else {
195         printf("找到该元素的索引是：%d", searchElem(search_e));
196     }*/
197 
198     /*printf("请输入要寻找哪个元素的前驱：");
199     scanf("%d", &search_e);
200     if (preElem(search_e) == -1) {
201         printf("该元素没有前驱\n");
202     }
203     else {
204         printf("该元素的前驱是：%d\n", preElem(search_e));
205     }
206     printf("请输入要寻找哪个元素的后继：");
207     scanf("%d", &search_e);
208     if (nextElem(search_e) == -1) {
209         printf("该元素没有后继\n");
210     }
211     else {
212         printf("该元素的后继是：%d\n", nextElem(search_e));
213     }*/
214     
215     printf("请输入要改变的元素:");
216     scanf("%d", &change_e1);
217     printf("请输入改变后的值:");
218     scanf("%d", &change_e2);
219     changeElem(change_e1, change_e2);
220     /*clearList();
221     destroyList();*/
222 }

 

 置空和销毁操作升级

①销毁进一步确定

②销毁操作返回类型改为布尔类型（需要自定义布尔类型返回值）

  1 #include<stdio.h>
  2 #define Capacity 6
  3 typedef int bool;
  4 const int true = 1;
  5 const int false = 0;
  6 
  7 
  8 //自定义顺序表
  9 struct List{
 10     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
 11     int len; //顺序表的长度
 12     int capacity; //顺序表的容量
 13 }list;
 14 
 15 //顺序表的初始化，即初步建立一个顺序表
 16 //1,给ElemSet动态数组申请足够大小的物理空间
 17 //2,给len和capacity赋初值
 18 void initList() {
 19     list.len = 0; //空表的长度初始化为0
 20     list.capacity = 5; //空表的初始存储空间为10个int
 21     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 22     if (!list.ElemSet) {
 23         printf("初始化失败\n");
 24         return;
 25     }
 26     else {
 27         printf("成功创建动态数组\n");
 28         //给表中初始化5个数据
 29         for (int i = 0;i < 5;i++) {
 30             list.ElemSet[i] = i;
 31             list.len++;
 32         }
 33     }
 34 }
 35 
 36 //打印顺序表中的全部元素
 37 void showList() {
 38     //printf("表中数据是：\n");
 39     for (int i = 0;i < list.len;i++) {
 40         printf("%d  ", list.ElemSet[i]);
 41     }
 42     printf("\n");
 43     
 44 }
 45 
 46 
 47 
 48 //给空表添加元素
 49 void addElem(int e) {
 50     if (list.len == list.capacity) {
 51         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 52         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 53         list.capacity++;
 54         if (!list.ElemSet) {
 55             printf("重新开辟内存空间失败\n");
 56         }
 57     }
 58     list.len += 1;
 59     list.ElemSet[list.len - 1] = e;
 60     printf("添加元素后得到的表是：\n");
 61     showList();
 62     printf("表的长度是:%d\n", list.len);
 63 }
 64 
 65 
 66 //在空表中插入元素
 67 void insertElem(int e, int insertIndex) {
 68     /*for (int i = insertIndex;i <= list.len;i++) {
 69         list.ElemSet[i + 1] = list.ElemSet[i];
 70         showList();
 71     }
 72     list.ElemSet[insertIndex] = e;*/
 73     if (insertIndex < 0 || insertIndex >= list.len) {
 74         printf("插入位置错误\n");
 75         return;
 76     }
 77     else if(list.len==list.capacity){
 78         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 79         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 80         if (!list.ElemSet) {
 81             printf("重新开辟空间失败\n");
 82         }
 83 
 84     }
 85     list.len++;
 86     for (int i = list.len-1;i >=insertIndex;i--) {
 87         list.ElemSet[i+1] = list.ElemSet[i];
 88         //showList();
 89     }
 90     list.ElemSet[insertIndex] = e;
 91     printf("插入元素后得到的表是：\n");
 92     showList();
 93     printf("表的长度是：%d", list.len);
 94 }
 95 
 96 //顺序表删除元素
 97 void deleElem(int e) {
 98     int e_index = searchElem(e);
 99     if (e_index < 0 || e_index >= list.len) {
100         printf("没有这个元素\n");
101         return;
102     }
103     list.len--;
104     for (int i = e_index;i < list.len;i++) {
105         list.ElemSet[i] = list.ElemSet[i+1];
106     }
107     printf("删除元素后得到的表是：\n");
108     showList();
109     printf("表的长度是：%d\n", list.len);
110 }
111 
112 //顺序表查找元素
113 int  searchElem(int e) {
114     for (int i = 0;i < list.len;i++) {
115         if (list.ElemSet[i] == e) {
116             return i;
117         }
118     }
119     return -1;
120 }
121 
122 //寻找特定元素的前驱
123 int preElem(int e) {
124     if (searchElem(e) == 0) {
125         return -1;
126     }
127     int e_index = searchElem(e);
128     return list.ElemSet[e_index - 1];
129 }
130 
131 //寻找特定元素的后继
132 int nextElem(int e) {
133     if (searchElem(e) == list.len-1) {
134         return -1;
135     }
136     int e_index = searchElem(e);
137     return list.ElemSet[e_index + 1];
138 }
139 
140 
141 //顺序表更改元素
142 void changeElem(int e1, int e2) {  //用e2更改1
143     if (searchElem(e1) < 0 || searchElem(e1) >= list.len) {
144         printf("没有这个元素");
145         return;
146     }
147     int e1_index = searchElem(e1);
148     list.ElemSet[e1_index] = e2;
149     printf("更改后得到的表是：\n");
150     showList();
151 }
152 
153 //将表重置为空表
154 void clearList() {
155     if (destroyList()){
156         printf("置空失败，该表已被销毁\n");
157         return;
158     }
159     for (int i = 0;i < list.capacity;i++) {
160         list.ElemSet[i] = 0;
161     }
162     printf("表已经置空\n");
163     showList();
164 }
165 
166 //销毁表
167 bool destroyList() {
168     char isbreak = ' ' ;
169     printf("是否要销毁表?y/n:");
170     scanf("%c", &isbreak);
171     getchar();
172     if (isbreak == 'y') {
173         list.len = 0;
174         printf("表已经销毁\n");
175         return true;
176     }
177     else {
178         return false;
179     }
180 }
181 
182 
183 void main() {
184     int add_e = 0;
185     int insert_e = 0;
186     int insert_index = 0;
187     int del_e = 0;
188     int search_e = 0;
189     int change_e1 = 0,change_e2=0;
190     initList();
191     showList();
192     /*printf("请输入你要添加的元素:");
193     scanf("%d", &add_e);
194     addElem(add_e);*/
195 
196     /*printf("请输入你要插入的元素:");
197     scanf("%d", &insert_e);
198     printf("请输入你要插入位置的索引:");
199     scanf("%d", &insert_index);
200     insertElem(insert_e,insert_index);*/
201 
202     /*printf("请输入要删除元素：");
203     scanf("%d", &del_e);
204     deleElem(del_e);*/
205 
206     /*printf("请输入要查找的元素:");
207     scanf("%d", &search_e);
208     if (searchElem(search_e) == -1) {
209         printf("没有找到该元素\n");
210     }
211     else {
212         printf("找到该元素的索引是：%d", searchElem(search_e));
213     }*/
214 
215     /*printf("请输入要寻找哪个元素的前驱：");
216     scanf("%d", &search_e);
217     if (preElem(search_e) == -1) {
218         printf("该元素没有前驱\n");
219     }
220     else {
221         printf("该元素的前驱是：%d\n", preElem(search_e));
222     }
223     printf("请输入要寻找哪个元素的后继：");
224     scanf("%d", &search_e);
225     if (nextElem(search_e) == -1) {
226         printf("该元素没有后继\n");
227     }
228     else {
229         printf("该元素的后继是：%d\n", nextElem(search_e));
230     }*/
231     
232     /*printf("请输入要改变的元素:");
233     scanf("%d", &change_e1);
234     printf("请输入改变后的值:");
235     scanf("%d", &change_e2);
236     changeElem(change_e1, change_e2);*/
237     
238     clearList();
239     /*destroyList();*/
240 }

 

 完整代码

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #define Capacity 6
  4 typedef int bool;
  5 const int true = 1;
  6 const int false = 0;
  7 
  8 
  9 //自定义顺序表
 10 struct List{
 11     int* ElemSet;//声明了一个名为ElemSet的长度不确定的数组，也叫“动态数组”
 12     int len; //顺序表的长度
 13     int capacity; //顺序表的容量
 14 }list;
 15 
 16 //顺序表的初始化，即初步建立一个顺序表
 17 //1,给ElemSet动态数组申请足够大小的物理空间
 18 //2,给len和capacity赋初值
 19 void initList() {
 20     list.len = 0; //空表的长度初始化为0
 21     list.capacity = 5; //空表的初始存储空间为10个int
 22     list.ElemSet = (int*)malloc(Capacity * sizeof(int)); //构造一个空的顺序表，动态申请存储空间
 23     if (!list.ElemSet) {
 24         printf("初始化失败\n");
 25         return;
 26     }
 27     else {
 28         printf("成功创建动态数组\n");
 29         //给表中初始化5个数据
 30         for (int i = 0;i < 5;i++) {
 31             list.ElemSet[i] = i;
 32             list.len++;
 33         }
 34     }
 35 }
 36 
 37 //打印顺序表中的全部元素
 38 void showList() {
 39     //printf("表中数据是：\n");
 40     for (int i = 0;i < list.len;i++) {
 41         printf("%d  ", list.ElemSet[i]);
 42     }
 43     printf("\n");
 44     
 45 }
 46 
 47 
 48 
 49 //给空表添加元素
 50 void addElem(int e) {
 51     if (list.len == list.capacity) {
 52         printf("sorry,没有空间可以添加元素了,正在重新开辟\n");
 53         list.ElemSet = (int*)realloc(list.ElemSet, (Capacity + 1) * sizeof(int));
 54         list.capacity++;
 55         if (!list.ElemSet) {
 56             printf("重新开辟内存空间失败\n");
 57         }
 58     }
 59     list.len += 1;
 60     list.ElemSet[list.len - 1] = e;
 61     printf("添加元素后得到的表是：\n");
 62     showList();
 63     printf("表的长度是:%d\n", list.len);
 64 }
 65 
 66 
 67 //在空表中插入元素
 68 void insertElem(int e, int insertIndex) {
 69     /*for (int i = insertIndex;i <= list.len;i++) {
 70         list.ElemSet[i + 1] = list.ElemSet[i];
 71         showList();
 72     }
 73     list.ElemSet[insertIndex] = e;*/
 74     if (insertIndex < 0 || insertIndex >= list.len) {
 75         printf("插入位置错误\n");
 76         return;
 77     }
 78     else if(list.len==list.capacity){
 79         printf("sorry，没有空间可以插入元素了，正在重新开辟空间\n");
 80         list.ElemSet = (int*)realloc(list.ElemSet,(Capacity + 1) * sizeof(int));
 81         if (!list.ElemSet) {
 82             printf("重新开辟空间失败\n");
 83         }
 84 
 85     }
 86     list.len++;
 87     for (int i = list.len-1;i >=insertIndex;i--) {
 88         list.ElemSet[i+1] = list.ElemSet[i];
 89         //showList();
 90     }
 91     list.ElemSet[insertIndex] = e;
 92     printf("插入元素后得到的表是：\n");
 93     showList();
 94     printf("表的长度是：%d\n", list.len);
 95 }
 96 
 97 //顺序表删除元素
 98 void deleElem(int e) {
 99     int e_index = searchElem(e);
100     if (e_index < 0 || e_index >= list.len) {
101         printf("没有这个元素\n");
102         return;
103     }
104     list.len--;
105     for (int i = e_index;i < list.len;i++) {
106         list.ElemSet[i] = list.ElemSet[i+1];
107     }
108     printf("删除元素后得到的表是：\n");
109     showList();
110     printf("表的长度是：%d\n", list.len);
111 }
112 
113 //顺序表查找元素
114 int  searchElem(int e) {
115     for (int i = 0;i < list.len;i++) {
116         if (list.ElemSet[i] == e) {
117             return i;
118         }
119     }
120     return -1;
121 }
122 
123 //寻找特定元素的前驱
124 int preElem(int e) {
125     if (searchElem(e) == 0) {
126         return -1;
127     }
128     int e_index = searchElem(e);
129     return list.ElemSet[e_index - 1];
130 }
131 
132 //寻找特定元素的后继
133 int nextElem(int e) {
134     if (searchElem(e) == list.len-1) {
135         return -1;
136     }
137     int e_index = searchElem(e);
138     return list.ElemSet[e_index + 1];
139 }
140 
141 
142 //顺序表更改元素
143 void changeElem(int e1, int e2) {  //用e2更改1
144     if (searchElem(e1) < 0 || searchElem(e1) >= list.len) {
145         printf("没有这个元素\n");
146         return;
147     }
148     int e1_index = searchElem(e1);
149     list.ElemSet[e1_index] = e2;
150     printf("更改后得到的表是：\n");
151     showList();
152 }
153 
154 //将表重置为空表
155 void clearList() {
156     if (destroyList()){
157         printf("置空失败，该表已被销毁\n");
158         return;
159     }
160     else {
161         for (int i = 0;i < list.capacity;i++) {
162             list.ElemSet[i] = 0;
163         }
164         printf("表已经置空\n");
165         showList();
166     }
167 }
168 
169 //销毁表
170 bool destroyList() {
171     char isbreak = ' ' ;
172     printf("是否要销毁表?y/n:");
173     scanf("%c", &isbreak);
174     getchar();
175     if(isbreak=='y'){
176         list.len = 0;
177         printf("销毁成功\n");
178         return true;
179     }
180     else {
181         printf("销毁失败\n");
182         return false;
183     }
184 }
185 
186 
187 void main() {
188     int add_e = 0;
189     int insert_e = 0;
190     int insert_index = 0;
191     int del_e = 0;
192     int search_e = 0;
193     int change_e1 = 0,change_e2=0;
194     initList();
195     showList();
196     printf("请输入你要添加的元素:");
197     scanf("%d", &add_e);
198     addElem(add_e);
199 
200     printf("请输入你要插入的元素:");
201     scanf("%d", &insert_e);
202     printf("请输入你要插入位置的索引:");
203     scanf("%d", &insert_index);
204     insertElem(insert_e,insert_index);
205 
206     printf("请输入要删除元素：");
207     scanf("%d", &del_e);
208     deleElem(del_e);
209 
210     printf("请输入要查找的元素:");
211     scanf("%d", &search_e);
212     if (searchElem(search_e) == -1) {
213         printf("没有找到该元素\n");
214     }
215     else {
216         printf("找到该元素的索引是：%d\n", searchElem(search_e));
217     }
218 
219     printf("请输入要寻找哪个元素的前驱：");
220     scanf("%d", &search_e);
221     if (preElem(search_e) == -1) {
222         printf("该元素没有前驱\n");
223     }
224     else {
225         printf("该元素的前驱是：%d\n", preElem(search_e));
226     }
227     printf("请输入要寻找哪个元素的后继：");
228     scanf("%d", &search_e);
229     if (nextElem(search_e) == -1) {
230         printf("该元素没有后继\n");
231     }
232     else {
233         printf("该元素的后继是：%d\n", nextElem(search_e));
234     }
235     
236     printf("请输入要改变的元素:");
237     scanf("%d", &change_e1);
238     printf("请输入改变后的值:");
239     scanf("%d", &change_e2);
240     changeElem(change_e1, change_e2);
241     
242     clearList();
243     destroyList();
244 }