数据结构

将已有带头结点链表L1中的值为奇数的元素从L1中删除，并将这些奇数结点使用尾插方法建立到带头结点链表L2中。创建链表为头插法，0表示创建链表结束。

图中第二行为键盘输入。

分数: 100

请勿频繁操作

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

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

int create(Link head);
void output(Link head);
void destroy(Link head);
void function(Link h1, Link h2);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	function(L1, L2);

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	destroy(L1);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

	if (head == NULL)
	{
		return ;
	}
	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;
} Node, *pNode, *Link;

int create(Link head);
void output(Link head);
void destroy(Link head);
void function(Link h1, Link h2);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	function(L1, L2);

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	destroy(L1);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

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

/******start******/
void function(Link h1, Link h2) {
    pNode p1 = h1, p2 = h2;

    while (p1->next != NULL) {
        if (p1->next->data % 2 == 1) {
            p2->next = p1->next;
            p2 = p2->next;
            p1->next = p2->next;
        } else {
            p1 = p1->next;
        }
    }
    p2->next = NULL;
}
/******end******/

两个一元多项式求和。polyn1和polyn2分别表示两个一元多项式，是带头结点单链表。求和后的一元多项式使用polyn1来表示。输入每对数据分别表示系数和指数，均为0表示输入结束（系数为0不做处理，指数重复出现不做处理）。

分数: 100

请勿频繁操作

//带头结点链表，多项式求和
#include <stdio.h>
#include <stdlib.h>

typedef struct _Node
{
	int coefficient;	//系数
	int exponent;		//指数
	struct _Node *next;
} Node, *pLink;

int Create(pLink *head);
int Insert(pLink head, int coef, int expo);
int polynomial_add(pLink head1, pLink head2);	//求和后的数据放置在head1链表中
void output(pLink head);
void Destroy(pLink head);

int main(void)
{
	pLink polyn1, polyn2;
	printf("输入第1个多项式的系数和指数(都为0表示结束):\n");
	if (Create(&polyn1) < 0)
	{
		return 0;
	}
	printf("输入第2个多项式的系数和指数(都为0表示结束):\n");
	if (Create(&polyn2) < 0)
	{
		return 0;
	}
	printf("第1个多项式为:\n");
	output(polyn1);
	printf("第2个多项式为:\n");
	output(polyn2);
	polynomial_add(polyn1, polyn2);
	printf("output:\n两个多项式求和结果为:\n");
	output(polyn1);
	Destroy(polyn1);
	Destroy(polyn2);
	return 0;
}

int Create(pLink *head)
{
	int coef;		//系数
	int expo;		//指数
	int flag;		//标识

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

	scanf("%d%d", &coef, &expo);
	while (coef != 0 || expo != 0)
	{
		flag = Insert(*head, coef, expo);
		if (flag < 0)
		{
			return -1;
		}
		else if (flag == 0)
		{
			;//系数为0，或者指数与之前输入过的相同，不做操作
		}
		scanf("%d%d", &coef, &expo);
	}
	return 1;
}

int Insert(pLink head, int coef, int expo)
{
	pLink p, s;

	if (coef == 0)
	{
		return 0;
	}
	p = head;
	while (p->next != NULL && p->next->exponent > expo)
	{
		p = p->next;
	}
	
	if (p->next != NULL)
	{
		if (p->next->exponent == expo)
		{
			return 0;
		}
	}
	s = (Node *)malloc(sizeof(Node));
	if (s == NULL)
	{
		return -1;
	}
	s->coefficient = coef;
	s->exponent = expo;
	s->next = p->next;
	p->next = s;

	return 1;
}

void output(pLink head)
{
	pLink p = head->next;
	if (p == NULL)
	{
		printf("0\n");
		return ;
	}
	while (p->next != NULL)
	{
		printf("%d*x^%d + ", p->coefficient, p->exponent);
		p = p->next;
	}
	if (p->exponent != 0)
	{
		printf("%d*x^%d", p->coefficient, p->exponent);
	}
	else
	{
		printf("%d", p->coefficient);
	}
	printf("\n");
}

void Destroy(pLink head)
{
	pLink p;

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

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

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

//带头结点链表，多项式求和
#include <stdio.h>
#include <stdlib.h>

typedef struct _Node
{
	int coefficient;	//系数
	int exponent;		//指数
	struct _Node *next;
} Node, *pLink;

int Create(pLink *head);
int Insert(pLink head, int coef, int expo);
int polynomial_add(pLink head1, pLink head2);	//求和后的数据放置在head1链表中
void output(pLink head);
void Destroy(pLink head);

int main(void)
{
	pLink polyn1, polyn2;
	printf("输入第1个多项式的系数和指数(都为0表示结束):\n");
	if (Create(&polyn1) < 0)
	{
		return 0;
	}
	printf("输入第2个多项式的系数和指数(都为0表示结束):\n");
	if (Create(&polyn2) < 0)
	{
		return 0;
	}
	printf("第1个多项式为:\n");
	output(polyn1);
	printf("第2个多项式为:\n");
	output(polyn2);
	polynomial_add(polyn1, polyn2);
	printf("output:\n两个多项式求和结果为:\n");
	output(polyn1);
	Destroy(polyn1);
	Destroy(polyn2);
	return 0;
}

int Create(pLink *head)
{
	int coef;		//系数
	int expo;		//指数
	int flag;		//标识

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

	scanf("%d%d", &coef, &expo);
	while (coef != 0 || expo != 0)
	{
		flag = Insert(*head, coef, expo);
		if (flag < 0)
		{
			return -1;
		}
		else if (flag == 0)
		{
			;//系数为0，或者指数与之前输入过的相同，不做操作
		}
		scanf("%d%d", &coef, &expo);
	}
	return 1;
}

int Insert(pLink head, int coef, int expo)
{
	pLink p, s;

	if (coef == 0)
	{
		return 0;
	}
	p = head;
	while (p->next != NULL && p->next->exponent > expo)
	{
		p = p->next;
	}
	
	if (p->next != NULL)
	{
		if (p->next->exponent == expo)
		{
			return 0;
		}
	}
	s = (Node *)malloc(sizeof(Node));
	if (s == NULL)
	{
		return -1;
	}
	s->coefficient = coef;
	s->exponent = expo;
	s->next = p->next;
	p->next = s;

	return 1;
}

void output(pLink head)
{
	pLink p = head->next;
	if (p == NULL)
	{
		printf("0\n");
		return ;
	}
	while (p->next != NULL)
	{
		printf("%d*x^%d + ", p->coefficient, p->exponent);
		p = p->next;
	}
	if (p->exponent != 0)
	{
		printf("%d*x^%d", p->coefficient, p->exponent);
	}
	else
	{
		printf("%d", p->coefficient);
	}
	printf("\n");
}

void Destroy(pLink head)
{
	pLink p;

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

/******start******/
int polynomial_add(pLink head1, pLink head2) {
    int sum;
    pLink p, q, s, temp;

    s = head1;
    p = head1->next;
    q = head2->next;
    head2->next = NULL;

    while (p != NULL && q != NULL) {
        if (p->exponent > q->exponent) {
            s->next = p;
            s = p;
            p = p->next;
        } else if (p->exponent < q->exponent) {
            s->next = q;
            s = q;
            q = q->next;
        } else {
            sum = p->coefficient + q->coefficient;
            if (sum != 0) {
                p->coefficient = sum;
                s->next = p;
                s = p;
                p = p->next;

                temp = q;
                q = q->next;
                free(temp);
            } else {
                temp = p;
                p = p->next;
                free(temp);
                temp = q;
                q = q->next;
                temp = q;
            }
        }
    }
    if (p == NULL) {
        s->next = q;
    } else {
        s->next = p;
    }
    return 1;
}
/******end******/

已知有序（非递减）带头结点的链表。现需要插入一个值为n的结点，保证该链表依然有序。如图示，第一、二行是键盘输入，第三、四行是输出。第一行是建立链表，0表示结束链表建立（0不存入链表）。第二行3表示插入值为3的结点，保证链表依然有序。当输入的链表无序时，输出链表无序（不做插入操作）。请在/******start******/和/******end******/注释行中间完成相关代码。

分数: 80

请勿频繁操作

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
int insert(node *head, int value);	//将值为value的结点插入到链表中，依然保证升序

int main(void)
{
	int value, result;
	node *head;

	printf("Input: ");
	head = create();
	scanf("%d", &value);
	
	printf("Output: ");
	out(head);			//输出原链表
	result = insert(head, value);
	if (result == 0)
	{
		printf("The link is disorder!\n");
	}
	else
	{
		out(head);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
int insert(node *head, int value);	//将值为value的结点插入到链表中，依然保证升序

int main(void)
{
	int value, result;
	node *head;

	printf("Input: ");
	head = create();
	scanf("%d", &value);
	
	printf("Output: ");
	out(head);			//输出原链表
	result = insert(head, value);
	if (result == 0)
	{
		printf("The link is disorder!\n");
	}
	else
	{
		out(head);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

/******start******/
int insert(node *head, int value) {
    node *p, *q, *r;
    p = head->next;
    q = head;
    while (p != NULL) {
        if (p->data > value) {
            r = (node *) malloc(sizeof(node));
            r->data = value;
            r->next = p;
            q->next = r;
            return 1;
        }
        if (p->data == value) {
            return 0;
        }
        q = p;
        p = p->next;
    }
    r = (node *) malloc(sizeof(node));
    r->data = value;
    r->next = NULL;
    q->next = r;
    return 1;
}
/******end******/

使用尾插法创建不带头结点的单链表，其中创建的结点个数为n，使用形参回传该链表头指针。

图中第一行的5，第二行的1 2 3 4 5是键盘输入的。

分数: 100

请勿频繁操作

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

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

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

int main(void)
{
	int n = 0;
	Link head = NULL;
	
	printf("Input n:");
	scanf("%d", &n);

	if (create(&head, n) < 0)
	{
		return 0;
	}

	output(head);

	destroy(head);
	return 0;
}

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

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

void output(Link head)
{
	pNode p = head;

	printf("Output:\n");
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;

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

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

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

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

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

int main(void)
{
	int n = 0;
	Link head = NULL;
	
	printf("Input n:");
	scanf("%d", &n);

	if (create(&head, n) < 0)
	{
		return 0;
	}

	output(head);

	destroy(head);
	return 0;
}

/******start******/
int create(Link *head, int n) {
    int i;
    pNode p, q;

    for (i = 1; i <= n; i++) {
        p = (pNode) malloc(sizeof(Node));
        if (p == NULL) {
            return -1;
        }
        scanf("%d", &p->data);

        if (i == 1) {
            *head = q = p;
        } else {
            q->next = p;
            q = p;
        }
    }
    q->next = NULL;
    return 1;
}
/******end******/

void output(Link head)
{
	pNode p = head;

	printf("Output:\n");
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;

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

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

该程序是带头结点双向链表的基本操作。完成HeadInsert函数功能，该函数使用头插法创建双向链表，创建的双向链表有n个结点。

分数: 100

请勿频繁操作

#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 n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

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

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

	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 n);
void Doubleout(pDoubleLink L);
void Destroy(pDoubleLink L);

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

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

	Doubleout(L);

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

/******start******/
void HeadInsert(pDoubleLink L, int n) {
    int i;
    int temp;
    pDoubleLink p;

    printf("Input:\n");
    for (i = 1; i <= n; i++) {
        scanf("%d", &temp);
        p = (pDoubleLink) malloc(sizeof(DoubleLink));
        if (p == NULL) {
            return;
        }
        p->data = temp;
        if (i == 1) {
            p->right = L->right;
            p->left = L;
            L->right = p;
        } else {
            p->right = L->right;
            p->left = L;
            p->right->left = p;
            L->right = p;
        }
    }
}
/******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;
	}
}

使用头插法创建带头结点的单链表，数据域为整型，在创建时输入的数据为-222时表示结束创建（-222不保存在链表里），使用形参回传链表头指针。

图中第二行为键盘输入。

分数: 100

请勿频繁操作

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

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

void output(Link head);
void destroy(Link head);
int create(Link *head);

int main(void)
{
	Link head = NULL;

	printf("Input data:\n");
	create(&head);
	output(head);
	destroy(head);

	return 0;
}

void output(Link head)
{
	pNode p = NULL;

	printf("Output:\n");
	if (head == NULL)
	{
		return ;
	}
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p = NULL;

	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;
} Node, *pNode, *Link;

void output(Link head);
void destroy(Link head);
int create(Link *head);

int main(void)
{
	Link head = NULL;

	printf("Input data:\n");
	create(&head);
	output(head);
	destroy(head);

	return 0;
}

void output(Link head)
{
	pNode p = NULL;

	printf("Output:\n");
	if (head == NULL)
	{
		return ;
	}
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p = NULL;

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

/******start******/
int create(Link *head) {
    int temp;
    pNode p;

    *head = (pNode) malloc(sizeof(Node));    //头结点
    if (*head == NULL) {
        return -1;
    }
    (*head)->next = NULL;

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

已知带头结点的有序链表head_a，head_b。合并两个链表到head_a，要求依然有序。图示第一、二行为输入，表示建立链表（0表示结束，不包含在链表）。第三行为输出。如果输入序列不能使链表为有序，则输出链表无序（注：当输入5 3 7 1 9 0时，建立的链表为1 3 5 7 9）。请在/******start******/和/******end******/注释行中间完成相关代码。

分数:

请勿频繁操作

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
int merge(node *la, node *lb);	//将la，lb链表合并到la，依然保证升序

int main(void)
{
	int result;
	node *head_a, *head_b;

	printf("Input: ");
	head_a = create();
	head_b = create();

	result = merge(head_a, head_b);

	printf("Output: ");
	if (result == 0)
	{
		printf("One link is disorder!\n");
	}
	else
	{
		out(head_a);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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


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

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
int merge(node *la, node *lb);	//将la，lb链表合并到la，依然保证升序

int main(void)
{
	int result;
	node *head_a, *head_b;

	printf("Input: ");
	head_a = create();
	head_b = create();

	result = merge(head_a, head_b);

	printf("Output: ");
	if (result == 0)
	{
		printf("One link is disorder!\n");
	}
	else
	{
		out(head_a);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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


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

使用n1到n2之间（含n1和n2，n1≤n2）能被13整除且不能被5整除的元素创建链表，使用尾插法带头结点方式创建该链表。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

已有带头结点链表s和t，在s链表中找出最后一个不在t链表中的元素。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

使用n1到n2之间（含n1和n2，1000≤n1≤n2≤9999）符合abcd=(ab+cd)*(ab+cd)条件的元素创建链表，使用尾插法带头结点方式创建该链表。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

两个一元多项式求乘积。polyn1和polyn2分别表示两个一元多项式，是带头结点单链表。求积后的一元多项式使用polyn3来表示。输入每对数据分别表示系数和指数，均为0表示输入结束（系数为0不做处理，指数重复或升序不做处理）。

图中第2行、第4行为键盘输入。

分数:

请勿频繁操作

//带头结点链表，多项式求积
#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
	int coefficient;	//系数
	int exponent;		//指数
	struct _node *next;
} Node, *pNode, *Link;

int initialize(Link *head);			//创建头结点，初始化无元素的带头结点的空链表
int create(Link head);
int insert(Link head, int coef, int expo);
int polynomial_mul(Link head1, Link head2, Link head3);	//求积后的数据放置在head3链表中
void output(Link head);
void destroy(Link head);

int main(void)
{
	Link polyn1, polyn2, polyn3;

	if (initialize(&polyn1) <= 0)
	{
		return 0;
	}
	if (initialize(&polyn2) <= 0)
	{
		destroy(polyn1);
		return 0;
	}
	if (initialize(&polyn3) <= 0)
	{
		destroy(polyn1);
		destroy(polyn2);
		return 0;
	}
	printf("输入第1个多项式的系数和指数(都为0表示结束):\n");
	if (create(polyn1) < 0)
	{
		return 0;
	}
	printf("输入第2个多项式的系数和指数(都为0表示结束):\n");
	if (create(polyn2) < 0)
	{
		return 0;
	}
	printf("第1个多项式为:\n");
	output(polyn1);
	printf("第2个多项式为:\n");
	output(polyn2);
	if (polynomial_mul(polyn1, polyn2, polyn3) > 0)
	{
		printf("Output:\n两个多项式求积结果为:\n");
		output(polyn3);
	}

	destroy(polyn1);
	destroy(polyn2);
	destroy(polyn3);
	return 0;
}

int initialize(Link *head)
{
	*head = (pNode)malloc(sizeof(Node));
	if (*head == NULL)
	{
		return -1;
	}
	(*head)->next = NULL;
	return 1;
}

int create(Link head)
{
	int coef;		//系数
	int expo;		//指数
	pNode p, q;
	
	if (head == NULL)
	{
		return -1;
	}

	q = head;
	scanf("%d%d", &coef, &expo);
	while (coef != 0 || expo != 0)
	{
		if (coef != 0)	//系数不为0，才存储到链表中
		{
			if (q == head)	//第1个数据结点
			{
				p = (pNode)malloc(sizeof(Node));
				if (p == NULL)
				{
					destroy(head);
					return -1;
				}
				p->coefficient = coef;
				p->exponent = expo;
				q->next = p;
				q = p;
			}
			else
			{
				if (q->exponent > expo)	//链表中指数按降序存放
				{
					p = (pNode)malloc(sizeof(Node));
					if (p == NULL)
					{
						destroy(head);
						return -1;
					}
					p->coefficient = coef;
					p->exponent = expo;
					q->next = p;
					q = p;
				}
			}
			//不符合要求的输入也不存入
		}
		scanf("%d%d", &coef, &expo);
	}
	q->next = NULL;
	return 1;
}

void output(Link head)
{
	pNode p;
	
	if (head == NULL)
	{
		return ;
	}

	p = head->next;
	if (p == NULL)	//空链表，相当于只有0值，系数为0的结点不存于链表中
	{
		printf("0\n");
		return ;
	}

	while (p->next != NULL)
	{
		if (p != head->next)
		{
			if (p->coefficient > 0)
			{
				printf("+ %d", p->coefficient);
			}
			else
			{
				printf("- %d", -p->coefficient);
			}
		}
		else
		{
			printf("%d", p->coefficient);
		}
		printf("*x^%d ", p->exponent);
		p = p->next;
	}
	if (p->exponent != 0)
	{
		if (p->coefficient > 0)
		{
			printf("+ %d", p->coefficient);
		}
		else
		{
			printf("- %d", -p->coefficient);
		}
		printf("*x^%d", p->exponent);
	}
	else
	{
		if (p->coefficient > 0)
		{
			printf("+ %d", p->coefficient);
		}
		else
		{
			printf("- %d", -p->coefficient);
		}
	}
	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 coefficient;	//系数
	int exponent;		//指数
	struct _node *next;
} Node, *pNode, *Link;

int initialize(Link *head);			//创建头结点，初始化无元素的带头结点的空链表
int create(Link head);
int insert(Link head, int coef, int expo);
int polynomial_mul(Link head1, Link head2, Link head3);	//求积后的数据放置在head3链表中
void output(Link head);
void destroy(Link head);

int main(void)
{
	Link polyn1, polyn2, polyn3;

	if (initialize(&polyn1) <= 0)
	{
		return 0;
	}
	if (initialize(&polyn2) <= 0)
	{
		destroy(polyn1);
		return 0;
	}
	if (initialize(&polyn3) <= 0)
	{
		destroy(polyn1);
		destroy(polyn2);
		return 0;
	}
	printf("输入第1个多项式的系数和指数(都为0表示结束):\n");
	if (create(polyn1) < 0)
	{
		return 0;
	}
	printf("输入第2个多项式的系数和指数(都为0表示结束):\n");
	if (create(polyn2) < 0)
	{
		return 0;
	}
	printf("第1个多项式为:\n");
	output(polyn1);
	printf("第2个多项式为:\n");
	output(polyn2);
	if (polynomial_mul(polyn1, polyn2, polyn3) > 0)
	{
		printf("Output:\n两个多项式求积结果为:\n");
		output(polyn3);
	}

	destroy(polyn1);
	destroy(polyn2);
	destroy(polyn3);
	return 0;
}

int initialize(Link *head)
{
	*head = (pNode)malloc(sizeof(Node));
	if (*head == NULL)
	{
		return -1;
	}
	(*head)->next = NULL;
	return 1;
}

int create(Link head)
{
	int coef;		//系数
	int expo;		//指数
	pNode p, q;
	
	if (head == NULL)
	{
		return -1;
	}

	q = head;
	scanf("%d%d", &coef, &expo);
	while (coef != 0 || expo != 0)
	{
		if (coef != 0)	//系数不为0，才存储到链表中
		{
			if (q == head)	//第1个数据结点
			{
				p = (pNode)malloc(sizeof(Node));
				if (p == NULL)
				{
					destroy(head);
					return -1;
				}
				p->coefficient = coef;
				p->exponent = expo;
				q->next = p;
				q = p;
			}
			else
			{
				if (q->exponent > expo)	//链表中指数按降序存放
				{
					p = (pNode)malloc(sizeof(Node));
					if (p == NULL)
					{
						destroy(head);
						return -1;
					}
					p->coefficient = coef;
					p->exponent = expo;
					q->next = p;
					q = p;
				}
			}
			//不符合要求的输入也不存入
		}
		scanf("%d%d", &coef, &expo);
	}
	q->next = NULL;
	return 1;
}

void output(Link head)
{
	pNode p;
	
	if (head == NULL)
	{
		return ;
	}

	p = head->next;
	if (p == NULL)	//空链表，相当于只有0值，系数为0的结点不存于链表中
	{
		printf("0\n");
		return ;
	}

	while (p->next != NULL)
	{
		if (p != head->next)
		{
			if (p->coefficient > 0)
			{
				printf("+ %d", p->coefficient);
			}
			else
			{
				printf("- %d", -p->coefficient);
			}
		}
		else
		{
			printf("%d", p->coefficient);
		}
		printf("*x^%d ", p->exponent);
		p = p->next;
	}
	if (p->exponent != 0)
	{
		if (p->coefficient > 0)
		{
			printf("+ %d", p->coefficient);
		}
		else
		{
			printf("- %d", -p->coefficient);
		}
		printf("*x^%d", p->exponent);
	}
	else
	{
		if (p->coefficient > 0)
		{
			printf("+ %d", p->coefficient);
		}
		else
		{
			printf("- %d", -p->coefficient);
		}
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;

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

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

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

已知带头结点的单向链表，在该链表第n个结点位置插入值为m的结点。如图示：第一行、第二行的数字是由键盘输入的。第三行、第四行是输出。第一行是建立链表，0表示链表结束（不存于链表）。第二行3 20表示将值为20的结点插入到该链表的第三个位置（当位置值小于等于1时均插入在表头，当位置值大于结点个数时均插入在表尾）。请在/******start******/和/******end******/注释行中间完成相关代码。

分数:

请勿频繁操作

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
void insert(node *head, int pos, int value);	//将值为value的结点插入到第pos个位置上

int main(void)
{
	int pos, value;
	node *head;

	printf("Input: ");
	head = create();
	scanf("%d%d", &pos, &value);	

	printf("Output: ");
	out(head);		//输出原链表
	insert(head, pos, value);
	out(head);		//输出插入元素后的链表
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
void out(node *head);	//输出链表
void insert(node *head, int pos, int value);	//将值为value的结点插入到第pos个位置上

int main(void)
{
	int pos, value;
	node *head;

	printf("Input: ");
	head = create();
	scanf("%d%d", &pos, &value);	

	printf("Output: ");
	out(head);		//输出原链表
	insert(head, pos, value);
	out(head);		//输出插入元素后的链表
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

已知带头结点的链表la，lb，将lb链表连接至la后。图示第1、3行是输入，建立链表（0表示建立结束，不包含在链表里），第2、4行是原始链表la和lb的输出。请在/******start******/和/******end******/注释行中间完成相关代码。

分数:

请勿频繁操作

#include <stdio.h>
#include <malloc.h>
typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();   //建立带头结点的链表
void out(node *head); //输出链表
void concat(node *la, node *lb);	//将lb连接到la之后
int main(void)
{
	node *head_a, *head_b;
	printf("Input Link a:");
	head_a = create();
	out(head_a);
	printf("Input Link b:");
	head_b = create();
	out(head_b);
	concat(head_a, head_b);
	printf("Output: ");
	out(head_a);
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;
	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;
	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		} 
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

#include <stdio.h>
#include <malloc.h>
typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();   //建立带头结点的链表
void out(node *head); //输出链表
void concat(node *la, node *lb);	//将lb连接到la之后
int main(void)
{
	node *head_a, *head_b;
	printf("Input Link a:");
	head_a = create();
	out(head_a);
	printf("Input Link b:");
	head_b = create();
	out(head_b);
	concat(head_a, head_b);
	printf("Output: ");
	out(head_a);
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;
	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;
	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		} 
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

将已有带头结点链表L1中的数据均为四位整数，将符合条件a+b>c+d（设四位数为abcd，并且千位+百位>十位+个位）的元素从L1中删除，并将这些删除的结点使用头插方法建立到带头结点链表L2中。创建链表为头插法，0表示创建链表结束。

图中第二行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link head);
void output(Link head);
void destroy(Link head);
void function(Link h1, Link h2);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	function(L1, L2);

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	destroy(L1);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

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

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

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

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

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

int create(Link head);
void output(Link head);
void destroy(Link head);
void function(Link h1, Link h2);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	function(L1, L2);

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	destroy(L1);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

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

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

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

删除带头结点链表中，值为k倍数的元素结点。创建链表为尾插法，0表示创建链表结束。

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

分数:

请勿频繁操作

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

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

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


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

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

	erase(head, k);

	printf("Output:\n");
	printf("Result Link: ");
	output(head);

	destroy(head);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

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


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

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

	erase(head, k);

	printf("Output:\n");
	printf("Result Link: ");
	output(head);

	destroy(head);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

使用n1到n2之间（含n1和n2，n1≤n2）是素数的元素创建链表，使用尾插法带头结点方式创建该链表。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

已知带头结点链表，删除给定位置的第n个结点。图示第1、3行为输入。第1行数据建立链表（0表示结束，不包含在链表），第2行输出原始链表，第3行输入删除的结点位置，第4行输出删除第n个位置后的链表。如链表中没有该位置结点，则报错。请在/******start******/和/******end******/注释行中间完成相关代码。

分数:

请勿频繁操作

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();   //建立带头结点的链表
void out(node *head); //输出链表  
int erase(node *head, int pos);	//删除链表head中第pos个位置的节点

int main(void)
{
	int result, pos;
	node *head;
	printf("Input Link: ");
	head = create();
	out(head);    //输出原始链表
	printf("Input position: ");
	scanf("%d", &pos);  //输入位置
	printf("Output: ");

	result = erase(head, pos);
	if (result == 0)
	{
		printf("Error!\n");
	}
	else
	{
		out(head);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;
	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;
	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();   //建立带头结点的链表
void out(node *head); //输出链表  
int erase(node *head, int pos);	//删除链表head中第pos个位置的节点

int main(void)
{
	int result, pos;
	node *head;
	printf("Input Link: ");
	head = create();
	out(head);    //输出原始链表
	printf("Input position: ");
	scanf("%d", &pos);  //输入位置
	printf("Output: ");

	result = erase(head, pos);
	if (result == 0)
	{
		printf("Error!\n");
	}
	else
	{
		out(head);
	}
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;
	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;
	i = 0;
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

void out(node *head)
{
	node *p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

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

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

已有带头结点链表s和t，统计在s链表中但不在t链表中的元素个数。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int count(Link s, Link t);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);

	value = count(s, t);

	printf("Output:\n");
	printf("count=%d\n", value);

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int count(Link s, Link t);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);

	value = count(s, t);

	printf("Output:\n");
	printf("count=%d\n", value);

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

将带头结点单链表（n个结点元素）的前面M（1≤m<n）个元素移动到链表尾部。当m小于1或大于等于n时链表不发生变化。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void move_m(pLink head, int m);
void Destroy(pLink head);

int main(void)
{
	int m;
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	printf("Input m:");
	scanf("%d", &m);
	move_m(head, m);
	output(head);
	Destroy(head);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入元素序列（尾插法）,0表示结束:\n");
	
	scanf("%d", &temp);
	while (temp != 0)
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
		scanf("%d", &temp);
	}
	return 1;
}

void Destroy(pLink head)
{
	pLink p;

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void move_m(pLink head, int m);
void Destroy(pLink head);

int main(void)
{
	int m;
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	printf("Input m:");
	scanf("%d", &m);
	move_m(head, m);
	output(head);
	Destroy(head);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入元素序列（尾插法）,0表示结束:\n");
	
	scanf("%d", &temp);
	while (temp != 0)
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
		scanf("%d", &temp);
	}
	return 1;
}

void Destroy(pLink head)
{
	pLink p;

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

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

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

使用n1到n2之间（含n1和n2，n1≤n2）能被3整除至少有一位数字是5的元素创建链表，使用尾插法带头结点方式创建该链表。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
Node *Create(int n1, int n2);
void Destroy(pLink head);

int main(void)
{
	int n1, n2;
	pLink head = NULL;

	printf("Input n1, n2:");
	scanf("%d%d", &n1, &n2);

	head = Create(n1, n2);
	printf("output:\n");
	output(head);
	Destroy(head);
	return 0;
}

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

void Destroy(pLink head)
{
	pLink p;

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

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

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

已有带头结点链表s和t，统计在s链表中并且存在于t链表中的元素个数。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int count(Link s, Link t);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);

	value = count(s, t);

	printf("Output:\n");
	printf("count=%d\n", value);

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int count(Link s, Link t);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);

	value = count(s, t);

	printf("Output:\n");
	printf("count=%d\n", value);

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

已有带头结点链表s和t，在s链表中找出第一个在t链表中出现的元素。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

已知带头结点的单向链表，求该表表长。图示中1 2 3 4 5 6 7 8 9 10 0由键盘输入，0表示建立链表结束（不存入链表）。第二行输出该链表的长度。请在/******start******/和/******end******/注释行中间完成求链表表长的代码。

分数:

请勿频繁操作

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
int len(node *head);	//求带头结点的链表元素个数

int main(void)
{
	int lenth;
	node *head;

	head = create();
	lenth = len(head);

	printf("Output: %d\n", lenth);
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	printf("Input: ");
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

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

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

#include <stdio.h>
#include <malloc.h>

typedef struct _node
{
	int data;
	struct _node *next;
} node;

node *create();			//建立带头结点的链表
int len(node *head);	//求带头结点的链表元素个数

int main(void)
{
	int lenth;
	node *head;

	head = create();
	lenth = len(head);

	printf("Output: %d\n", lenth);
	return 0;
}

node *create()
{
	int n, i;
	node *head, *p, *q;

	head = (node*)malloc(sizeof(node));
	head->next = NULL;
	q = head;

	i = 0;
	printf("Input: ");
	scanf("%d", &n);
	while (n != 0)
	{
		p = (node*)malloc(sizeof(node));
		p->data = n;
		if (i % 2)
		{
			p->next = head->next;
			head->next = p;
		}
		else
		{
			p->next = q->next;
			q->next = p;
			q = q->next;
		}
		i++;
		scanf("%d", &n);
	}
	return head;
}

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

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

使用尾插法创建带头结点的单链表，数据域为整型，在创建时输入的数据为-1时表示结束创建（-1不保存在链表里）。

图中第二行为键盘输入。

分数:

请勿频繁操作

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

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

void output(Link head);
void destroy(Link head);
int create(Link head);

int main(void)
{
	Link head = NULL;

	head = (pNode)malloc(sizeof(Node));		//头结点
	if (head == NULL)
	{
		return 0;
	}
	head->next = NULL;
	
	printf("Input data:\n");
	create(head);
	output(head);
	destroy(head);

	return 0;
}

void output(Link head)
{
	pNode p = NULL;

	printf("Output:\n");
	if (head == NULL)
	{
		return ;
	}
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p = NULL;

	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;
} Node, *pNode, *Link;

void output(Link head);
void destroy(Link head);
int create(Link head);

int main(void)
{
	Link head = NULL;

	head = (pNode)malloc(sizeof(Node));		//头结点
	if (head == NULL)
	{
		return 0;
	}
	head->next = NULL;
	
	printf("Input data:\n");
	create(head);
	output(head);
	destroy(head);

	return 0;
}

void output(Link head)
{
	pNode p = NULL;

	printf("Output:\n");
	if (head == NULL)
	{
		return ;
	}
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p = NULL;

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

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

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

使用头插法创建带头结点的单链表，数据域为字符型，在创建时遇回车结束，使用形参回传链表头指针。

图中第二行为键盘输入。

分数:

请勿频繁操作

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

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

void output(Link head);
void destroy(Link head);
int create(Link *head);

int main(void)
{
	Link head;

	printf("Input string:\n");
	create(&head);
	output(head);
	destroy(head);

	return 0;
}

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

void destroy(Link head)
{
	pNode p;
	if (head == NULL)
	{
		return ;
	}
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

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

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

void output(Link head);
void destroy(Link head);
int create(Link *head);

int main(void)
{
	Link head;

	printf("Input string:\n");
	create(&head);
	output(head);
	destroy(head);

	return 0;
}

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

void destroy(Link head)
{
	pNode p;
	if (head == NULL)
	{
		return ;
	}
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

将两个带头结点的单链表进行合并。将L2的第i个元素放置在L1的第i个元素后面（如果L1或L2有多余元素，放在最后面）。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void merge(pLink head1, pLink head2);
void Destroy(pLink head);

int main(void)
{
	pLink l1, l2;

	printf("Input L1(0 for end):");
	if (CreateLink(&l1) < 0)
	{
		return 0;
	}
	printf("L1:");
	output(l1);
	printf("Input L2(0 for end):");
	if (CreateLink(&l2) < 0)
	{
		return 0;
	}
	printf("L2:");
	output(l2);
	merge(l1, l2);
	printf("output:\nmerged:");
	output(l1);
	Destroy(l1);
	Destroy(l2);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

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

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void merge(pLink head1, pLink head2);
void Destroy(pLink head);

int main(void)
{
	pLink l1, l2;

	printf("Input L1(0 for end):");
	if (CreateLink(&l1) < 0)
	{
		return 0;
	}
	printf("L1:");
	output(l1);
	printf("Input L2(0 for end):");
	if (CreateLink(&l2) < 0)
	{
		return 0;
	}
	printf("L2:");
	output(l2);
	merge(l1, l2);
	printf("output:\nmerged:");
	output(l1);
	Destroy(l1);
	Destroy(l2);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

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

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

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

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

将带头结点的单链表中字符串dest替换为source。

分数:

请勿频繁操作

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

#define LEN 20
typedef struct _Link
{
	char data[LEN];
	struct _Link *next;
} Link, *pLink;

void Destroy(pLink L);
int create(pLink *L);
void output(pLink L);
void replace(pLink L, char dest[], char source[]);
void input(char temp[]);

int main(void)
{
	char dest[20], source[20];
	pLink L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始链表为:\n");
	output(L);
	printf("输入需要被替换的字符串(dest):");
	input(dest);
	printf("输入需要替换的字符串(source):");
	input(source);
	replace(L, dest, source);
	printf("output:\n");
	output(L);
	Destroy(L);
	return 0;
}

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

int create(pLink *L)
{
	char temp[20];
	pLink p, q;

	p = *L = (pLink)malloc(sizeof(Link));
	if (*L == NULL)
	{
		return -1;
	}
	p->next = NULL;

	printf("输入创建链表的字符串(\"0\"表示结束):\n");
	input(temp);
	while (strcmp(temp, "0") != 0)
	{
		q = (pLink)malloc(sizeof(Link));
		if (q == NULL)
		{
			return -1;
		}
		strncpy(q->data, temp, LEN);
		q->next = p->next;
		p->next = q;
		p = q;
		input(temp);
	}
	return 1;
}

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

void input(char temp[])
{
	int flag = 0;
	int length = 0;

	fgets(temp, LEN, stdin);
	length = strlen(temp);
	if (temp[length - 1] == '\n')
	{
		temp[length - 1] = '\0';
		flag = 1;
	}

	if (flag == 0)
	{
		while (getchar() != '\n')
		{
			;
		}
	}
}

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

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

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

#define LEN 20
typedef struct _Link
{
	char data[LEN];
	struct _Link *next;
} Link, *pLink;

void Destroy(pLink L);
int create(pLink *L);
void output(pLink L);
void replace(pLink L, char dest[], char source[]);
void input(char temp[]);

int main(void)
{
	char dest[20], source[20];
	pLink L;

	if (create(&L) < 0)
	{
		return 0;
	}
	printf("原始链表为:\n");
	output(L);
	printf("输入需要被替换的字符串(dest):");
	input(dest);
	printf("输入需要替换的字符串(source):");
	input(source);
	replace(L, dest, source);
	printf("output:\n");
	output(L);
	Destroy(L);
	return 0;
}

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

int create(pLink *L)
{
	char temp[20];
	pLink p, q;

	p = *L = (pLink)malloc(sizeof(Link));
	if (*L == NULL)
	{
		return -1;
	}
	p->next = NULL;

	printf("输入创建链表的字符串(\"0\"表示结束):\n");
	input(temp);
	while (strcmp(temp, "0") != 0)
	{
		q = (pLink)malloc(sizeof(Link));
		if (q == NULL)
		{
			return -1;
		}
		strncpy(q->data, temp, LEN);
		q->next = p->next;
		p->next = q;
		p = q;
		input(temp);
	}
	return 1;
}

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

void input(char temp[])
{
	int flag = 0;
	int length = 0;

	fgets(temp, LEN, stdin);
	length = strlen(temp);
	if (temp[length - 1] == '\n')
	{
		temp[length - 1] = '\0';
		flag = 1;
	}

	if (flag == 0)
	{
		while (getchar() != '\n')
		{
			;
		}
	}
}

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

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

已有带头结点链表s和t，在s链表中找出最后一个在t链表中出现的元素。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

将L1、L2两个无头结点有序（升序）链表合并（每个链表中至少有1个元素），合并后的头指针为L1。创建链表为头插法，需要降序输入，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

Link create(void);
void output(Link head);
void destroy(Link head);
void merge(Link *h1, Link h2);

int main(void)
{
	Link L1 = NULL, L2 = NULL;

	printf("Input L1's data:\n");
	L1 = create();
	if (L1 == NULL)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);
	printf("Input L2's data:\n");
	L2 = create();
	if (L2 == NULL)
	{
		return 0;
	}
	printf("L2: ");
	output(L2);

	merge(&L1, L2);

	printf("Output:\n");
	output(L1);
	destroy(L1);
	return 0;
}

Link create(void)
{
	pNode p;
	Link head = NULL;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

	if (head == NULL)
	{
		return ;
	}
	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;
} Node, *pNode, *Link;

Link create(void);
void output(Link head);
void destroy(Link head);
void merge(Link *h1, Link h2);

int main(void)
{
	Link L1 = NULL, L2 = NULL;

	printf("Input L1's data:\n");
	L1 = create();
	if (L1 == NULL)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);
	printf("Input L2's data:\n");
	L2 = create();
	if (L2 == NULL)
	{
		return 0;
	}
	printf("L2: ");
	output(L2);

	merge(&L1, L2);

	printf("Output:\n");
	output(L1);
	destroy(L1);
	return 0;
}

Link create(void)
{
	pNode p;
	Link head = NULL;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

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

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

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

使用循环链表实现约瑟夫环的操作；输入总人数n，每计数到m时该人出列，得到最后一个出列人的号数，请在/******start******/和/******end******/注释之间添加操作代码，实现该操作。输入输出格式如图：第一行为用户输入总人数，"input the count":为固定输入，第二行输入每次出列的计数值m（3表示每数到3的人出列），input key为固定输入；第三行为输出，表示最后一个留下的人的号数，“output:the last one is”为固定输出。

分数:

请勿频繁操作

# include<stdio.h>
# include<stdlib.h>
struct list
{
	int data;
	struct list *next;
};
struct list *create(void)
{int i,n;
struct list *s,*h,*r;
printf("input the count:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
s=(struct list *)malloc(sizeof(struct list));
	s->data=i;
	s->next=NULL;
	if(i==1){h=s;r=s;}
	else
	{r->next=s;
	r=s;
	}
	r->next=h;
}
return(h);
 }
void main()
{
	struct list *p,*q,*h;
	int i,m;
h=create();
	p=h;
printf("input key");
scanf("%d",&m);
/******start******/

/******end******/
	
}

# include<stdio.h>
# include<stdlib.h>
struct list
{
	int data;
	struct list *next;
};
struct list *create(void)
{int i,n;
struct list *s,*h,*r;
printf("input the count:");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
s=(struct list *)malloc(sizeof(struct list));
	s->data=i;
	s->next=NULL;
	if(i==1){h=s;r=s;}
	else
	{r->next=s;
	r=s;
	}
	r->next=h;
}
return(h);
 }
void main()
{
	struct list *p,*q,*h;
	int i,m;
h=create();
	p=h;
printf("input key");
scanf("%d",&m);
/******start******/

/******end******/
	
}

使用头插法创建不带头结点的单链表，其中创建的结点个数为n，返回值为链表头指针。

图中第一行的5，第二行的1 2 3 4 5是键盘输入的。

分数:

请勿频繁操作

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

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

Link create(int n);
void output(Link head);
void destroy(Link head);

int main(void)
{
	int n = 0;
	Link head = NULL;
	
	printf("Input n:");
	scanf("%d", &n);

	head = create(n);
	output(head);

	destroy(head);
	return 0;
}

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

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

void output(Link head)
{
	pNode p = head;

	printf("Output:\n");

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

void destroy(Link head)
{
	pNode p;

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

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

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

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

Link create(int n);
void output(Link head);
void destroy(Link head);

int main(void)
{
	int n = 0;
	Link head = NULL;
	
	printf("Input n:");
	scanf("%d", &n);

	head = create(n);
	output(head);

	destroy(head);
	return 0;
}

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

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

void output(Link head)
{
	pNode p = head;

	printf("Output:\n");

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

void destroy(Link head)
{
	pNode p;

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

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

已有带头结点链表s和t，在s链表中找出第一个不在t链表中的元素。创建链表为尾插法，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	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;
} Node, *pNode, *Link;

int create(Link *head);
void output(Link head);
int find(Link s, Link t, int *value);
void destroy(Link head);

int main(void)
{
	int flag = 0;
	int value = 0;
	Link s = NULL, t = NULL;

	printf("Input s:\n");
	flag = create(&s);
	if (flag <=0 )
	{
		return 0;
	}
	printf("s: ");
	output(s);

	printf("Input t:\n");
	flag = create(&t);
	if (flag <= 0)
	{
		destroy(s);
		return 0;
	}
	printf("t: ");
	output(t);


	flag = find(s, t, &value);

	printf("Output:\n");
	if (flag < 0)
	{
		printf("Not Find!\n");
	}
	else
	{
		printf("value=%d\n", value);
	}

	destroy(s);
	destroy(t);
	return 0;
}

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

	h = (pNode)malloc(sizeof(Node));		//头结点
	if (h == NULL)
	{
		return -1;
	}
	q = h;

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

void output(Link head)
{
	pNode p;

	if (head != NULL)
	{
		p = head->next;
	}
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

void destroy(Link head)
{
	pNode p;
	
	while (head != NULL)
	{
		p = head->next;
		free(head);
		head = p;
	}
}

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

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

已知两个带头结点有序（升序）链表L1、L2，在不修改两个链表状态下，将数据创建到带头结点链表L3中保持有序。创建链表为头插法，需要降序输入，0表示创建链表结束。

图中第2行、第5行为键盘输入。

分数:

请勿频繁操作

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

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

int create(Link head);
void output(Link head);
void destroy(Link head);
int merge(Link h1, Link h2, Link h3);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL, L3 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	L3 = (pNode)malloc(sizeof(Node));	//头结点
	if (L3 == NULL)
	{
		free(L3);
		return 0;
	}
	L3->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	printf("Input L2's data:\n");
	flag = create(L2);
	if (flag <= 0)
	{
		destroy(L1);
		return 0;
	}
	printf("L2: ");
	output(L2);

	flag = merge(L1, L2, L3);
	if (flag <= 0)
	{
		destroy(L1);
		destroy(L2);
		return 0;
	}

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	printf("L3: ");
	output(L3);
	destroy(L1);
	destroy(L2);
	destroy(L3);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

	if (head == NULL)
	{
		return ;
	}
	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;
} Node, *pNode, *Link;

int create(Link head);
void output(Link head);
void destroy(Link head);
int merge(Link h1, Link h2, Link h3);

int main(void)
{
	int flag = 0;
	Link L1 = NULL, L2 = NULL, L3 = NULL;

	L1 = (pNode)malloc(sizeof(Node));	//头结点
	if (L1 == NULL)
	{
		return 0;
	}
	L1->next = NULL;

	L2 = (pNode)malloc(sizeof(Node));	//头结点
	if (L2 == NULL)
	{
		free(L1);
		return 0;
	}
	L2->next = NULL;

	L3 = (pNode)malloc(sizeof(Node));	//头结点
	if (L3 == NULL)
	{
		free(L3);
		return 0;
	}
	L3->next = NULL;

	printf("Input L1's data:\n");
	flag = create(L1);
	if (flag <= 0)
	{
		return 0;
	}
	printf("L1: ");
	output(L1);

	printf("Input L2's data:\n");
	flag = create(L2);
	if (flag <= 0)
	{
		destroy(L1);
		return 0;
	}
	printf("L2: ");
	output(L2);

	flag = merge(L1, L2, L3);
	if (flag <= 0)
	{
		destroy(L1);
		destroy(L2);
		return 0;
	}

	printf("Output:\n");
	printf("L1: ");
	output(L1);
	printf("L2: ");
	output(L2);
	printf("L3: ");
	output(L3);
	destroy(L1);
	destroy(L2);
	destroy(L3);
	return 0;
}

int create(Link head)
{
	pNode p;
	int temp;

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

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

void destroy(Link head)
{
	pNode p;

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

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

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

将带头结点单链表结点反转。如：原始链表结点内容为1、3、5、2、4、6，反转后链表内容为6、4、2、5、3、1。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void reverse(pLink head);
void Destroy(pLink head);

int main(void)
{
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	reverse(head);
	printf("output:\nreverse:");
	output(head);
	Destroy(head);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入元素序列（尾插法）,0表示结束:\n");
	
	scanf("%d", &temp);
	while (temp != 0)
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
		scanf("%d", &temp);
	}
	return 1;
}

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void reverse(pLink head);
void Destroy(pLink head);

int main(void)
{
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	reverse(head);
	printf("output:\nreverse:");
	output(head);
	Destroy(head);
	return 0;
}

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

int CreateLink(pLink *head)
{
	int temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入元素序列（尾插法）,0表示结束:\n");
	
	scanf("%d", &temp);
	while (temp != 0)
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
		scanf("%d", &temp);
	}
	return 1;
}

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

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

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

统计带头结点单链表中大写字母字符、小写字母字符、数字字符、其它字符个数。

分数:

请勿频繁操作

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

typedef struct _Node
{
	char data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void LinkCount(pLink head, int *cnt);
void Destroy(pLink head);

int main(void)
{
	int cnt[4] = {0};	//0下标存大写字母个数，1存小写字母，2存数字字符，3存其它字符
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	LinkCount(head, cnt);
	printf("output:\n大写:%d,小写:%d,数字:%d,其它:%d\n", cnt[0], cnt[1], cnt[2], cnt[3]);
	Destroy(head);
	return 0;
}

void output(pLink head)
{
	if (head == NULL)
	{
		return ;
	}
	head = head->next;
	while(head != NULL)
	{
		printf("%c", head->data);
		head = head->next;
	}
	printf("\n");
}

int CreateLink(pLink *head)
{
	char temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入字符序列（尾插法）:\n");
	
	while ((temp = getchar()) != '\n')
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
	}
	return 1;
}

void Destroy(pLink head)
{
	pLink p;

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

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

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

typedef struct _Node
{
	char data;
	struct _Node *next;
} Node, *pLink;

int CreateLink(pLink *head);
void output(pLink head);
void LinkCount(pLink head, int *cnt);
void Destroy(pLink head);

int main(void)
{
	int cnt[4] = {0};	//0下标存大写字母个数，1存小写字母，2存数字字符，3存其它字符
	pLink head = NULL;

	if (CreateLink(&head) < 0)
	{
		return 0;
	}
	output(head);
	LinkCount(head, cnt);
	printf("output:\n大写:%d,小写:%d,数字:%d,其它:%d\n", cnt[0], cnt[1], cnt[2], cnt[3]);
	Destroy(head);
	return 0;
}

void output(pLink head)
{
	if (head == NULL)
	{
		return ;
	}
	head = head->next;
	while(head != NULL)
	{
		printf("%c", head->data);
		head = head->next;
	}
	printf("\n");
}

int CreateLink(pLink *head)
{
	char temp;
	pLink p;
	pLink s;

	(*head) = (pLink)malloc(sizeof(Node));
	if ((*head) == NULL)
	{
		return -1;
	}
	p = *head;
	p->next = NULL;

	printf("输入字符序列（尾插法）:\n");
	
	while ((temp = getchar()) != '\n')
	{
		s = (pLink)malloc(sizeof(Node));
		if (s == NULL)
		{
			return -1;
		}
		s->data = temp;
		s->next = p->next;
		p->next = s;
		p = s;
	}
	return 1;
}

void Destroy(pLink head)
{
	pLink p;

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

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

复制带头结点链表source给dest。

分数:

请勿频繁操作

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
int Create(pLink *head);
int copy(pLink source, pLink *dest);
void Destroy(pLink head);

int main(void)
{
	pLink head1 = NULL;
	pLink head2 = NULL;

	printf("创建源链表，0结束:\n");
	if (Create(&head1) < 0)
	{
		return 0;
	}
	printf("source:");
	output(head1);
	if (copy(head1, &head2) < 0)
	{
		return 0;
	}
	printf("output:\nsource:");
	output(head1);
	printf("copy:");
	output(head2);
	Destroy(head1);
	Destroy(head2);
	return 0;
}

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

int Create(pLink *head)
{
	int temp;
	pLink p, q;

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

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

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

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

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

typedef struct _Node
{
	int data;
	struct _Node *next;
} Node, *pLink;

void output(pLink head);
int Create(pLink *head);
int copy(pLink source, pLink *dest);
void Destroy(pLink head);

int main(void)
{
	pLink head1 = NULL;
	pLink head2 = NULL;

	printf("创建源链表，0结束:\n");
	if (Create(&head1) < 0)
	{
		return 0;
	}
	printf("source:");
	output(head1);
	if (copy(head1, &head2) < 0)
	{
		return 0;
	}
	printf("output:\nsource:");
	output(head1);
	printf("copy:");
	output(head2);
	Destroy(head1);
	Destroy(head2);
	return 0;
}

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

int Create(pLink *head)
{
	int temp;
	pLink p, q;

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

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

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

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