最长用的有关链表的算法（超容易理解）

在我们学习数据结构的时候对链表都不陌生，链表是有序的，是一个是非重要的知识点，日常练习算法，去面试一些公司的时候我们都有可能会遇到有关链表的一些东西。

下面是有关链表的一些常见操作实现：

1. 添加节点
2. 展示链表
3. 删除节点
4. 修改节点
5. 计算链表的节点总数量
6. 计算链表的倒数第 index 个节点
7. 添加结点，根据编号排序进行书写

创建一个节点类

class HeroNode {
  public int no;
  public String name;
  public String nickName;
	
  public HeroNode(int no, String name, String nickName) {
    this.no = no;
    this.name = name;
    this.nickName = nickName;
  }

  @Override
  public String toString() {
    return "HeroNode{" +
            "no=" + no +
            ", name='" + name + '\'' +
            ", nickName='" + nickName + '\'' +
            '}';
  }
}

分析：我们先创建一个节点类之后，针对节点进行链表的操作

---

建立头指针

HeroNode head = new HeroNode(0, "", "");

1 添加节点到节点末尾

public void addNode(HeroNode node) {
	HeroNode temp = head;
	// 先将指向头的指针移动到最后一个
	while(temp.next != null) {
		temp = temp.next;
	}
	// 在链表的末尾添加数据
	temp.next = node;
}

/*
	测试
*/
public static void main(String[] args) {
	HeroNode hero1 = new HeroNode(1, "11", "11111");
	HeroNode hero2 = new HeroNode(2, "22", "22222");
	HeroNode hero3 = new HeroNode(3, "33", "33333");
	HeroNode hero4 = new HeroNode(4, "44", "44444");
	addNode(hero1);
	addNode(hero2);
	addNode(hero3);
	addNode(hero4);
	showLink();
}
	
/*
	结果：
	
	HeroNode{no=1, name='11', nickName='11111'}
	HeroNode{no=2, name='22', nickName='22222'}
	HeroNode{no=3, name='33', nickName='33333'}
	HeroNode{no=4, name='44', nickName='44444'}
*/

---

2 展示链表

public void showLink (){
	// 首先我们进行判断，如果链表为空的话，就返回链表为空
	if (head.next == null) {
		System.out.println("该链表为空链表");
	}
	HeroNode temp = head.next;
	while (temp != null) {
		System.out.println(temp);
		temp = temp.next;
	}
}

---

3 根据节点编号删除节点中的某一个节点

在删除的过程中，我们找到的并不是指针直接指向的哪个节点，而是要找到待删除节点的前一个节点，将前一个节点的 next 指向待删除节点的下一个，这样待删除的节点没有任何一个节点指向将会被删除。

public void deleteNode(int no) {
	HeroNode temp = head;
	boolean flag = false;
	while(temp.next != null) {
		if(temp.next.no == no) {
			flag = true;
			break;
		}
		temp = tmep.next;
	}
	if (flag) {
		temp.next = temp.next.next;
	} else {
		System.out.printf("没有找到编号为 %d 的节点", no);
	}
}

/*
	测试
*/
public static void main(String[] args) {
	deleteNode(1);
	showNode();
	deleteNode(4);
	System.out.println("========================");
	showNode();
}


/* 
	结果
	
	HeroNode{no=2, name='22', nickName='22222'}
	HeroNode{no=3, name='33', nickName='33333'}
	HeroNode{no=4, name='44', nickName='44444'}
	========================
	HeroNode{no=3, name='33', nickName='33333'}
	HeroNode{no=4, name='44', nickName='44444'}

*/

---

4 根据节点编号修改节点

public void updateNode(HeroNode node) {
	HeroNode temp = head;
	if(temp.next == null) {
		System.out.println("该链表为空链表, 不可以修改");
		return;
	}
	boolean flag = false;
	while (temp.next != null) {
		if(temp.next.no = node.no) {
			temp.next.name = node.name;
			tmep.next.nickName = node.nickName;
			flag = true;
			break;
		}
		temp = temp.next;
	}
	if (!flag) {
		System.out.printf("修改失败，编号为 %d 的节点不存在", node.no);
	}
}
/*
	测试
*/
public static void main(String[] args) {
	System.out.println("===========未修改=============");
	showNode();
	HeroNode hero5 = new HeroNode(4, "4  4", "4 44 4 ");
	updateNode(4);
	System.out.println("===========修改之后=============");
	showNode();
}


/* 
	结果
	
	===========未修改=============
	HeroNode{no=1, name='11', nickName='11111'}
	HeroNode{no=2, name='22', nickName='22222'}
	HeroNode{no=3, name='33', nickName='33333'}
	HeroNode{no=4, name='44', nickName='44444'}
	===========修改之后=============
	HeroNode{no=1, name='11', nickName='11111'}
	HeroNode{no=2, name='22', nickName='22222'}
	HeroNode{no=3, name='33', nickName='33333'}
	HeroNode{no=4, name='4  4', nickName='4 44 4 '}

*/

---

5 计算链表的节点总数量

public static int getLinkLength(){
	if (head.next == null){
		return 0;
	}
	HeroNode temp = head;
	int length = 0;
	while(temp != null){
		length++;
		temp = temp.next;
	}
	return length;
}

/*
	测试
*/
public static void main(String[] args) {
	System.out.println(getLinkLength());
}


/* 
	结果
	
	4

*/

---

6 计算链表的倒数第 index 个节点

在获取链表倒数第 index 节点的方法很多，这里我介绍2中

1. 计算总长度，用总长度减去 index 的方法，进而遍历链表
2. 使用双指针的方法

方法一代码实现

public HeroNode getLastIndex(HeroNode head, int index) {
	// 先获取链表的总长度，直接调用上面的方法
	int length = getLinkLength();
	if(index < 0 || index > length){
		retrun null;	
	}
	HeroNode temp = head;
	for(int i = 0; i < length - index; i++){
		temp = temp.next;	
	}
	return temp;
}

/*
	测试
*/
public static void main(String[] args) {
	HeroNode hero1 = new HeroNode(1, "11", "11111");
	System.out.println(getLastIndex(hero1, 2));
}


/* 
	结果
	
	HeroNode{no=3, name='33', nickName='33333'}
*/

方法二代码实现 —— 双指针

实现思路：

1. 使用一个 left 和 right ，最开始的时候两个都指向 头（head）
2. 先遍历 right 移动 index 的单位，保证 left 和 right 指针间隔始终保持 index 个单位
3. 遍历到最后时 left 指针所指向的就是要返回的

public HeroNode getLastIndex(HeroNode node, int index) {
	HeroNode head = new HeroNode(0, "", "");
	HeroNode left = node;
    HeroNode right = head;
    int length = getLength(node);
    if (index < 0 || index > length) {
      return null;
    }
    for (int i = 0; i < index; i++) {
      right = right.next;
    }
    while (right.next != null) {
      right = right.next;
      left = left.next;
    }
    return left;
}

/*
	测试
*/
public static void main(String[] args) {
	System.out.println(getLastIndex(hero1, 2));
}


/* 
	结果
	
	HeroNode{no=3, name='33', nickName='33333'}

*/

---

7 添加结点，根据编号排序进行书写

public void addByOrder(HeroNode node) {
	HeroNode temp = head;
	boolean flag = false;
	while(tmep.next != null) {
		if(temp.next.no > node.no){
			break;	
		} else if (temp.next.no == node.no) {
			flag = true;
			break;
		}
		temp = temp.next;
	}
	if(flag){
		System.out.printf("编号为 %d 的节点已经存在", node.no);
	} else {
		node.next = temp.next;
		temp.next = node;
	}
}

这几个方法是链表常见的，其中不是很全，像链表反转，合并链表还没有总结，自己学习完之后会持续更新本篇文章。链表是非常重要的一个知识点，希望热爱编程的可以将链表的基础学习学扎实，学精通。