线性表与链表

线性表

线性表是具有相同数据类型的 n(n>=0) 个数据元素的有限序列
n为表长 第几个元素 专业名称 位序 第一个元素成为 表头元素 最后一个元素是 表尾元素
除了表头元素外，每个元素都有一个直接前驱 除表尾元素外，每个元素都有一个直接后继

线性表的基本操作
InitList(&L); 初始化表。构造一个空的线性表L，分配内存空间

DestroyList(&L)；销毁操作。销毁线性表，并释放线性表L所占用的内存空间

ListInsert(&L,i,e); 插入操作.在表L中的第 i 个位置上插入指定元素e

ListDelete(&L,i,&e); 删除操作.删除表L中第 i 个位置的元素,并用e返回删除元素的值

LocateElem(L,e); 按值查找操作.在表L中查找具有给定关键字值的元素

GetElem(L,i); 按位查找操作.获取表L中第 i 个位置的元素的值

其他常用的操作:

Length(L); 求表长.返回线性表L的长度,即L中数据元素的个数

PrintList(L) 输出操作.按前后顺序输出线性表L的所有元素值

Empty(L) 判空操作.若L为空表,则返回true,否则返回false

线性表可用的存储结构

顺序表

使用顺序存储方式实现的线性表 逻辑上相邻物理存储位置也相信

顺序表的特点：
1.随机访问，即可以在常数级时间内找到第i个元素
2.存续密度高，每个节点只存储数据元素（而链式存储会将用于指向的指针）
3.拓展容量不方便
4.插入、删除操作不方便，需要移动大量元素

顺序表代码

#include<stdio.h>
#include<stdlib.h>

#define InitSize 10

typedef struct{
	int *data;		//指示动态分配数组的指针 
	int MaxSize;
	int length;			//当前顺序表的长度 
}List;


//初始化顺序表
void InitList(List &L){
	L.data = (int *)malloc(InitSize*sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
} 

//动态申请内存空间
void IncreaseSize(List &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(List &L,int i,int e){
	if(i < 1 || i > L.length + 1) {
		return false;
	}
	if(L.length > L.MaxSize) {
		return false;
	}
	for(int q = L.length; q >= i; q--) {
		L.data[q] = L.data[q-1];
	}
	L.data[i-1] = e;
	L.length++;
	return true;
} 

//顺序表的删除操作
bool ListDelete(List &L,int i, int &e){
	if(i < 1 || i > L.length + 1) {
		return false;
	}
	e = L.data[i-1];
	for(int q = i; q < L.length; q++) {
		L.data[q-1] = L.data[q];
	}
	L.length--;
	return true;
} 

//顺序表的按位查找
int GetElem(List L,int i){
	return L.data[i-1];
} 

//顺序表的按值查找
int LocateElem(List L,int e){
	for(int i = 0; i < L.length; i++) {
		if(L.data[i] = e){
			return i+1;
		}
	}
	return 0;
} 

int main(){
	
	List L;
	
	//进行初始化操作
	InitList(L);
	
	IncreaseSize(L,5);
	
	//对顺序表进行插入操作 
	ListInsert(L,2,23);
	
	//对e进行声明并初始化 
	int e = -1;
	ListDelete(L,3,e);
	
	//按位查找
	int local = GetElem(List L,4); 
	
	//按值查找 
	int key = LocateElem(List L,int e);
	
	return 0;
}

链表

单链表

单链表的特点：
优点：改变容量方便
缺点：不能随机存取，需要耗费一定空间存放指针

#include<stdio.h>

struct LNode{
	int data;
	struct LNode *next;	//指向下一个结点的指针 (指针域) 
}LNode,*LinkList;

//初始化一个空的链表
bool InitList(LinkList &L){
	L = (LNode *)maclloc(sizeof(LNode));
	if (L == NULL) {
		return false;
	}
	L->next=null;
	return true;
} 

//判断单链表是否为空
bool Empty(LinkList L){
	if (L == NULL) {
		return true;
	} else {
		return false;
	}
} 

//插入操作
bool ListInsert(LinkList &L,int i,int e){
	
	if(i == 1) {
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
	}
	
	
	if(i < 0) {
		return false;
	}
	LNode *p; //指针p指向当前扫描到的结点
	int j = 1; //当前p指向的是第几个结点 
	p = L;	//L指向头结点，头结点是第0个结点 (不存数据) 
	
	while(p != NULL && j < i-1) {
		p = p->next;
		j++;
	} 
	
	if(p == NULL) {
		return false;
	}
	
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	
	return true;
} 

bool ListDelete(LinkList &L,int i,int &e){
	if(i < 1) {
		return false;
	}
	LNode *p;
	int j = 0;
	p = L;
	while(p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	
	if(p == NULL) {
		return false;
	}
	if(p->next == NULL) {
		return false;
	}
	
	LNode *q = p->next;
	e = q->data;
	p->next = q->next;
	free(q);
	return true;
}

//按位查找，返回第i个元素(带头结点)
LNode * GetElem(LinkList L,int i){
	if(i < 0) {
		return NULL;
	}
	LNode *p;
	int j = 0;
	p = L;
	while(p!=NULL && j < 1) {
		p = p->next;
		j++;
	}
	return p;
}


//按值查找，找到数据域==e的结点
LNode * LocateElem(LinkList L,int e){
	LNode *p = L->next;
	while(p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
} 


//求单链表长度
int Length(LinkList L){
	int len = 0;
	LNode *p = L;
	while(p != NULL) {
		p = p->next;
		len++;
	}
	return len;
} 


int main(){
	
	LinkList L;
	
	
	
	return 0;
	
} 

双链表

#include<stdio.h>

typedef struct DNode{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinklist;


//初始化双链表 
bool InitDLinkList(DLinklist &L){
	L = (DNode *)malloc(sizeof(DNode));
	if (L = NULL) {
		return false;
	}
	L->prior = NULL;
	L->next = NULL;
	return true;
}


bool Empty(DLinklist L) {
	if (L->next == NULL) {
		return true;
	} else {
		return false;
	}
}


//在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s){
	if (p == NULL || s == NULL) {
		return false;
	}
	
	s->next = p->next;
	
	if (p->next != NULL) {
		p->next->prior = s;
	}
	
	s->prior = p;
	p->next = s;
	
	return true;
} 


//删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
	if (p == NULL) {
		return false;
	}
	
	DNode *q = p->next;
	if (q == NULL) {
		return false;
	}
	
	p->next = q->next;
	if (q->next != NULL) {
		q->next->prior = p;
 	}
 	
 	free(q);
 	return true;
} 

循环链表

让链表的最后一个结点指向头结点

静态链表

什么是静态链表
类型为结构体的数组

优点：增删操作不需要移动大量元素
缺点：不能随机存取，只能从头结点开始依次往后查找，容量固定不可变