【数据结构/Data Structure】链表（四）：打印链表

一、顺序打印

        1、迭代方法

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

        2、递归方法

void Print(struct Node* p) {
    if(p == NULL){            //递归结束的条件
        printf("\n");
        return;
    }
	printf("%d ", p->data);   
	Print(p->next);           //递归调用
}

         为了更好理解递归调用的过程，画图来理解这个过程。假设有这样一个链表，head是指向头节点的指针，链表有三个节点，假设地址依次是100 200 150。

        调用 Print(head) 时，内存，或者说栈中发生的情况如下图所示。假设我们是在main函数中调用了 Print(head) 。每个函数调用时，都会在栈中开辟一块内存，称作这个函数的栈帧（Stack Frame），函数内的局部变量以及引用的参数也存储在其中。

        在这里，我们通过递归调用，在main的栈帧上创建了四个函数栈帧，同时也打印出了我们需要的节点值。当最后函数传入 0 ，也即链表到底时，触发了递归的退出条件 p == NULL，函数执行结束后，对应的栈帧也自动销毁，内存由系统释放。

        于是，栈内通过递归调用的函数栈帧依次释放，回到 main() 函数，当然，如果 main() 函数也结束，整个程序也就结束，main() 函数的栈帧也会对应销毁。

二、逆序打印

        虽然我们这里使用的是单向链表，但是通过递归，我们能够十分轻松的实现链表的逆序打印。方法也十分简单，对比递归实现的顺序打印，我们将逆序打印中，printf() 的操作安排在递归调用之后。通过这样的处理，程序执行打印会在递归返回的过程中，这样也就轻松实现了逆序打印的操作。

void ReversePrint(struct Node* p) {
    if(p == NULL){            //递归结束的条件
        printf("\n");
        return;
    }
	Print(p->next);           //递归调用
	printf("%d ", p->data);   
}

三、完整代码

        1、代码

#include <stdio.h>
#include <stdlib.h>
struct Node {
	int data;
	struct Node* next;
};

struct Node* Insert(struct Node* head, int val, int pos) {
	if (pos < 1) return head;

	struct Node* temp1 = (struct Node*)malloc(sizeof(struct Node));
	temp1->data = val;
	temp1->next = head;

	if (pos == 1) {
		temp1->next = head;
		head = temp1;
		return head;
	}

	struct Node* temp2 = head;
	int currentPos = 1; // 用来追踪当前的位置  

	while (temp2->next != NULL && currentPos < pos - 1) { // 遍历到指定位置的前一个节点  
		temp2 = temp2->next;
		currentPos++;
	}
	if (currentPos == pos - 1) { // 如果能到达指定位置  
		temp1->next = temp2->next; // 新节点的next指向原位置节点的next  
		temp2->next = temp1; // 将新节点插入到链表中  
	}
	else {
		// 这里我们选择在链表末尾添加  
		temp2->next = temp1;
		temp1->next = NULL;
	}
	return head;
}

struct Node*  Delete(struct Node* head, int pos) {
	if(pos < 1)	return head;

	struct Node* temp1 = head;
	
	if (pos == 1) {
		head = head->next;
		free(temp1);
		return head;
	}


	int currentPos = 1; // 用来追踪当前的位置  

	while (temp1->next != NULL && currentPos < pos - 1) { // 遍历到指定位置的前一个节点  
		temp1 = temp1->next;
		currentPos++;
	}
	struct Node* temp2 = temp1->next;	//temp2保存将要删除的的节点
	if (currentPos == pos - 1) { // 如果能到达指定位置  
		if (temp2 != NULL)
			temp1->next = temp2->next;
		else
			temp1->next = NULL;
		free(temp2);
	}
	else {
		// 不能到达指定位置，不进行删除操作
		return head;
	}
	return head;
}

struct Node* Reverse(struct Node* head) {
	struct Node* current = head;
	struct Node* prev = NULL;
	struct Node* next;

	while (current != NULL)
	{
		next = current->next;
		current->next = prev;
		prev = current;
		current = next;
	}
	head = prev;
	return head;
}

//打印链表：递归实现
void Print(struct Node* p) {
	if (p == NULL) {            //递归结束的条件
		printf("\n");
		return;
	}
	printf("%d ", p->data);
	Print(p->next);           //递归调用
}

void ReversePrint(struct Node* p) {
	if (p == NULL) {            //递归结束的条件
		printf("\n");
		return;
	}
	ReversePrint(p->next);           //递归调用
	printf("%d ", p->data);
}

int main()
{
	struct Node* head = NULL;			//empty list
	head = Insert(head, 2, 1);			//List:2
	head = Insert(head, 3, 2);			//List:2 3
	head = Insert(head, 4, 2);			//List:2 4 3
	head = Insert(head, 5, 2);			//List:2 5 4 3

	Print(head);
	ReversePrint(head);

	return 0;
}

        2、结果