在DFS函数中，用链表来保存路径用指针，二维指针，引用

首先本问题大概是指这样的一个场景，在进行DFS时，需要保存能够一次走完所有顶点的路径。在这里用链表存储。一个链表的结点就是一条路径，也就是说当DFS时若符合条件，就完成当前指针所指的结点的赋值，然后指向下一个结点。

首先用指针，这是不行的，因为C语言只是将实参传递给形参，形参只是单纯的复制了一份实参

void pointer_test(int* ptr)
{
	int a = 3;
	int* q = &a;
	printf("函数内\n");
	printf("新增一个指针q，里面的值为%p\n", q);
	ptr = q;
	printf("把q的值赋给ptr后，ptr的值%p\nptr指向的值为%d\n", ptr,*ptr);
	printf("函数退出\n");
}

//main函数
int a = 2;
int* ptr0 = &a;
printf("函数调用前ptr0的地址%p\n", ptr0);
pointer_test(ptr0);
printf("函数调用后ptr0的地址%p\n", ptr0);

当程序的逻辑是这样的时候
其中p是新增的一个结点，p中的路径和ptr中的一样

ptr->next = p;
ptr = p;

所以就有可能出现这种情况
设p1,p2,p3为分别调用dfs函数时的指针

原本的意思是在进行路径复制后再链表的尾部增加一个结点，指针指向这个尾结点

所以可以用二维指针

#include <iostream>
#include<stdio.h>
using namespace std;
int martrix[6][6] = { {0,1,0,0,0,0},{1,0,1,1,0,0},{0,1,0,1,0,0},{0,1,1,0,1,1},{0,0,0,1,0,1},{0,0,0,1,1,0} };
bool vis[10];
int road[6];
typedef struct pathnode
{
	int road[10];
}pathnode;
pathnode path[10];
int j = 0;
typedef struct roadnode
{
	int road[10];
	struct roadnode* next;
}roadnode, * ptrroadnode;
ptrroadnode ptr;

void dfs3(int start_num, int index)//此dfs方法输出所有能够走完所有顶点的路径.用链表保存路径且输出，链表指针传的就是指针，这样的话，指针的值不发生改变，
								   //函数中的ptr需要用全局变量，main函数中p指针就是头指针,需要路径的复制
{
	vis[start_num] = true;
	ptr->road[index] = start_num;
	if (index == 6 - 1)
	{
		ptrroadnode p;
		p = (ptrroadnode)malloc(1 * sizeof(roadnode));
		p->next = NULL;
		for (int i = 0; i < 6; i++)
		{
			p->road[i] = ptr->road[i];
		}
		//printf("改变前:ptr=%d\n", ptr);
		ptr->next = p;
		ptr = p;
		//printf("改变后：ptr=%d\n", ptr);

		return;
	}
	for (int i = 0; i < 6; i++)
	{
		if (martrix[start_num][i] != 0 && vis[i] == false)
		{
			dfs3(i, index + 1);
			vis[i] = false;
		}
	}
}

void dfs31(int start_num, int index, ptrroadnode* p)//此dfs方法输出所有能够走完所有顶点的路径.用链表保存路径且输出，链表指针传的就是指针，这样的话，指针的值不发生改变，
								                    //函数中的ptr需要用全局变量，main函数中p指针就是头指针,需要路径的复制
{
	printf("*p的内容为%p\n", (*p));
	vis[start_num] = true;
	(*p)->road[index] = start_num;
	if (index == 6 - 1)
	{
		//printf("1111\n");
		ptrroadnode q;
		q = (ptrroadnode)malloc(1 * sizeof(roadnode));
		q->next = NULL;
		for (int i = 0; i < 6; i++)
		{
			q->road[i] = (*p)->road[i];
			if (i > 0)
				printf("->");
			printf("%d", q->road[i]);
		}
		printf("\n");
		//printf("改变前:ptr=%d\n", ptr);
		//printf("q的内容%d\n", q);
		(*p)->next = q;
		*p = q;
		//printf("改变后：*q=%d\n", *p);

		return;
	}
	for (int i = 0; i < 6; i++)
	{
		if (martrix[start_num][i] != 0 && vis[i] == false)
		{
			dfs31(i, index + 1,p);
			vis[i] = false;
		}
	}
}

void pointer_test(int* ptr)
{
	int a = 3;
	int* q = &a;
	printf("函数内\n");
	printf("新增一个指针q，里面的值为%p\n", q);
	ptr = q;
	printf("把q的值赋给ptr后，ptr的值%p\nptr指向的值为%d\n", ptr,*ptr);
	printf("函数退出\n");
}
int main()
{
	
	ptrroadnode p = (ptrroadnode)malloc(1 * sizeof(roadnode));
	p->next = NULL;
	ptrroadnode* pp = &p;
	//printf("p的内容%d\n", p);
	ptrroadnode head = p;
	printf("调用函数前head的内容为%p\n", head);
	dfs31(0, 0, pp);
	printf("调用函数后head的内容为%p\n", head);

	
	
	while (head->next != NULL)
	{
		for (int i = 0; i < 6; i++)
		{
			if (i > 0)
				printf("->");
			printf("%d", head->road[i]);
		}
		head = head->next;
		printf("\n");
	}
	
	
	/*
	int a = 2;
	int* ptr0 = &a;
	printf("函数调用前ptr0的地址%p\n", ptr0);
	pointer_test(ptr0);
	printf("函数调用后ptr0的地址%p\n", ptr0);
	*/
	return 0;
}

用二维指针可以进行指针的改变

因为二维指针可以改变整个程序的p的指向，所以在需要有一个head指针指向头结点，才能遍历

对一维指针的引用和二维指针类似，同样可以改变p的指向，只不过在dfs31程序中不需要再加*符号，同样在主函数中需要有head