步骤

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;
        }
    }
}

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.单链表的概念 ：

单链表的存储结构为线性非连续型，相比于数组极大的减少了空间的利用率，通过指针指向下一个结点让链表最大的利用了空间
以下是链表的实现原理:


链表的每个结点都包含一个数据域和一个指针域

创建链表的步骤:

1.先创建出结构体变量
struct Node
{
  int data;   //数据域
  struct Node* next; //指针域
}；

2.创建表头
struct Node* creatList()
{ 
   //定义一个指针变量通过动态内存申请将指针变量变为结点 
  struct Node* headNode=(struct Node*)malloc(sizeof(struct Node));
  headNode=NULL;   //建立一个空表
  return headNode; 
}

3.创建结点
struct Node* creatNode(int data)
{  
  //为新结点动态内存申请空间
  struct Node* newNode=(struct Node*)malloc(sizeof(struct Node));
  newNode->data=data;   //将形参传递的数据传入新结点内
  newNode->next=NULL;   //将新结点的指针域为空
  return newNode;
}

4.打印链表

打印以headNode为头结点的链表
void printList(struct Node* headNode)
{ 
  //因为第一个结点内不存放数据,所以从第二个结点开始打印
  //定义一个新的指针变量指向第二个结点
  struct Node* pMove=headNode->next;
  while(pMove!=NULL)
  {
    printf("data=%d\n",pMove->data);
    pMove=pMove->next;
  }   
  printf("\n");
}

链表功能的实现
链表的创建操作已经完成了,现在我们来完善链表的功能

链表的功能包括了增,删, 查 ,改

1.插入结点(表头法)


void InsertNode(struct Node* headNode)
{ 
   //调用创建结点函数来创建新结点
  struct Node* newNode=creatNode(data);
  newNode->next=headNode->next;
  headNode->next=newNode;
}

通过图片不难看出头插法是如何实现的
2.插入结点(尾插法)


void InsertNode(struct Node* headNode)
{ 
  struct Node* newNode=creatNode(data);
  //定义一个临时变量指向表头
  struct Node* temp=headNode;
  if(headNode==NULL)   //如果头结点为空
  {  
    //如果headNode为空则将newNode设为第一个新结点
   headNode=newNode;
   newNode->=NULL;
  }
  else
  {  
     //最终让temp指向尾结点
    while(temp->next != NULL)
    {  
      temp=temp->next;
    }
    //将尾结点temp的next设为newNode,即将newNdoe设为尾结点
    temp->next=newNode;
  }
}

3.查找结点
void SeekNode(struct Node* headNode,int data)
{ 
  //创建一个指针变量指向第二个结点
  struct Node* pMove=headNode->next;
  if(pMove==NULL)
  {
    printf("数据为空,无法查找!\n");
  }
  while(pMove != NULL)
  {
     if(pMove->data == data)
     {
       printf("数据存在!\n");
       printf("data=%d\n",pMove->data);
     }
     pMove=pMove->data;
  }
     printf("\n");
}

4.指定位置删除结点
void DeletedNode(struct Node* headNode,int posData)
{
	struct Node* posNode = headNode->next;
	struct Node* posFrotNode = headNode;
	if (posNode == NULL)
	{
		printf("数据为空,无法删除!\n");
	}
	while (posNode->data != posData)
	{
		posFrotNode = posNode;   //将指定位置的前面到达指定位置
		posNode = posFrotNode->next;
		if (posNode == NULL)
		{
			printf("未找到指定位置,无法删除!\n");
		}
	}
	posFrotNode->next = posNode->next;
	free(posNode);
}

文章目录
一、链表是什么？
二、使用步骤
1.定义结构体类型
2.创建及输出动态单链表
1.尾插法无头单链表❤
2.尾插法有头单链表
3.头插法无头单链表
4.头插法有头单链表


一、链表是什么？
官方解释:

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
二、使用步骤
1.定义结构体类型
代码如下：
struct node
{
	int num;
	struct node* next;
};

2.创建及输出动态单链表
创建链表之前需要了解动态单链表的几种形式，有头或无头，尾插法还是头插法，通过多次创建链表，个人更喜欢使用尾插法来创建一个无头单链表。


有头和无头的区别就在于第一个节点是否有数据域。
头插法和尾插法也就顾名思义，头插法每次都是在头节点后插入一个节点，而尾插法则是在链表末尾插入一个节点。所以在顺序输出的情况下，头插法创建的单链表是逆序输出的，而尾插法就是顺序输出。
1.尾插法无头单链表❤
int main()
{
	struct node* p1, * p2, * head;
	head = NULL;
	p1 = p2 = (struct node*)malloc(LEN);
	if(p1==NULL) exit(1);
	scanf_s("%d", &p1->num);
	int count = 0;
	do
	{
		if (count == 0) head = p1;
		else p2->next = p1;
		p2 = p1;
		p1 = (struct node*)malloc(LEN);
		if(p1==NULL) exit(1);
		count++;
		scanf_s("%d", &p1->num);
	} while (p1->num != 0);
	p2->next = NULL;
	free(p1);
	struct node* p;
	p = head;
	while (p != NULL)
	{
		printf("%d ", p->num);
		p = p->next;
	}
	return 0;
}

2.尾插法有头单链表
int main()
{
	struct node* head, * p1, * p2;
	p1 = p2 = (struct node*)malloc(LEN);
	if(p1==NULL) exit(1);
	head = (struct node*)malloc(LEN);
	if(head==NULL) exit(1);
	scanf_s("%d", &p1->num);
	int count = 0;
	do
	{
		if (count == 0) head->next = p1;
		else p2->next = p1;
		p2 = p1;
		count++;
		p1 = (struct node*)malloc(LEN);
		if(p1==NULL) exit(1);
		scanf_s("%d", &p1->num);
	} while (p1->num != 0);
	p2->next = NULL;
	free(p1);
	struct node* p;
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->num);
		p = p->next;
	}
	return 0;
}

3.头插法无头单链表
int main()
{
	struct node* head, * p1;
	head = NULL;
	p1 = (struct node*)malloc(LEN);
	if(p1==NULL) exit(1);
	scanf_s("%d", &p1->num);
	while (p1->num != 0)
	{
		p1->next = head;
		head = p1;
		p1 = (struct node*)malloc(LEN);
		if(p1==NULL) exit(1);
		scanf_s("%d", &p1->num);
	}
	free(p1);
	struct node* p;
	p = head;
	while (p != NULL)
	{
		printf("%d ", p->num);
		p = p->next;
	}
	return 0;
}

4.头插法有头单链表
int main()
{
	struct node* head, * p1;
	head = (struct node*)malloc(LEN);
	if(head==NULL) exit(1);
	head->next = NULL;
	int date;
	scanf_s("%d", &date);
	while (date != 0)
	{
		p1 = (struct node*)malloc(LEN);
		if(p1==NULL) exit(1);
		p1->num = date;
		p1->next = head->next;
		head->next = p1;
		scanf_s("%d", &date);
	}
	struct node* p;
	p = head->next;
	while (p != NULL)
	{
		printf("%d ", p->num);
		p = p->next;
	}
	return 0;
}

以上链表输入时都已0为结束标志，当检测到输入的值为0时，链表创建完毕。

以上链表的创建都是根据自己的思想创建的，所以可能会出现错误，希望大佬们可以指点一二😊