【数据结构】线性表链式存储结构-双向链表

双链表基本操作

//宏定义
#define FAILED		0
#define SUCCESS		1


typedef struct DNode
{
	int data;
	struct DNode* prior;
	struct DNode* next;
}DLinkNode;

//创建链表
//**********************头插法**********************//

DLinkNode* CreateDLinkListF(int  a[], int n)
{
	DLinkNode* L = (DLinkNode*)malloc(sizeof(DLinkNode));
	DLinkNode* s;
	L->next = NULL;
	L->prior = NULL;
	for (int i = 0; i < n; i++)
	{
		s = (DLinkNode*)malloc(sizeof(DLinkNode));
		s->data = a[i];
		s->next = L->next;
		s->prior = L;
		if (L->next)
			L->next->prior = s;
		L->next = s;
	}
	return L;
}

//**********************尾插法**********************//
DLinkNode* CreateDLinkListR(int a[], int n)
{
	DLinkNode* L = (DLinkNode*)malloc(sizeof(DLinkNode));
	DLinkNode* r = L ;
	DLinkNode* s;
	DLinkNode* p;
	L->next = NULL;
	L->prior = NULL;
	for (int i = 0; i < n; i++)
	{
		s = (DLinkNode*)malloc(sizeof(DLinkNode));
		s->data = a[i];
		r->next = s;
		s->prior = r;
		r = s;
	}
	r->next = NULL;

	return L;
}

//**********************链表初始化**********************//
DLinkNode* InitDLinkList()
{
	DLinkNode* L;
	L = (DLinkNode*)malloc(sizeof(DLinkNode));
	if (!L)
		return FAILED;
	L->prior = NULL;
	L->next = NULL;
	return L;
}

//**********************销毁线性表**********************//
void DestroyDLinkList(DLinkNode* L)
{
	DLinkNode* s = L;
	DLinkNode* next = L->next;
	while (next)
	{
		free(s);
		s = next;
		next = next->next;
	}
	free(s);
}

//**********************判断空表**********************//
int DLinkListEmpty(DLinkNode* L)
{
	return (L->next == NULL);
}


//**********************求表长**********************//
int DLinkListLength(DLinkNode* L)
{
	int n = 0;
	DLinkNode* s = L;
	while (s->next)
	{
		n++;
		s = s->next;
	}
	return n;

}

//**********************输出信息**********************//
void DispDLinkList(DLinkNode* L)
{
	DLinkNode* s = L->next;
	while (s)
	{
		printf("%d  ", s->data);
		s = s->next;
	}
	printf("\n");
}

//**********************得到第i个值**********************//
int GetDLinkElem(DLinkNode* L, int i, int* e)
{
	DLinkNode* s = L->next;
	if (i < 0) return FAILED;
	int n = 1;
	while (n < i && s)
	{
		n++;
		s = s->next;
	}
	if (!s) return FAILED;
	else
	{
		*e = s->data;
		return SUCCESS;
	}

}

//**********************得到e的索引**********************//
int LocateDLinkElem(DLinkNode* L, int e)
{
	DLinkNode* s = L;
	int i = 1;
	while (s->next && s->data != e)
	{
		s = s->next;
		i++;
	}
	if (s->next == NULL) return FAILED;
	else return i;
}

//**********************插入元素**********************//

int DLinkListInsert(DLinkNode* L, int i, int e)
{
	if (i < 0)  return FAILED;
	int j = 0;
	DLinkNode* s = L;
	DLinkNode* r;
	s = L;
	int n = 1;
	while (n < i && s)
	{
		s = s->next;
		n++;
	}
	if (!s ) return FAILED;
	else
	{
		r = (DLinkNode*)malloc(sizeof(DLinkNode));
		r->data = e;
		r->next = s->next;
		r->prior = s;
		if (s->next)
			s->next->prior = r;
		s->next = r;
		return SUCCESS;
	}

}

//**********************删除元素**********************//

int DLinkListDelete(DLinkNode* L, int i, int* e)
{
	if (i < 1) return FAILED;
	int j = 1; 
	DLinkNode* p = L->next;
	DLinkNode* q;
	while (j < i && p)
	{
		j++;
		p = p->next;
	}
	if (!p)  return FAILED;
	p->prior->next = p->next;
	if (p->next)
		p->next->prior = p->prior;
	free(p);
	return SUCCESS;
}

双链表应用实例

//将双向链表的元素进行倒序处理
void DlinkReverse(DLinkNode* L)
{
	DLinkNode* p = L->next;
	DLinkNode* q;
	L->next = NULL;
	while (p)
	{
		q = p->next;
		p->next = L->next;
		if (L->next)
			L->next->prior = p;
		L->next = p;
		p->prior = L;
		p = q;
	}
}


//使带头结点的双向链表元素有序递增
void SortDlink(DLinkNode* L)
{
	DLinkNode* pre;
	DLinkNode* q;
	DLinkNode* p = L->next->next;
	L->next->next = NULL;	
	while (p)
	{
		pre = L;
		q = p->next;
		while (pre->next && pre->next->data < p->data)
			pre = pre->next;
		p->next = pre->next;
		p->prior = pre;
		if (pre->next)
			pre->next ->prior= p;
		pre->next = p;
		p = q;
		

	}

}