数据结构：线性表

线性表

线性表是具有相同数据结构的n个数据元素的有限序列，n是表长

术语

• 表头元素
• 表尾元素
• 表长
• 空表
• 位序
• 直接前驱
• 直接后继

基本操作

InitList(&L)  //初始化表，分配内存空间
DestroyList(&L)  //销毁表，释放内存空间

ListInsert(&L, i, e)   //第i个位置插入e
ListDelete(&L, i, &e)   //删除第i个位置元素，用e返回

LocateElem(L, e)   //按值查找
GetElem(L, i)      //按位查找

Length(L)      //求表长
PrintList(L)   //遍历表
Empty(L)       //判空

C++中&的用法

#include <stdio.h>

void test(int x){
	x = 1024;
	printf("x = %d\n", x);
}

int main(){
	int x = 1;
	printf("x = %d\n", x);
	test(x);
	printf("x = %d\n", x);

#include <stdio.h>

void test(int &x){
	x = 1024;
	printf("x = %d\n", x);
}

int main(){
	int x = 1;
	printf("x = %d\n", x);
	test(x);
	printf("x = %d\n", x);

顺序表静态分配

#include <stdio.h>
#define MaxSize 10

typedef struct{
	ElemType data[MaxSize];
	int length;
}SqList;

//初始化顺序表
void InitList(SqList &L){
	for(int i=0; i<MaxSize; i++){
		L.data[i] = 0;
	}
	L.length = 0;
}

int main(){
	SqList L;
	InitList(L);
	return 0;
}

顺序表动态分配

#include <stdlib.h>
#define InitSize 10

typedef struct{
	int *data;
	int MaxSize;
	int length;
}SeqList;

void InitList(SeqList &L){
	//用malloc函数申请一片连续的存储空间
	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(){
	SeqList L;
	InitList(L);
	//插入10个元素;
	IncreaseSize(L, 5);
	return 0;
}

顺序表插入操作

#define MaxSize 10

typedef struct{
	int data[MaxSize];
	int length;
}SqList;

bool ListInsert(SqList &L, int i, int e){
	if(i<1 || i>L.length+1){
		return false;
	}
	if(L.length >= MaxSize){
		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;
}

int main(){
	SqList L;
	InitList(L);
	//插入一些元素
	ListInsert(L, 1, 100);
	return 0;
}

最好时间复杂度：O(1)，插入到表尾

最坏时间复杂度：O(n)，插入到表头

平均时间复杂度：O(n/2)

顺序表删除操作

bool ListDelete(SqList &L, int i, int &e){
	for(int j=i; j<L.length; j++){
		L.data[j-1] = L.data[j];
	}
	L.length--;
	return true;

最好时间复杂度：O(1)，删除表尾

最坏时间复杂度：O(n)，删除表头

平均时间复杂度：O(n-1/2)

顺序表的查找操作

按位查找

// 查找第i个元素，返回值
int GetElem(SqList L, int i){
	return L.data[i-1];
}

时间复杂度：O(1)，随机存取

按值查找

// 查找第一个值为e的元素，返回位序
int LocateElem(SqList L, int e){
	for(int i=0; i<L.length; i++){
		if(L.data[i] == e){
			return i+1;
		}
	}
	return 0;
}

单链表定义

每个结点除了存放数据元素外，还要存储指向下一个节点的指针

优点：不需要连续空间

缺点：不可随机存取，耗费空间存放指针

struct LNode{
	int data;
	struct LNode *next;
};
struct LNode *p = (struct LNode *)malloc(struct LNode));

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

LNode *GetElem(LinkList L, int i)

// 头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
	LNode *s;
	int x = 1;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	s->data = x;
	s->next = L->next;
	L->next = s;

// 不带头结点的单链表
bool InitList(LinkList &L){
	L = null;
	return true;
}
// 带头结点的单链表
bool InitList(LinkList &L){
	L = (LNode *)malloc(sizeof(LNode));
	if(L == null) return false;
	L->next = null;
	return true;
}

// LinkList等价于LNode *

单链表的插入删除

//插入操作
s->data = e;
s->next = p->next;
p->next = s;

//删除操作
e = q->data;
p->next = q->next;
free(q);

单链表的查找

// 按位查找
while(p != null && j < i-1){
	p = p->next;
	j++;
}

while(p != null && p->data != e){
	p = p->next;
}

单链表的建立

// 尾插法
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
r->next = s;
r = s;

// 头插法
s = (LNode *)malloc(sizeof(LNode));
s->data = x;
s->next = L->next;  // L是头指针
L->next = s;