*创建单链表的方法* 
 头插法创建单链表 
 个人感觉尾插法更容易理解= =头插法看了好久才看懂（mock上的课不错，这里的代码就来自上面的老师的课件，大部分注释是我自己的理解）
 
#include <iostream>
using namespace std;
struct LNode{
    int data;//数据域
    LNode*next;//指针域
};//定义一个结点类型的结构体
typedef LNode* LinkList;//用typedef来给LNode的指针类型定义一个新的名字LinkList
void input(int *ep)//形参是和数据域类型相同的指针，用来指向结点的数据域
{cout<<"请输入要储存的整数：";
    cin>>*ep;}
void CreateListF(LinkList *L,int n,void(*input)(int *ep))//第一个形参是头结点的指针的指针，n是需要创建的结点的个数，函数的指针（这个我还不是很清楚）
{ LinkList s;//创建一个指向结点的指针
    *L=new LNode;//创建头结点
    (*L)->next=NULL;//让头结点中的指针域初始为空值
    for(;n>0;n--)//创建结点
    { s=new LNode; //创建一个新结点
        input(&s->data);//输入该结点数据域所要储存的数据
        s->next=(*L)->next;//（第一次循环）将空值给开始结点的指针域；（第二次循环）让第二个结点的数据域中储存开始结点的地址，也就是现在头节点的next和第二个结点的next都储存着开始结点的地址（都指向开始结点）；
        (*L)->next=s;//（第一次循环）让头结点的的指针域中存储开始结点的地址；（第二次循环）让头结点的next中储存第二个结点的地址；
    }

}

int main()
{ LinkList L;
    int n;
    cout<<"请输入要创建结点的个数:";
    cin>>n;
    CreateListF(&L,n,input);
    return 0;





}
 
 
尾插法创建单链表 
 这个比较容易理解qwq
 
#include <iostream>
using namespace std;
struct LNode{
    int data;
    LNode* next;
};
typedef LNode* LinkList;
void input(int *ep)
{cout<<"请输入链表中的内容:";
    cin>>*ep;
}
void CreateListR(LinkList *L,int n,void(*input)(int*))
{ LinkList p,s;//创建两个结点型的指针；其中s用来创建结点，p用来实现循环
    p=*L=new LNode;//让p和*L都指向头结点
    for(;n>0;n--)//创建n个结点
    {s=new LNode;//创建一个新的结点
        input(&s->data);//输入数据
        p->next=s;//（第一次循环）让头结点的next指向开始结点；（第二次循环）让开始结点的next指向第二个结点，也就是新建立的结点
        p=s;//（第一次循环）让p和s一样指向开始结点；（第二次循环）让p和s一样指向新建立的结点，实现循环；
    }
    p->next=NULL;//最后尾结点的指针域要为0；
}
int main()
{LinkList L;
    int n;
    cout<<"请输入要创建的结点的个数：";
    cin>>n;
    CreateListR(&L,n,input);
    return 0;
}

如果你掌握以下知识，可能会对理解此片文章有所帮助：
 
1.C语言的基本语法，及指针的简单使用
 
2.完全理解教程二的原理
 
写在前面的话：
 
接下来的教程可能会非常难以理解，因此我用了差不多整整一天时间来理解别人写的C语言循环创建单链表的原理。所以如果你一时读不懂，不要担心，你可以在纸上演算，慢慢体会，这需要一个过程。
 
然后此篇文章与其他单链表文章不同的是，省略了单链表的操作，专注于循环创建链表的工作。对于链表的基本操作，可能会在下篇文章叙述。
 
C语言语法不太熟练也没关系，我上一次用C是在一年前，也是写数据结构。语法都快忘光了，用到再查。
 
在上一个教程你已经学会了如何手动写代码使节点相连，但这种重复的工作何不交给计算机完成呢？
 
//分割线//
 
1.和之前一样，我们先声明一个节点单元，把main函数写上
 
#include<stdio.h>
#include<stdlib.h>

typedef struct node_s{
	int data;
	struct node_s *next;
}node;

int main()
{
	
	
} 

 
2.创建一个头节点，有了这个头节点，就可以“抓”住整个链表，以至于顺藤摸瓜控制整个单链表
 
#include<stdio.h>
#include<stdlib.h>

typedef struct node_s{
	int data;
	struct node_s *next;
}node;

int main()
{
	node* head;	//在语法上，这语句代表声明一个指向node结构体类型的指针head。在编程目的上，我们创造了一个head节点 
	
	head = (node*)malloc(sizeof(node));		//为head（头节点）节点分配内存地址 
	
} 
 
3.再创建一个节点，把它与头节点相连
 
	node *s_node; 						//创建一个节点 
		
	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
	
	head->next = s_node;			//先将头节点和第一个节点相连 
 
4.声明一个辅助指针f ，使它指向s_node
 
int main()
{
	node* head;	//在语法上，这语句代表声明一个指向node结构体类型的指针head。在编程目的上，我们创造了一个head节点 
	
	head = (node*)malloc(sizeof(node));		//为head（头节点）节点分配内存地址
	
	node *s_node; 						//创建一个节点 
		
	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
	
	head->next = s_node;			//先将头节点和第一个节点相连 
	
	node *f;		//声明一个辅助指针，接下来，它指向的地方可能随时发生变化 
	
	f = s_node;		//让它指向刚刚创建的s_node节点，保存着s_node地址,如果不这样做，在接下来的第二条语句，s_node将会被刷新
 
5.创建循环
 
int main()
{
	node* head;	
	
	head = (node*)malloc(sizeof(node));		
	
	node *s_node; 					
		
	s_node = (node*)malloc(sizeof(node));		
	
	head->next = s_node;			
	
	node *f;		
	
	f = s_node;		
	
	for(int i=0 ; i<(length-1) ; i++)	//0,1,2,3,4,5,6,7,8,9，循环创建length-1个子节点，length-1是因为已经有head节点了，没必要再创造10个节点。 
	{									//这里创造9个，加head一个，那就是10个了。 
		s_node = (node*)malloc(sizeof(node));		//分配内存单元，此时s_node指向的内存单元一直被刷新。 
		
		s_node->next = NULL; 	//初始化next的值而已，不然它会被填入奇奇怪怪的值。不用担心，NULL会被刷新，不会一直是NULL值。
								//写这条语句也是无奈之举，后面遍历链表时： 
								//		在while，next有值时，一直执行，为NULL值时，遍历结束。最后一个节点的NULL不会被刷新，所以到最后一个节点NULL判定生效
								//在其他教程里，先创建头、尾节点，在头节点后面插入节点，比如这样:
								//		{头节点}->{一直在此插入节点}->{node2}->{node3}->{node4}->{尾节点}
								//		这样可以直接把尾节点的next赋值为NULL。一些教程把这样的创建方法叫做头插法。
								//既然讲了头插法，那就讲一下尾插法：
								// 		{头节点}->{node2}->{node3}->{node4}->{一直在此插入节点}->{尾节点}
								//本教程不属于头插法，也不属于尾插法，属于“指针指示法”，这是我自己想的名字，不用太过纠结，它是这样插入的：
								// 		{头节点}->{node2}->{node3}->{node4}->{一直在此插入节点}
								//大部分教程都使用头插法和尾插法。目前提到的方式，效率、结果都一样，不必纠结。 
								//无论头插还是尾插，它们都要创建尾节点，它们使用尾节点的next作为临时存储新生成节点的容器。。。
								//如果你对上面这大段注释有疑惑，那就先忘掉它吧！
		f->next = s_node; 
		
		f = s_node;
		
	}
	
	至此，单链表已经创建完成，下面是赋值然后测试结果/ 
 
6.增加赋值与测试
 
int main()
{
	node* head;	//在语法上，这语句代表声明一个指向node结构体类型的指针head。在编程目的上，我们创造了一个head节点 
	
	head = (node*)malloc(sizeof(node));		//为head（头节点）节点分配内存地址
	
	node *s_node; 						//创建一个节点 
		
	s_node = (node*)malloc(sizeof(node));		//为节点分配地址 
	
	head->next = s_node;			//先将头节点和第一个节点相连 
	
	node *f;		//声明一个辅助指针，接下来，它指向的地方可能随时发生变化 
	
	f = s_node;		//让它指向刚刚创建的s_node节点，保存着s_node地址,如果不这样做，在接下来的第二条语句，s_node将会被刷新 
	
	for(int i=0 ; i<(length-1) ; i++)	//0,1,2,3,4,5,6,7,8,9，循环创建length-1个子节点，length-1是因为已经有head节点了，没必要再创造10个节点。 
	{									//这里创造9个，加head一个，那就是10个了。 
		s_node = (node*)malloc(sizeof(node));		//分配内存单元，此时s_node指向的内存单元一直被刷新。 
		
		s_node->next = NULL; 
		
		f->next = s_node; 
		
		f = s_node;
		
	}
	
	至此，单链表已经创建完成，下面是赋值然后测试结果/ 
	
	int j = 0;		//计数器 
	
	f = head;
	
	while(f->next != NULL)		//遍历赋值 
	{
		f->data = j;
		
		j++;
		
		f = f->next;
	}
	
	f = head;
	
	while(f->next != NULL)		//遍历输出值 
	{
		printf("--%d--",f->data);
		
		f = f->next;
	}
} 
 
7.打印输出结果：
 
 
单链表教程应该就到这里了，因为再写的话可以写单链表的操作，但又不是很有必要。因为单链表可以实现链栈，直接去了解链栈的操作就可以，比较节约学习时间。
 
超详细！创建链栈及其基本操作（C语言）
 
如果觉得教程对你有所帮助，可以点赞支持φ(゜▽゜*)♪，非常感谢！

1 简述
 
创建单链表有两种方式：头插法与尾插法
 
尾插法是在链表的结尾增加新的节点
 
头插法是插入头节点后面，剩余节点前面
 
2 尾插法
 
步骤
 
需要新建一个尾节点tail，(初始head=tail)
创建新的节点new，连接到尾节点，tail.next = new
尾节点后移，tail = new
Q：为什么要加新的节点？
 
A:因为head的节点不能动，增加新的节点让其移动，让其指向最后一个节点，便于连接tail.next=new
 
返回创建好的列表一般返回head，如果让head后移，那最后返回head的结果只有最后一个节点
 
 
3 头插法
 
步骤
 
new.next = head.next
head.next=new
 
这种做法实际上实现了逆序
 
假如节点为： 1 2 3
 
创建过程：
 
head -> 1
head ->2 ->1
head ->3 ->2 ->1
返回头节点的结果是3 ->2 ->1，原来是 1 2 3，实现了逆序
 
参考https://blog.csdn.net/joob000/article/details/81196165

步骤
 
1、尾部插入法创建链表
2、自定义上一个节点、当前节点、下一个节点，遍历反转链表，主要是把当前节点的下一个节点设置为当前节点的上一个节点；
 
public class ReverseLinkd {

    private static Node head;
    private static Node tail;

    public static void main(String[] args) {
        String[] dataArray = {"1", "2", "3", "4", "5", "6", "7"};
        for(int i = 0; i< dataArray.length; i++) {
            createLinked(dataArray[i]);
        }
        System.out.println("---------------原链表---------------");
        printAll(head);

        System.out.println("---------------反转后链表---------------");
        printAll(reverse(head));

    }
    //链表反转方法
    public static Node reverse(Node node) {
        if(node == null) {
            System.out.println("空链表");
            return null;
        } else if(node.next == null) {
            System.out.println("链表只有一个节点");
            return node;
        } else {
            Node pre = null;
            Node next = null;
            Node cur = node;
            while(cur != null) {
                //记录下一个要操作的节点
                next = cur.next;
                //当前节点的下一个节点为当前节点的上一个节点，实现反转
                cur.next = pre;
                //上一个节点和当前节点全部后移
                pre = cur;
                cur = next;
            }
            return pre;
        }
    }

    //创建一个单链表，尾部插入法
    public static void createLinked(String nodeData) {
        Node node = new Node(nodeData);
        if(head == null) {
            head = node;
            tail = head;
        } else {
            tail.next = node;
            tail = node;
        }
    }

    //打印链表
    public static void printAll(Node node) {
        if(node == null) {
            System.out.println("空链表");
        } else {
            while(node != null) {
                System.out.print(node.getData() + "-->");
                node = node.next;
            }
        }
        System.out.println();
    }


    //定义单链表
    static class Node{
        public String data;
        public Node next;

        public Node(String data) {
            this.data = data;
        }

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
}