线性表基本操作

#include<iostream>
#include<errno.h>
using namespace std;

//数组实现

/*
#define MAXLINES 1000
typedef int elementtype;
typedef int position;
struct List
{
	elementtype elements[MAXLINES];
	position last = 0;
};


position End(List L)//返回尾后下标
{
	return L.last + 1;
}

void Insert(elementtype x, position p, List L)//所有的插入都是往**之前插
{
	if (p > MAXLINES - 1)
		cerr << "list is full";
	else
	{
		if (p > L.last + 1||p<1)
			cerr << "position dose not exit";//输出错误的方式
		else
		{
			for (position q = L.last; q >= p; --q)
				L.elements[q + 1] = L.elements[q];
			L.last += 1;
			L.elements[p] = x;
		}

	}
}

void Delete(position p, List L)
{
	if (p > MAXLINES - 1)
		cerr << "list is full";
	else
	{
		if (p > L.last + 1 || p<1)
			cerr << "position dose not exit";//输出错误的方式
		else
		{
			for (position q = p; q < L.last; ++p)
				L.elements[q] = L.elements[q + 1];
			L.last--;
		}
	}
}

position First(List L)
{
	return 1;
}

position Locate(elementtype x, List L)
{
	for (position q = First(L); q < End(L); ++q)
	{
		if (L.elements[q] == x)
			return q;
	}
	return L.last + 1;//x若不存在
}
*/

//指针实现方式

/*

typedef int elementtype;

struct node
{
	node* next;
	elementtype element;
};

typedef node* position;

//由于每次的插入都是插在之前，所以这里返回的是指向x的前一个指针
position Locate(elementtype x, node* header)
{
	position q = header;
	while (q->next != NULL)
	{
		if (q->next->element == x)
			return q;
		else
			q = q->next;
	}
	return q;
}

//插入操作
void Insert(elementtype x, elementtype p, node* header)//将x插入到值为p的前面，未找到就插在尾后
{
	position q = Locate(p, header);
	position temp;
	temp->element = x;
	temp->next = q->next;
	q->next = temp;
}

//删除操作
void Delete(elementtype p, node* header)
{
	position q = Locate(p, header);
	if (q->next == NULL)
		cerr << "can not find the position";
	position temp = q->next;
	q -> next = temp->next;
	delete temp;
}

*/

//游标实现

/*

typedef int elementtype;
#define maxsize 1000

struct node
{
	elementtype element;
	int next;
};

node space[maxsize];

int availhead;
void Initial()
{
	
	for (int i = 0; i < maxsize - 1; ++i)
	{
		space[i].next = i + 1;
	}
	space[maxsize - 1].next = -1;
	availhead = 0;
}

int Locate(int M, elementtype x)
{
	int N = M;//无必要，毕竟不是按引用传递
	while (space[N].next != -1)
	{
		if (space[space[N].next].element == x)
			return N;
	}
	return N;
}

void Insert(int M, elementtype x)//这里的int就可以直接代表指针,并且如若找不到，直接在末尾后添加
{
	int N=Locate(x, M);
	int temp = space[availhead].next;
	if (temp == -1)
		cerr << "no avail space";
	space[availhead].next = space[temp].next;
	space[temp].element = x;
	space[temp].next = space[N].next;
	space[N].next = temp;

}

void Delete(int M, elementtype x)
{
	int N = Locate(x, M);
	if (N == -1)
		cerr << "can not find the position";
	space[N].next = space[space[N].next].next;
}

*/

//双向链表

//该链表无头节点，或者说头节点中也含有信息
//指针实现

/*

typedef int elementtype;
struct node
{
	node* pre;
	node* next;
	elementtype element;
};

typedef node* position;
typedef node* List;

position Locate(elementtype x,List L)
{
	position q = L;
	while (q->next != NULL)
	{
		if (q->element == x)
			return q;
		else
			q = q->next;
	}
	return q->next;//注意这里不需要像前面一样返回找到元素的前一个元素，可以直接返回到本来元素
}


void Delete(elementtype x, List L)//十分巧妙的删除手法
{
	position p = Locate(x, L);
	if (p->pre != NULL)//如果不是首结点
		p->pre->next = p->next;
	if (p->next != NULL)//如果不是尾结点
		p->next->pre = p->pre;
	delete p;

}

*/

//环状链表
//该链表删除添加元素的对象都是位置p之后的一个元素
//同样头结点中蕴含信息
//规定：R为首节点，指向R的为尾节点

typedef int elementtype;
struct node
{
	node* next;
	elementtype element;
};

typedef node* position;
typedef node* List;

position Locate(List L, elementtype x)
{
	position q = L;
	while (q->next != NULL)
	{
		if (q->element == x)//在之后插入
			return q;
	}
	return q;
}
void LInsert(List L, elementtype x)//在首端之后插入
{
	node* temp = new node;
	temp->element = x;
	if (L == NULL)
	{
		temp->next = temp;
		L = temp;//形成自环
	}
	else
	{
		temp->next = L->next;
		L->next = temp;
	}

}

void RInsert(List L, elementtype x)//在末尾之后插入
{
	LInsert(L, x);
	L = L->next;//感觉有点不太好

}

void LInsert(List L)
{
	if (L == NULL)
		cerr << "list is not exict";
	else
	{
		node* temp = L->next;
		if (temp == NULL)
			L = NULL;
		else
		{
			L->next = temp ->next;
		}
		delete temp;
	}

}