三个朋友今天全部上岸大厂,祝贺。(太羡慕了)
静态分配创建一个顺序表;
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;
}