顺序表的创建

三个朋友今天全部上岸大厂，祝贺。（太羡慕了）

静态分配创建一个顺序表；

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;
}