三个朋友今天全部上岸大厂，祝贺。（太羡慕了）
静态分配创建一个顺序表；
1.顺序表的定义：
#define MaxSize 10
typedef struct {ElemType data[MaxSize];int length;
}SqlList;
这里我们用结构体的方式定义以一个顺序表；用静态数组存放数据元素；定义一个存放表长度的变量；这里我们用了静态分配的方式定义了一个顺序表；
2.顺序表的初始化
#include<stdio.h>
#include<math.h>
#include<iostream>
#include<string.h>
using namespace std;#define MaxSize 10
typedef struct {int data[MaxSize];int length;
}SqlList;
//初始化一个顺序表
void InitList(SqlList &L) {for(int i = 0; i<MaxSize; i++) {L.data[i] = 0;}L.length = 0;
}
int main() {SqlList L;InitList(L); return 0;
}在main函数声明一个顺序表，这时候计算机就会为它分配一段连续的空间；这里分配的内存空间的大小就是MaxSIze*sizeof（数据类型）；
还有一个点比较重要：
就是这段代码：
for(int i = 0; i<MaxSize; i++) {L.data[i] = 0;}
可能会想有必要吗？
#include<stdio.h>
#include<math.h>
#include<iostream>
#include<string.h>
using namespace std;#define MaxSize 10
typedef struct {int data[MaxSize];int length;
}SqlList;
//初始化一个顺序表
void InitList(SqlList &L) {L.length = 0;
}
int main() {SqlList L;InitList(L); for(int i = 0;i<MaxSize;i++){printf("data[%d] = %d\n",i,L.data[i]);} return 0;
}
我跑一下，你看看结果！！！
不初始化数组会出现内存中遗留的数据，这些“脏数据”当然不是我们想要的；原因是c它自己创建一个数组的时候不会初始化数组的元素；（这个自己一定要注意，java就没有这样的烦恼）；
咱们静态创建一个顺序表，最大的坏处就是你没有办法衡量你的顺序表的长度，导致我们代码的健壮性是相当的差劲了；
指针即为地址，指针几个字节跟语言无关，而是跟系统的寻址能力有关；32位占4个字节，64位占8个字节；
#include<stdio.h>
#include<math.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;#define InitSize 10
typedef struct {int *data;//指示动态分配数组的指针 int MaxSize;//顺序表的最大容量 int length;//顺序表当前的长度
} SeqList;//顺序表的类型定义（动态分配）
//初始化一个顺序表
void InitList(SqlList &L) {L.data = (int *)malloc(InitSize*sizeof(int));L.length = 0;L.MaxSize = InitSize;
}
//动态增加数组的长度
void IncreaseSize(SeqList &L,int len){int *p = L.data;L.data=(int*)malloc((L.MaxSize+len)*sizeof(int));for(int i =0;i<L.length;i++){L.data[i] = p [i];}L.MaxSize = L.MaxSize + len;free(p);
}
int main() {SqlList L;InitList(L);IncreaseSize(L,5);return 0;
}
malloc函数感觉挺好用的，数组的动态扩容比较重要；
void IncreaseSize(SeqList &L,int len){int *p = L.data;L.data=(int*)malloc((L.MaxSize+len)*sizeof(int));for(int i =0;i<L.length;i++){L.data[i] = p [i];}L.MaxSize = L.MaxSize + len;free(p);
} 上次写还是大一了（惭愧）；
#include<stdio.h>
#include<math.h>
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;#define InitSize 10
typedef struct {int *data;//指示动态分配数组的指针int MaxSize;//顺序表的最大容量int length;//顺序表当前的长度
} SeqList;//顺序表的类型定义（动态分配）
//初始化一个顺序表
void InitList(SeqList &L) {L.data = (int *)malloc(InitSize*sizeof(int));L.length = 0;L.MaxSize = InitSize;
}
//动态增加数组的长度
void IncreaseSize(SeqList &L,int len) {int *p = L.data;L.data=(int*)malloc((L.MaxSize+len)*sizeof(int));for(int i =0; i<L.length; i++) {L.data[i] = p [i];}L.MaxSize = L.MaxSize + len;free(p);
}
//插入操作
bool ListInsert(SeqList &L,int i,int e) {if(i<1 || i>L.length+1) {printf("数据规格错误");return false;}if(L.length >= L.MaxSize) {printf("当前存储空间已满，不能插入");return false;}for(int j = L.length; j>=i; j--) {L.data[j] = L.data[j-1];}L.data[i-1] = e;L.length++;return true;
}
//删除操作
bool ListDelete(SeqList &L,int i,int &e) {if(i<1 || i>L.length) {printf("数据规格不合法");return false;}e = L.data[i-1];for(int j = i; j< L.length; j++ ) {L.data[j-1] = L.data[j];}L.length--;return true;
}
//顺序表的按位查找
void getList(SeqList L,int i) {if(i<1 || i>L.length) {printf("数据元素不合法\n");}else{printf("查找到的数据是%d\n",L.data[i-1]);}
}
//s顺序表按值查找
int *LocateElem(SeqList L,int e){static int a[10];int flag = 0;for(int i = 0;i<L.length;i++){if(L.data[i] == e){a[flag] = i;flag++;}}return a;
}
//顺序表正序输出
void print(SeqList L){for(int i = 0;i < L.length ;i++){printf("data[%d]=%d\n",i,L.data[i]);}
}
int main() {SeqList L;InitList(L);ListInsert(L,1,1);ListInsert(L,2,3);ListInsert(L,3,3);ListInsert(L,4,3);print(L);int *a= LocateElem(L,3);for(int i = 0 ;i<10;i++){if(*(a+i)!= 0){printf("%d\n",*(a+i)); }}return 0;
}
