顺序表

1. 静态数组实现

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define TURE 1
#define FALSE 0
#define MAX 10

typedef struct {
	int data[MAX];
	int len;
}SqList;
void InitList(SqList*);
int ListInsert(SqList*, int pos, int e);
int ListDelete(SqList*, int pos, int* e);
void Print(SqList*);
int GetElem(SqList* sq,int pos);
int LocatElem(SqList* sq, int e);
int main() {
	SqList l;
	int e;
	InitList(&l);
	ListInsert(&l,1,1);
	ListInsert(&l,1,1);
	ListInsert(&l,1,1);
	ListInsert(&l,1,1);
	ListDelete(&l,1,&e);
	Print(&l);
	return 0;
}
void InitList(SqList* l) {
	l->len = 0;
}
int ListInsert(SqList* L, int pos, int e) {
	if (pos<1 || pos>L->len + 1) {
		return FALSE;
	}
	for (int i = L->len; i >= pos; i--)
	{
		L->data[i] = L->data[i - 1];
	}
	L->data[pos - 1] = e;
	L->len++;
	return TURE;
}
int ListDelete(SqList* L, int pos, int* e) {
	if (pos<1||L->len<pos) {
		return FALSE;
	}
	*e = L->data[pos - 1];
	for (int i = pos; i < L->len; i++)
	{
		L->data[i-1] = L->data[i];
	}
	L->len--;
	return TURE;
}
void Print(SqList* L) {
	if (L->len!=0) {
		for (int i = 0; i < L->len; i++)
		{
			printf("%d ",L->data[i]);
		}
		printf("\n");
	}
}
int GetElem(SqList* sq, int pos) {
	return sq->data[pos-1];
}
int LocatElem(SqList* sq, int e) {
	for (int i = 0; i < sq->len; i++)
	{
		if (e == sq->data[i]) return i+1;
	}
}

2. 动态数组实现

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define TURE 1
#define FALSE 0
#define InitMAX 10

typedef struct {
	int * data;
	int MaxSize;
	int len;
}SqList;
void InitList(SqList*);
int ListInsert(SqList*, int pos, int e);
int ListDelete(SqList*, int pos, int* e);
void Print(SqList*);
int GetElem(SqList* sq, int pos);
int LocatElem(SqList* sq, int e);
void IncreaseSize(SqList* sqm,int len);
int main() {
	SqList L;
	int e;
	InitList(&L);
	ListInsert(&L,1,1);
	ListInsert(&L,1,2);
	ListInsert(&L,1,2);
	ListInsert(&L,1,3);
	ListDelete(&L, 1, &e);
	ListDelete(&L, 1, &e);
	ListDelete(&L, 1, &e);
	ListDelete(&L, 1, &e);
	Print(&L);
	return 0;
}
void InitList(SqList* L) {
	L->data = (int*)malloc(sizeof(int)*InitMAX);
	L->len = 0;
	L->MaxSize = InitMAX;
	return ;
}

int ListInsert(SqList* sq, int pos, int e) {
	if (pos<1||pos>sq->len+1) {
		return FALSE;
	}
	for (int i = sq->len; i >= pos; i--)
	{
		sq->data[i] = sq->data[i - 1];
	}
	sq->data[pos - 1] = e;
	sq->len++;
	return TURE;
}
void IncreaseSize(SqList* sq, int len) {
	int* p = sq->data;
	sq->data = (int *)malloc(sizeof(int) *(sq->MaxSize+len));
	for (int i = 0; i <sq->len ; i++)
	{
		sq->data[i]=p[i];
	}
	sq->len = sq->MaxSize + len;
	free(p);
}
int ListDelete(SqList* sq, int pos, int* e) {
	if (pos<1||pos>sq->len) {
		return FALSE;
	}
	*e = sq->data[pos - 1];
	for (int i = pos; i < sq->len; i++)
	{
		sq->data[i-1] = sq->data[i];
	}
	sq->len--;
	return TURE;
}
void Print(SqList* sq) {
	if (sq->len!=0) {
		for (int i = 0; i < sq->len; i++)
		{
			printf("%d ",sq->data[i]);
		}
		printf("\n");

	}
	return;
}
int GetElem(SqList* sq, int pos) {
	return sq->data[pos - 1];
}
int LocatElem(SqList* sq, int e) {
	if (sq->len!=0) {
		for (int i = 0; i < sq->len; i++)
		{
			if (e==sq->data[i]) {
				return i + 1;
			}
		}
	}
	return FALSE;
}

• 插入、删除操作的时间复杂度分析
  1.最好时间复杂度=O(1)
  2.最坏时间复杂度=O(n)
  3.平均时间复杂度=O(n)
• 按位查找操作的时间复杂度:O(1)
• 按值查找操作的时间复杂度
  1.最好时间复杂度=O(1)
  2.最坏时间复杂度=O(n)
  3.平均时间复杂度=O(n)
  优点：可以随机存储，存储密度高
  缺点：要求大片连续空间，改变容量不便
  总结：顺序表具有随机存储的特性，但是插入和删除需要移动大量元素