单链表专题

1. 创建单链表(以下所写的均为带头结点的链表)

分以下几种情况

• 输入数据(输入-1结束输入)

struct Link
{
	int data;
	struct Link* next;
};

//创建链表
struct Node* creatLink()
{
	struct Node* p1, * p2, * head = NULL;
	p1 = p2 =(struct Node*)malloc(LEN);

	printf("(输入-1结束输入)请输入节点的数据值-->\n");
	scanf("%d", &p1->data);
	p1->next = NULL;

	while (-1 != p1->data)
	{
		if (head == NULL)
		{
			head = p1;
			p2 = p1;
		}
		else
		{
			p2->next = p1;
			p2 = p1;
		}

		p1 = (struct Node*)malloc(LEN);
		scanf("%d", &p1->data);
		p1->next = NULL;
	}
	p2->next = NULL;
	return head;
}

• 创建带n个结点的链表

struct Link
{
	int data;
	struct Link* next;
};


//创建链表
struct Link* cratDataLink(int n)
{
	struct Link* head, * p1, * p2;
	int i;

	if (0 == n)
	{
		return NULL;
	}
	head = p1 = p2 = (struct Link*)malloc(LEN);

	printf("\n请输入%d个整型数据：\n", n);
	for (i = 1; i <= n; i++)
	{
		scanf("%d", &p1->data);
		if (NULL == head)
		{
			head = p1;
		}
		else
		{
			p2->next = p1;
		}
		p2 = p1;
		p1 = (struct Link*)malloc(LEN);
	}
	p2->next = NULL;

	return head;
}

• 结束

2. 单链表的遍历输出

struct Link
{
	int data;
	struct Link* next;
};
//打印链表数据
void printDataLink(struct Link* head)
{
	while (head !=NULL)
	{
		printf("%d-->", head->data);
		head = head->next;
	}
	printf("NULL\n");
}

3. 单链表的数据排序(仅交换数据域)

struct Link
{
	int data;
	struct Link* next;
};

//对整型进行交换
void swapI(int* a, int* b)
{
	int temp = 0;

	temp = *a;
	*a = *b;
	*b = temp;
}

//对链表的数据项进行排序(升序)		这里只交换数据域，不交换数据节点
struct Node* sortLinkData(struct Node* head)
{

	if (head == NULL)
	{
		return NULL;
	}

	struct Node* p;
	p = head->next;

	/*定义一个尾指针，初值为空，以后为每次的最大值*/
	struct Node* end = NULL;

	while (end != head)
	{
		/*pre和pnext一前一后*/
		struct Node* pre = head;
		struct Node* pnext = p;

		while (pnext != end)
		{
			/*比较相邻节点的数据*/
			if (pre->data < pnext->data)
			{
				swapI(&pre->data, &pnext->data);	/*交换整型数据*/
			}

			/*pre与pnext同时向后移动一个节点*/
			pre = pre->next;
			pnext = pnext->next;
		}
		/*该次循环结束，找到的是该次循环中的最大值*/
		end = pre;
	}
	return head;
}

4. 单链表数据逆置

struct Link
{
	int data;
	struct Link* next;
};

//链表数据逆置
struct Link* reverseLink(struct Link* head)
{
	struct Link* h, * p1, * p2;
	int flag = 0;

	h = p1 = p2 = head;

	while (h != NULL)
	{
		if (flag == 0)
		{
			h = h->next;
			p1->next = NULL;
			flag++;
		}
		else if (flag == 1)
		{
			p2 = p1;
			p1 = h;
			h = h->next;
			p1->next = p2;

		}
	}

	return p1;
}

5. 删除单链表中值为奇数的节点

//删除data为奇数的结点
struct Link* delOddsNode(struct Link* head)
{
	struct Link* p1, * p2;

	if (head == NULL)
	{
		return head;
	}

	p1 = head->next;
	p2 = head;

	while (p1 != NULL)
	{
		if (p1->data % 2 != 0)
		{
			p2->next = p1->next;
			free(p1);
			p1 = p2->next;
		}
		/*如果节点是偶数，也需要进行指针的移动保存数据，
		注意在写的时候要考虑完全*/
		else   
		{
			p2 = p1;
			p1 = p1->next;
		}
	}

	//若是头结点为奇数
	if (head->data % 2 != 0)
	{
		p2 = head;
		head = head->next;	//重新选取新的头结点
		free(p2);
	}
	return head;
}

6. 求两个链表的交集

struct Student
{
	int number;
	float score;
	struct Student* next;
};

struct List
{
	//建立带头、尾指针的链表
	struct Student* head;		
	struct Student* tail;
};

//求两个链表的交集
struct List* commonPartList(struct List* listOne, struct List* listTwo)
{
	struct List* comList = creatList();
	struct Student* p1 = listOne->head->next;

	while (p1 != NULL)
	{
		struct Student* p2 = listTwo->head->next;

		while (p2 != NULL)
		{
			//比较学号与分数是否相等
			if (p1->number == p2->number && p1->score == p2->score)
			{
				insertData(comList, p1->number, p1->score);
				break;
			}
			p2 = p2->next;			//指针后移
		}
		p1 = p1->next;				//指针后移
	}
	return comList;
}