SWUSTOJ 960A题总结，又完成一个讨厌的题，内含链表操作启发

今天debug了一个nice代码，先码在这里，SWUST ＯJ960

双向链表的操作问题

1000(ms)

10000(kb)

2994 / 8244

建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。）

输入

第一行：双向表的长度；

第二行：链表中的数据元素。

输出

输出双向链表中的数据元素的值。

样例输入

10

2 4 6 3 5 8 10 21 12 9

样例输出

2 3 4 5 6 8 9 10 12 21

对于本题，

构建链表时在连接时需双向连接，且头指针的前指针为NULL,尾指针的后指针为NULL

解题思想：

1. 尾插法构建链表
2. 构建新链表为目标链表，将原链表上节点取出放在新链表合适位置
3. 新链表末尾置为NULL并输出
   
   **

所以这个题坑在哪里了？

1. 注释真的很重要！！！！！
2. 循环过程中忘记目标节点的移动
3. 为方便以后查看与思考，规定在对链表操作时，应声明一个新指等于为目标节点，之后通过该指针对目标节点操作，同时在赋值给辅助指针后，目标节点后移，防止链丢失。
4. 每次对末尾操作要注意尾部指向NULL

代码如下，编译环境VS

#include<stdio.h>
#include<stdlib.h>
struct link
{
	int data;
	struct link *next;
	struct link *last;
};
//先锁定目标位置，一次位移
struct link *ApendNode(struct link *head,int n);//构造链表
struct link *rankLink(struct link *head);//链表排序
void showLink(struct link *head);//输出链表

int main()
{
	struct link *head,*answer;
	int n;
	scanf_s("%d", &n);
	head = (struct link *)malloc(sizeof(link));
	head->last = NULL;
	head = ApendNode(head,n);
	answer = rankLink(head);
	showLink(answer);
	system("pause");
	return 0;
}
struct link *rankLink(struct link *old)//旧节点名字为old
{
	//新建一个链，读取原目标，插入新链
	//方法概述：新建链表，并插入前两个，这里需要比较，
	//         然后将剩余链表中节点循环比对，插入合适位置直到取出最后一个节点，即末指针为空
	struct link *head,*p,*pr,*p2,*tail;
	p2 = NULL;

	head = (link *)malloc(sizeof(link));//申请新头节点
	head->last = NULL;//头节点前指针为空

	link *help1,*help2;//辅助节点1，2帮助导入前2节点
	help1 = old->next;
	help2 = help1->next;

	p = help2->next;//p为待处理节点

	head->next = help1;//连接1个
	help1->last = head;

	//连接第二个节点，根据大小放置，pr指向第一个节点，tail为尾节点
	if (help1->data > help2->data)
	{
		head->next = help2;
		help2->last = head;
		help2->next = help1;
		help1->last = help2;
		help1->next = NULL;
		tail = help1;
		pr = help2;
	}
	else
	{
		//此时helpl链在结果链，断开链
		help2->next = NULL;
		tail = help2;
		pr = help1;
	}
	tail->next = NULL;
	//已连接2个

	free(old);//原链表头节点被搁置，处理

	//这之后开始对其余节点处理，pr为首节点（含数据），tail为尾节点（含数据）
	//p2为辅助节点
	while (p != NULL)
	{
		//为最小值
		if (p->data <= head->next->data)
		{
			link *help;//help存该插入节点，p改为下一节点
			help = p;
			p = p->next;
			help->next = head->next;
			head->next = help;
			help->last = head;
			help->next->last = help;
		}
		else
		{
			if (p->data > tail->data)//为最大值
			{
				p2 = p->next;
				tail->next = p;
				p->last = tail;
				p->next = NULL;
				tail = p;
				p = p2;
				tail->next = NULL;
			}
			else
			{
				//pr为首节点，重置pr；
				//满足插入条件两值中间
				while (pr!= tail)
				{
					if ((p->data) >= (pr->data))
					{
						if (p->data <= pr->next->data)
						{
							link *start, *end;//start为前节点，end为后节点
							p2 = p->next;
							start = pr;
							end = pr->next;
							start->next = p;
							p->last = start;
							p->next = end;
							end->last = p;//插入操作；
							p = p2;
							break;
						}
					}
					pr = pr->next;//pr读取下一数值
				}
				pr = head->next;//重置pr为首节点

			}
		}
	}
	tail->next = NULL;
	return head;
}
struct link *ApendNode(struct link *head, int n)
{
	link *p, *pr;
	pr = head;
	for (int i = 0; i < n; i++)
	{
		p = (link *)malloc(sizeof(link));
		pr->next = p;
		p->last = pr;
		pr = p;
		scanf_s("%d",& (p->data));
	}
	pr->next = NULL;
	return head;
}
void showLink(link * head)
{
	link *p;
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}