自制非循环单链表 diy 过程

自制简易链表

1. 链表第一步，需要一个点，才能一个一个 "链"起来 。首先定义一个节点单元，使用 typedef 功能自定义一个节点单元类型

typedef struct Node{
	int data;
	struct Node * pNext;
} NODE, *PNODE;

• 自定义的结构体中，包含两个数据类型，其中 data 用来存储 int 数据，另一个指针类型 pNext 用来存储下一个节点的地址，所以其类型为 struct Node * ，将其定义为 NODE，其指针类型定义为 PNODE，方便之后的使用

2. 链表第二步，将结点"链"起来，定义一个函数，能够实现自动创建一个链表，并在最后返回这个链表的头结点，以便用户定位到整个链表

PNODE create_list(void);

int main(void)
{
	PNODE pHead = create_list();
}

PNODE create_list(void)
{
	int len, val;
	//首先申请头结点的内存空间
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	
	if ( pHead == NULL )
	{
		printf("动态内存申请失败，程序终止！\n");
		exit(-1);
	}

	//定义一个尾节点，此时还没有输入链表节点个数，将头结点当成尾节点，尾节点的指针部分不指向任何值，设为NULL
	PNODE pTail = pHead;
	pTail->pNext = NULL;

	//读取用户输入的链表节点个数
	printf("请输入链表节点的个数： ");
	scanf("%d", &len);
	
	for ( int i=0;i<len;i++ )
	{
		//为新的一个节点申请一块空间
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if ( pNew == NULL )
		{
			printf("动态内存申请失败，程序终止！\n");
			exit(-1);
		}
		//将用户输入的数据赋值到新的节点的data内
		printf("请输入第%d个值： ", i+1);
		scanf("%d", &val);
		pNew->data = val;

		//令当前的尾节点指向这个新的节点
		pTail->pNext = pNew;
		//将最新的这个节点赋值给尾节点变量，即新产生的节点设置为尾节点
		pNew->pNext = NULL;
		pTail = pNew;
		//一次 “链接” 过程就这样完成了
	}
	
	return pHead;
	//最后将头结点返回给用户进一步使用
}

3. 链表第三步，向用户展示数据，编写一个函数，输入头结点，就可以自动按照节点顺序返回各个数据，其中需要判断一下链表是否为空，毕竟链表空了就展示不了了

bool is_empty(PNODE pHead);
void traverse_list(PNODE pHead);

int main(void)
{
	PNODE pHead = create_list();
	traverse_list(pHead);
}

bool is_empty(PNODE pHead)
{
	if ( pHead->pNext == NULL )
	//链表空判断很简单，只要看头结点中的指针有没有指向有效数据即可
	{
		return true;
	}
	else
	{
		return false;
	}
}

void traverse_list(PNODE pHead)
{
	if ( is_empty(pHead) )
	//判断链表是否为空
	{
		printf("链表为空！！！\n");
	}
	else
	{
	//如果链表不为空，就遍历链表，直到走到尾节点，将头结点指针不停得指向下一个节点，并判断其中的指针是不是指向NULL，指向NULL就说明走到尾了
		while ( pHead->pNext != NULL )
		{
			printf("%d ", pHead->pNext->data);
			pHead = pHead->pNext;
		}
		printf("\n");
	}
	return;
}

4. 链表第四步，由于链表中没有记录长度的值，所以需要一个功能告诉用户当前链表的长度

int length_list(PNODE pHead);

int main(void)
{
	PNODE pHead = create_list();
	int len;
	traverse_list(pHead);
	len = length_list(pHead);
}

int length_list(PNODE pHead)
{
	int len = 0;
	while ( pHead->pNext != NULL )
	//要实现这个功能也不难，直接用链表遍历的方法就可以了，每次遍历都对长度加一
	{
		len++;
		pHead = pHead->pNext;
	}
	
	return len;
}

5. 链表第五步，整理链表，这个功能也很简单，使用一个简单的排序算法即可，注意链表的实际原理还是一个线性数据结构，所以使用与数组相同的排序算法即可，以下其实就是将数组排序那一套搬到链表里面了

void sort_list(PNODE pHead);

int main(void)
{
	PNODE pHead = create_list();
	int len;
	traverse_list(pHead);
	len = length_list(pHead);
	sort_list(pHead);
}

void sort_list(PNODE pHead)
{
	int i, j, t;
	int len=length_list(pHead);
	PNODE p, q;
	
	for ( i=0,p=pHead->pNext;i<len-1;i++,p=p->pNext )
	{
		for ( j=i+1,q=p->pNext;j<len;j++,q=q->pNext)
		{
			if ( p->data > q->data )
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}
	return;
}

6. 链表第六步，插入算法，需要实现在已经"链"成一串表的情况下，在其中一个连接处插入一个节点，或者在整个链表末端插入一个节点

• 结合图来理解：

  • 

  • 如图所示，目标是：将q节点插入到p节点之后

    1. 首先需要通过用户所给的 pos 参数来确定 p 节点的位置在何处，并利用头结点的位置一步一步定位到 p 节点
    2. 需要注意的是，p 节点可以是尾节点，尾节点之后仍然可以扩充节点
    3. 接下来需要进行插入算法，大体上分为两步：
       1. 将 p 节点内的指针指向 q 节点
       2. 将 q 节点内的指针赋值为 p->pNext

bool insert_list(PNODE pHead, int pos, int val);

int main(void)
{
	PNODE pHead = create_list();
	int len;
	traverse_list(pHead);
	len = length_list(pHead);
	sort_list(pHead);
	if ( insert_list(pHead, 6, 8) )
	{
		printf("插入成功！\n");
	}
	else
	{
		printf("当前位置无法插入！\n");
	}
}

bool insert_list(PNODE pHead, int pos, int val)
{
	int len = length_list(pHead);
	
	int i = 0;
	PNODE p = pHead;

	//需要注意以下两步即是定位 p 节点的过程，这个定位算法十分健壮；
	// 综合分析( i<pos-1 && p!=NULL )，这一判断条件实际上就是为了使得 p 顺利走到 pos-1 的位置，并且保证输入的 pos 在有效范围，当 i==pos-1 && p!=NULL时，退出循环的结果是：p 可顺利的走到 pos 的前一个位置，而只要当 p == NULL ，p的位置就不在有效范围了，代表此时p已经走到了尾节点的pNext处，是没有办法在此处插入数值的
	//而 ( i>pos-1 || p==NULL ) 实际上就是直接对  (i==pos-1 && p!=NULL) 取反的结果 (再排除(p<pos-1))
 	while ( i<pos-1 && p!=NULL )
	{
		p = p->pNext;
		i++;
	}
	if ( i>pos-1 || p==NULL )
	{
		return false;
	}
	
	PNODE q = (PNODE)malloc(sizeof(NODE));
	if ( q == NULL )
	{
		printf("动态内存申请失败，程序终止！\n");
		exit(-1);
	}
	q->data = val;
	q->pNext = p->pNext;
	p->pNext = q;
	
	return true;
}

7. 链表第七步，删除算法，这一步与插入算法类似，只是这时要注意所选的位置必须在链表有效长度之内了，不能大于链表的有效长度

• 结合图来理解：

  • 

  • 如图所示，目标是将p节点之后的那个节点删除

    1. 首先需要通过用户所给的 pos 参数来确定 p 节点的位置在何处，并利用头结点的位置一步一步定位到 p 节点
    2. 需要注意的是这时p不能是尾节点了，如果p是尾节点后面无值是无法删除的了
    3. 接下来就是个简单的删除算法：
       1. 定义一个 q = p->pNext;
       2. p->pNext = p->pNext->pNext; free(q);

bool delete_list(PNODE pHead, int pos, int *pVal);

int main(void)
{
	PNODE pHead = create_list();
	int len;
	traverse_list(pHead);
	len = length_list(pHead);
	sort_list(pHead);
	
	int d_val;
	if ( delete_list(pHead, 1, &d_val) )
	{
		printf("删除的数字是: %d\n", d_val);
	}
	else
	{
		printf("当前位置无法删除！\n");
	}
}

bool delete_list(PNODE pHead, int pos, int *pVal)
{
	int len = length_list(pHead);
	
	int i = 0;
	PNODE p = pHead;

	//需要注意此处与插入算法不同的原因是，这里要判断p->pNext != NULL，这样可以使得 p 不到达尾节点的目的 
	while ( i<pos-1 && p->pNext!=NULL )
	{
		p = p->pNext;
		i++;
	}
	
	if ( i>pos-1 || p->pNext==NULL )
	{
		return false;
	}
	
	PNODE q = p->pNext;
	*pVal = p->pNext->data;
	p->pNext = p->pNext->pNext;
	free(q);
	
	return true;
}

8. 到这里，一个简易的链表功能就定义完成了，比较值得注意的地方是：
   1. 链表的创建过程，如何将节点一个一个的"链"起来
   2. 链表的插入和删除算法，如何定位到 pos-1位置，如何实现健壮的算法？[逻辑取反]