数据结构

删除带头结点的循环链表中元素为m的结点。

分数:

请勿频繁操作

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
void del(pCircleLink L, int m);

int main(void)
{
	int n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始循环链表为:\n");
	output(&L);
	printf("输入需要删除的元素:");
	scanf("%d", &n);
	del(&L, n);
	printf("output:\n");
	output(&L);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
void del(pCircleLink L, int m);

int main(void)
{
	int n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始循环链表为:\n");
	output(&L);
	printf("输入需要删除的元素:");
	scanf("%d", &n);
	del(&L, n);
	printf("output:\n");
	output(&L);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/

该程序是带头结点双向链表的基本操作。完成Insert函数功能，该函数将数据data插入到双向链表的第pos个位置上。

分数:

请勿频繁操作

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *prior;
	struct _DoubleLink *next;
	int length;
} DoubleLink, *pDoubleLink;

void Create(pDoubleLink L, int n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);
int Insert(pDoubleLink L, int data, int pos);

int main(void)
{
	int n, data, pos, flag;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->prior = L->next = NULL;
	L->length = 0;

	printf("输入需要创建的链表元素个数:");
	scanf("%d", &n);
	Create(L, n);

	printf("输入需要插入的元素值:");
	scanf("%d", &data);
	printf("输入需要插入的元素的位置:");
	scanf("%d", &pos);

	flag = Insert(L, data, pos);
	if (flag < 0)
	{
		printf("output:\nThe Position is Wrong!\n");
	}

	if (flag >= 0)
	{
		Doubleout(L);
	}

	Destroy(L);
	free(L);
	return 0;
}

/*头插法创建双向链表*/
void Create(pDoubleLink L, int n)
{
	int i, data;
	pDoubleLink p;
	printf("输入创建链表各元素的值:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &data);

		p = (pDoubleLink)malloc(sizeof(DoubleLink));
		p->data = data;
		p->next = L->next;
		p->prior = L;

		if (L->next != NULL)
		{
			L->next->prior = p;
			L->next = p;
		}
		else
		{
			L->next = p;
		}
	}
	L->length = n;
}

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->prior;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->next;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

/******start******/

/******end******/

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *prior;
	struct _DoubleLink *next;
	int length;
} DoubleLink, *pDoubleLink;

void Create(pDoubleLink L, int n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);
int Insert(pDoubleLink L, int data, int pos);

int main(void)
{
	int n, data, pos, flag;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->prior = L->next = NULL;
	L->length = 0;

	printf("输入需要创建的链表元素个数:");
	scanf("%d", &n);
	Create(L, n);

	printf("输入需要插入的元素值:");
	scanf("%d", &data);
	printf("输入需要插入的元素的位置:");
	scanf("%d", &pos);

	flag = Insert(L, data, pos);
	if (flag < 0)
	{
		printf("output:\nThe Position is Wrong!\n");
	}

	if (flag >= 0)
	{
		Doubleout(L);
	}

	Destroy(L);
	free(L);
	return 0;
}

/*头插法创建双向链表*/
void Create(pDoubleLink L, int n)
{
	int i, data;
	pDoubleLink p;
	printf("输入创建链表各元素的值:\n");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &data);

		p = (pDoubleLink)malloc(sizeof(DoubleLink));
		p->data = data;
		p->next = L->next;
		p->prior = L;

		if (L->next != NULL)
		{
			L->next->prior = p;
			L->next = p;
		}
		else
		{
			L->next = p;
		}
	}
	L->length = n;
}

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->prior;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->next;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

/******start******/

/******end******/

将带头结点的循环链表中元素m替换为n。

分数:

请勿频繁操作

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
void replace(pCircleLink L, int m, int n);

int main(void)
{
	int m, n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始循环链表为:\n");
	output(&L);
	printf("输入需要被替换的元素m:");
	scanf("%d", &m);
	printf("输入需要替换的元素n:");
	scanf("%d", &n);
	replace(&L, m, n);
	printf("output:\n");
	output(&L);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
void replace(pCircleLink L, int m, int n);

int main(void)
{
	int m, n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始循环链表为:\n");
	output(&L);
	printf("输入需要被替换的元素m:");
	scanf("%d", &m);
	printf("输入需要替换的元素n:");
	scanf("%d", &n);
	replace(&L, m, n);
	printf("output:\n");
	output(&L);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/

该程序是带头结点双向链表的基本操作。完成HeadInsert函数功能，调用该函数一次，可以在该双向链表的最前面插入一个元素。

分数:

请勿频繁操作

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *left;
	struct _DoubleLink *right;
	int length;
} DoubleLink, *pDoubleLink;

void HeadInsert(pDoubleLink L, int data);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

int main(void)
{
	int i, n, data;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->left = L->right = NULL;
	L->length = 0;

	printf("输入需要插入的元素个数:");
	scanf("%d", &n);
	printf("输入需要插入的元素值(头插法)");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &data);
		HeadInsert(L, data);
	}

	Doubleout(L);

	Destroy(L);
	free(L);
	return 0;
}

/******start******/

/******end******/

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->right != NULL)
	{
		printf("%d ", p->right->data);
		p = p->right;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->left;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->right;
	while (p != NULL)
	{
		q = p->right;
		free(p);
		p = q;
	}
}

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *left;
	struct _DoubleLink *right;
	int length;
} DoubleLink, *pDoubleLink;

void HeadInsert(pDoubleLink L, int data);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

int main(void)
{
	int i, n, data;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->left = L->right = NULL;
	L->length = 0;

	printf("输入需要插入的元素个数:");
	scanf("%d", &n);
	printf("输入需要插入的元素值(头插法)");
	for (i = 0; i < n; i++)
	{
		scanf("%d", &data);
		HeadInsert(L, data);
	}

	Doubleout(L);

	Destroy(L);
	free(L);
	return 0;
}

/******start******/

/******end******/

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->right != NULL)
	{
		printf("%d ", p->right->data);
		p = p->right;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->left;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->right;
	while (p != NULL)
	{
		q = p->right;
		free(p);
		p = q;
	}
}

该程序是带头结点双向链表的基本操作。完成CreateTail函数，该函数使用尾插法创建双向链表。

分数:

请勿频繁操作

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *prior;
	struct _DoubleLink *next;
	int length;
} DoubleLink, *pDoubleLink;

void CreateTail(pDoubleLink L, int n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

int main(void)
{
	int n;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->prior = L->next = NULL;
	L->length = 0;

	printf("输入需要插入的元素个数:");
	scanf("%d", &n);
	CreateTail(L, n);

	Doubleout(L);

	Destroy(L);
	free(L);
	return 0;
}

/******start******/

/******end******/

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->prior;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->next;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

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

typedef struct _DoubleLink
{
	int data;
	struct _DoubleLink *prior;
	struct _DoubleLink *next;
	int length;
} DoubleLink, *pDoubleLink;

void CreateTail(pDoubleLink L, int n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

int main(void)
{
	int n;
	pDoubleLink L = (pDoubleLink)malloc(sizeof(DoubleLink));		//头结点
	L->prior = L->next = NULL;
	L->length = 0;

	printf("输入需要插入的元素个数:");
	scanf("%d", &n);
	CreateTail(L, n);

	Doubleout(L);

	Destroy(L);
	free(L);
	return 0;
}

/******start******/

/******end******/

void Doubleout(pDoubleLink L)
{
	pDoubleLink p = L;
	printf("output:\n");
	while (p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	printf("\n");
	while (p != L)
	{
		printf("%d ", p->data);
		p = p->prior;
	}
	printf("\n");
}

void Destroy(pDoubleLink L)
{
	pDoubleLink p, q;
	
	p = q = L->next;
	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

删除带头结点非循环双向链表中值为x的所有结点。创建链表为尾插法，0表示创建链表结束。

图中第1行的3，第3行为键盘输入。

分数:

请勿频繁操作

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

typedef struct _node
{
	int data;
	struct _node *next;
	struct _node *prior;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
void destroy(Link head);
void erase(Link head, int x);

int main(void)
{
	int flag = 0;
	int x = 0;
	Link head;

	printf("Input x:");
	scanf("%d", &x);
	printf("Input data:\n");
	flag = create(&head);
	if (flag <= 0)
	{
		return 0;
	}
	printf("Link :\n");
	output(head);

	erase(head, x);
	printf("Output:\n");
	output(head);

	destroy(head);
	return 0;
}

int create(Link *head)
{
	int temp;
	pNode p, q;

	*head = (pNode)malloc(sizeof(Node));
	if (*head == NULL)
	{
		return -1;
	}
	(*head)->next = NULL;
	(*head)->prior = NULL;
	q = *head;

	scanf("%d", &temp);
	while (temp != 0)
	{
		p = (pNode)malloc(sizeof(Node));
		if (p == NULL)
		{
			destroy(*head);
			return -1;
		}
		p->data = temp;
		q->next = p;
		p->prior = q;
		q = p;
		scanf("%d", &temp);
	}
	q->next = NULL;

	return 1;
}

void output(Link head)
{
	if (head == NULL)
	{
		return ;
	}
	printf("Forward: ");
	while (head->next != NULL)
	{
		printf("%d ", head->next->data);
		head = head->next;
	}
	printf("\n");
	printf("Backward: ");
	while (head->prior != NULL)
	{
		printf("%d ", head->data);
		head = head->prior;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;

	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

/******start******/

/******end******/

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

typedef struct _node
{
	int data;
	struct _node *next;
	struct _node *prior;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
void destroy(Link head);
void erase(Link head, int x);

int main(void)
{
	int flag = 0;
	int x = 0;
	Link head;

	printf("Input x:");
	scanf("%d", &x);
	printf("Input data:\n");
	flag = create(&head);
	if (flag <= 0)
	{
		return 0;
	}
	printf("Link :\n");
	output(head);

	erase(head, x);
	printf("Output:\n");
	output(head);

	destroy(head);
	return 0;
}

int create(Link *head)
{
	int temp;
	pNode p, q;

	*head = (pNode)malloc(sizeof(Node));
	if (*head == NULL)
	{
		return -1;
	}
	(*head)->next = NULL;
	(*head)->prior = NULL;
	q = *head;

	scanf("%d", &temp);
	while (temp != 0)
	{
		p = (pNode)malloc(sizeof(Node));
		if (p == NULL)
		{
			destroy(*head);
			return -1;
		}
		p->data = temp;
		q->next = p;
		p->prior = q;
		q = p;
		scanf("%d", &temp);
	}
	q->next = NULL;

	return 1;
}

void output(Link head)
{
	if (head == NULL)
	{
		return ;
	}
	printf("Forward: ");
	while (head->next != NULL)
	{
		printf("%d ", head->next->data);
		head = head->next;
	}
	printf("\n");
	printf("Backward: ");
	while (head->prior != NULL)
	{
		printf("%d ", head->data);
		head = head->prior;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;

	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

/******start******/

/******end******/

统计带头结点的循环链表中元素的个数。

分数:

请勿频繁操作

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
int count(pCircleLink L);

int main(void)
{
	int n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	
	n = count(&L);
	printf("output:\n该循环链表有%d个元素.\n", n);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/

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

typedef struct _CircleLink
{
	int data;
	struct _CircleLink *next;
} CircleLink, *pCircleLink;

void Destroy(pCircleLink L);
int create(pCircleLink L);
void output(pCircleLink L);
int count(pCircleLink L);

int main(void)
{
	int n;
	CircleLink L;

	L.next = &L;

	if (create(&L) < 0)
	{
		return 0;
	}
	
	n = count(&L);
	printf("output:\n该循环链表有%d个元素.\n", n);
	Destroy(&L);
	return 0;
}

void Destroy(pCircleLink L)
{
	pCircleLink p, q;
	p = q = L->next;
	while (p->next != L)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

int create(pCircleLink L)
{
	int number;
	pCircleLink p, q;

	p = L;
	printf("输入创建循环链表的元素(0表示结束):\n");
	scanf("%d", &number);
	while (number != 0)
	{
		q = (pCircleLink)malloc(sizeof(CircleLink));
		if (q == NULL)
		{
			return -1;
		}
		q->data = number;
		q->next = p->next;
		p->next = q;
		p = q;
		scanf("%d", &number);
	}
	return 1;
}

void output(pCircleLink L)
{
	pCircleLink p = L;
	while (p->next != L)
	{
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}

/******start******/

/******end******/