数据结构线性表（代码框架总结）

线性表

顺序表————————

静态分配

动态分配

初始化

增加顺序表的长度

按位序插入元素

删除位序i的元素

位序查找，返回位序的元素

按值查找元素e

删除位于s和t之间的元素

元素逆置

合并顺序表：将两个有序表合并成新的有序顺序表

单链表（不带头结点）————————

结构体定义

初始化

按位查找

按值查找元素为e的节点

链表长度

后插操作，在节点p之后插入元素e

在第i个位置插入元素e

前插操作，在节点p之前插入元素e

前插操作，在节点p之前插入节点s

删除位序为i的节点

删除指定节点p

尾插法

头插法

单链表（带头结点）————————

初始化

按位查找，返回第i个元素

按值查找元素为e的节点

链表长度

后插操作，在节点p之后插入元素e

在第i个位置插入元素e

前插操作，再节点p之前插入元素e

前插操作，再节点p之前插入节点s

删除位序为i的节点

删除指定节点p

尾插法

头插法

将两个元素递增的带头结点的单链表，归并成一个按元素递减有序的链表

双链表（带头结点）————————

初始化

判断是否为空

按位查找

按值查找元素为e的节点

在p节点之后插入节点s

在p节点之后插入元素e

前插，在p节点之前插入节点s

按位插入，在第i个位置插入元素e

删除p节点的后继节点

销毁双链表

尾插法

头插法

链表长度

删除指定节点s

删除位序为i的节点

循环单链表（L指向表尾）————————

结构体定义

初始化

按位查找返回第i个元素（带头结点）

按值查找元素为e的节点

链表长度

后插操作，在节点p之后插入元素e

在第i位置插入元素e（带头结点）

前插操作，在节点p之前插入元素e

前插操作，在节点p之前插入节点s

删除位序为i的节点

删除指定节点p

尾插法（带头结点）

头插法（带头结点）

判断是否为空

判断是否为表尾节点

循环单链表（L指向表头）————————

结构体定义

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

初始化

bool InitList(LinkList &L){
	L = (LNode*)malloc(sizeof(LNode));
	if(L == NULL)
		false;
	L = L->next;
	return true;
}

按位查找返回第i个元素（带头结点）在这里插入代码片

按值查找元素为e的节点

链表长度

后插操作，在节点p之后插入元素e

在第i位置插入元素e（带头结点）

前插操作，在节点p之前插入元素e

前插操作，在节点p之前插入节点s

删除位序为i的节点

删除指定节点p

尾插法（带头结点）

头插法（带头结点）

判断是否为空

bool Empty(LinkList L){
	return L == L->next;
}

判断是否为表尾节点

bool isTail(LinkList L,LNode *p){
	return p->next == L;
}

循环双链表————————

结构体定义

typedef struct DNode{
	ElemType data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

初始化

bool InitList(DLinkList &L){
	L = (DNode*)malloc(sizeof(DNode));
	if(L == NULL)
		return false;
	L->prior = L;
	L->next = L;
	return true;
}

判断是否为空

bool Empty(DLinkList L){
	return L == L->next;
}

判断是否为表尾节点

bool isTail(DLinkList L,DNode *p){
	return p->next == L;
}

按位查找

DNode *GetElem(DLinkList &L,int i){
	if(i < 0)
		return NULL;
	if(i == 0)
		return L;
	int j = 1;
	DNode *p = L->next;
	while(p != L && j < i){
		p = p->next;
		j++;
	}
	if(L == p)
		return NULL;
	return p;
}

按值查找元素为x的节点

DNode *LocateElem(DLinkList L,ElemType x){
	DNode *p = L;
	if(p == NULL)
		return NULL;
	p = p->next;
	while(p != NULL && p->data != x){
		p = p->next;
	}
	if(p == L)
		return NULL;
	return p;
}

在p结点之后插入节点s

bool InsertNextDNode(DNode *p,DNode *s){
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

在p节点之后插入元素e

bool InsertNextElem(DNode *p,ElemType e){
	DNode *s = (DNode*)malloc(sizeof(DNode));
	if(s ==NULL)
		return false;
	s->data = e;
	return InsertNextDNode(p,s)
}

前插，在节点p之前插入节点s

bool InsertPriorDNode(DNode *p,DNode *s){
	return InsertNextDNode(p->prior,s);
}

按位插入，在第i个位置插入元素e

bool InsertIElem(DLinkList &L,int i,ElemType e){
	DNode *p = GetElem(L,i-1);  //找到要插入位置的前一个元素
	if(p == NULL)
		return false;
	return InsertNextElem(p,e);
}

删除p节点的后继节点

bool DeleteNextNode(DNode *p){
	if(p == NULL)
		return false;
	DNode *q = p->next;
	q->next->prior = p;
	p->next = q->next;
	free(q);
	return true;
}

删除指定节点s

bool DeleteNode(DNode *s){
	s->next->prior = s->prior;
	s->prior->next = s->next;
	free(s);
	return true;
}

删除位序为i的节点

bool DeleteINode(DLinkList &L,int i){
	if(i <= 0 || i > Length(L))
		return false;
	DNode *s = GetElem(L,i);
	if(s == NULL)
		return false;
	return DeleteNode(s);
}

销毁双链表

bool DestoryList(DLinkList &L){
	DNode *p = L->next;
	while(p != L){
		DeleteNode(p);
	}
	free(L);
	L = NULL;
	return true;
}

尾插法

头插法

链表长度

int Length(DLinkList L){
	int len = 0;
	DNode *p = L->next;
	while(p != L){
		p = p->next;
		len++;
	}
	return len;
}

静态链表————————

结构体定义

#define MaxSize 10
typedef struct{
	ElemType data;
	int next;
}SLinkList[MaxSize];

初始化

void InitSLinkList(SLinkList L){
	for(int i = 1;i < MaxSize;i++)
		L[i].next = -2;
	L[0].next = -1;
}

判断是否为空

bool Empty(SLinkList L){
	return L[0].next == -1;
}

得到第i个元素的下标

int GetIndex(SLinkList L,int i){
	int j = 0;
	int count = 0;
	while(j != -1 && count < i){
		count++;
		j = L[j].next;
	}
	if(count != i) 		//没遍历到i,元素不足i个
		return -1;
	return j;
}

得到第一个为空的元素

int GetFirstEmptyNode(SLinkList L){
	for(int i = 0;i < MaxSize;i++){
		if(L[i].next == -2)
			return i;
	}		
}

返回L的第i个元素

ELemType GetElem(SLinkList L,int i){
	int j = GetIndex(L,i);
	if(j == -1)				//
		return NULL;		//
	return L[j].data;
}

在第i个节点之后插入元素e

bool InsertElem(SLinkList &L,int i,ElemType e){
	int j = GetIndex(L,i);
	int K = GetFirstEmptyNode(L);
	L[k].next = L[j].next;
	L[j].next = k;
	L[k].data = e;
	return true;
}

删除第i个节点e（仅删除元素值）

bool DeleteNode(SLinkList &L,int i,ElemType &e){
	int j = GetIndex(L,i);
	if(j == -1){
		int k = GetIndex(L,i - 1);
		L[j].next = -2;
		e = L[j].data;
		L[k].next = -1;
		return true;
	}
	e = L[j].data;
	int temp = L[j].next;
	L[j].data = L[temp].data;		//把要删除元素的下一个位置上移
	L[j].next = L[temp].next;
	L[temp].next = -2;
	return true;
}