数据结构：单链表增删改查的思路和代码实现
链表是以节点的方式来存储的。
1.一个节点包含。 data域(用来存放数据)，next域:指向下一个节点(存储的是内存的地址)。
2.各个节点不一定是连续存放的
3.链表分带头结点的链表和没有头节点的链表。
import java.util.Stack;
public class MyLinkedList {
//定义一个头节点。不存放具体的数据。
private User head = new User(0, "");
public User getHead() {
return head;
}
//添加节点到单向链表。
/**
* 默认排序添加思路：
* 1.找到当前链表的最后节点。
* 2.将最后节点的next指向新的节点
*/
public void add(User user) {
//因为head节点不可以动，因此需要创建一个辅助节点
User temp = head;
//循环查找。找到链表的最后
while (true) {
//找到链表的最后
if (temp.next == null) {
break;
}
//如果没有找到最后，将temp后移
temp = temp.next;
}
//把新的节点指向链表最后
temp.next = user;
}
/**
* 按照ID排序添加思路：
* 1.通过遍历找到新添加的节点的位置,
* 2.把新的节点.next 指向 temp.next
* 3.把temp.next指向新的节点。
*/
public void addByOrder(User user) {
//因为头节点不能动。因此需要通过一个辅助指针来帮助查找添加的位置。
//我们找的temp应该是位于添加位置的前一个节点。否则无法插入。
User temp = head;
while (true) {
//如果为null说明已经到最后了。这时候直接插入就可以了。
if (temp.next == null) {
break;
}
//如果当前节点的下一个节点的ID比新节点的ID大，则表示找到(新节点在这两个中间插入。)
if (temp.next.id > user.id) {
break;
} else if (temp.next.id == user.id) {
//如果编号存在 直接返回。不做插入操作
System.out.printf("编号%d存在了。无法添加。", user.id);
return;
}
temp = temp.next;
}
//.把新的节点.next 指向 temp.next
user.next = temp.next;
//把temp.next指向新的节点。
temp.next = user;
}
/**
* 修改节点思路：
* 1.找到和新节点相同ID的节点。 temp.id == 新节点.id
* 2.更改姓名 temp.name = 新节点.name;
*/
//修改节点信息。根据人物ID修改人物名称。
public void update(User newUser) {
//判空
if (head.next == null) {
System.out.println("链表为空。无法修改");
return;
}
//找到需要修改的节点，根据人物ID
//因为头节点不能动。所以定义一个辅助节点
User temp = head.next;
while (true) {
if (temp == null) {
break;
}
//如果找到则直接修改名字
if (temp.id == newUser.id) {
temp.name = newUser.name;
return;
}
//temp后移实现遍历
temp = temp.next;
}
System.out.printf("没有找到ID为%d的节点，无法修改", newUser.id);
}
/**
* 删除节点思路：(根据人物ID来删除)
* 1.先找到和要删除节点相同ID的前一个节点 temp.
* 2.temp.next = temp.next.next (上一个节点直接指向当前节点的下一个节点。)
* 3.被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收。
*/
public void delete(int id) {
User temp = head;
boolean flag = false;
while (true) {
if (temp.next == null) {
break;
}
//找到了待删除节点的前一个节点temp。
if (temp.next.id == id) {
//待删除的上一个节点指向他的下一个节点(实现删除。)
temp.next = temp.next.next;
return;
}
//temp后移实现遍历
temp = temp.next;
}
System.out.printf("要删除的节点%d不存在", id);
}
/**
* 打印输出思路：
* 1.找到头节点的下一个节点。指向辅助节点temp
* 2.打印输出temp并将temp指向下一个节点。
* 3.循环第二步。
*/
//显示当前链表。
public void showList() {
//判断当前链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点不能动。因此需要一个辅助节点。
User temp = head.next;
while (true) {
//判断是否到最后
if (temp == null) {
break;
}
//输出节点信息
System.out.println(temp);
//temp后移实现遍历
temp = temp.next;
}
}
/**
* 面试题：获取单链表有效节点的个数（忽略头节点。）
*/
public static int getLength(User head) {
if (head.next == null) {
return 0;
}
int length = 0;
User temp = head.next;
while (temp != null) {
length++;
temp = temp.next;
}
return length;
}
/**
* 面试题：查找单链表中的倒数第N个节点
* 思路：
* 1.编写一个方法接受 单链表的head节点和index。
* index表示是倒数第index个节点
* 2.获取链表的长度length。
* 3.得到length后，从链表第一个开始遍历（lenth-index）个就是需要的节点。
* 4.如果找到返回该节点。找不到返回null
*/
public static User findLastIndexNode(User head, int index) {
//如果链表为空返回null
if (head.next == null) {
return null;
}
//获取链表的长度。调用上一个方法。
int length = getLength(head);
//遍历 length -index位置，就是倒数第index的节点。
if (index <= 0 || index > length) {
return null;
}
//定义给辅助变量，for循环定位到倒数的index
User temp = head.next;
for (int i = 0; i < length - index; i++) {
temp = temp.next;
}
return temp;
}
/**
* 面试题：实现单链表的翻转。
* 思路：
* 1.先定义一个节点 reverseHead = new User() reverseHead.next默认为null
* 2.从头到尾遍历原来的链表，每遍历一个节点，就将其next指向上一个节点(第一个会指向null)，
* 然后取出放入新节点的next。
* 3.完成遍历后。把原来链表的head.next指向新节点的next即可。
*/
public static void reversetList(User head) {
//如果当前链表为空，或者只有一个节点。则无需反转
if (head.next == null || head.next.next == null) {
return;
}
//定义一个辅助节点。
User temp = head.next;
//指向当前节点的下一个节点。
User next = null;
//创建一个新节点。(相当于一个容器 用来暂时存放未翻转完的链表。)
User reverseHead = new User(0, "");
//遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
while (temp != null) {
//先取出当前节点的下一个节点备用。否则设置next后会无法找到下一个节点。
next = temp.next;
//当前节点的next指向新节点(第一次会指向null)
temp.next = reverseHead.next;
//把翻转后的链表结构赋值给新节点
reverseHead.next = temp;
temp = next;
}
//最后完成翻转后。将链表的头节点指向新节点的next即可。
head.next = reverseHead.next;
}
/**
* 面试题：从尾到头打印单链表
* 思路：
* 1.方式1：将单链表进行反转操作，然后再遍历即可，这样做会破坏原来的单链表结构！不建议！！！
* 2.方式2：可以利用栈这个数据结构，将各个节点压如栈中。然后利用栈的先进后出的特点。实现逆序打印效果。
* 3.方式3：用递归打印。
*/
//利用栈来实现逆序打印。
public static void reversetPrint2(User head) {
Stack<User> stack = new Stack<>();
if (head.next==null){
return;
}
User temp = head.next;
while (temp!=null){
stack.add(temp);
temp = temp.next;
}
while (stack.size()>0){
System.out.println(stack.pop());
}
}
//利用递归来实现逆序打印。
public static void reversetPrint3(User head) {
if (head != null) {
reversetPrint3(head.next);
System.out.println(head);
}
}
/**
* 面试题：合并两个有序的单链表。合并之后链表依然有序。
*/
public static User mergeList(User user1,User user2){
if (user1==null)return user2;
if (user2==null)return user1;
User head = null;
if (user1.id<user2.id){
head =user1;
head.next = mergeList(user1.next,user2);
}else{
head =user2;
head.next = mergeList(user2.next,user1);
}
return head;
}
}
class User {
public int id;
public String name;
public User next;
public User(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
class TestList {
public static void main(String[] args) {
User user = new User(1, "张三");
User user1 = new User(2, "李四");
User user2 = new User(3, "王五");
User user3 = new User(4, "赵六");
MyLinkedList list2 = new MyLinkedList();
//倒序插入测试效果
list2.addByOrder(user3);
list2.addByOrder(user2);
list2.addByOrder(user1);
list2.addByOrder(user);
list2.addByOrder(user);
System.out.println("--------------");
list2.showList();
//修改节点的名字。
User newUser = new User(1, "一号人物");
list2.update(newUser);
System.out.println("修改后的链表。。。");
list2.showList();
//删除
// list2.delete(1);
// list2.delete(4);
System.out.println("删除后的链表。。。");
list2.showList();
//获取单链表的有效节点个数
System.out.println(MyLinkedList.getLength(list2.getHead()));
//获取倒数第1个节点
System.out.println(MyLinkedList.findLastIndexNode(list2.getHead(), 1));
//MyLinkedList.reversetList(list2.getHead());
//System.out.println("倒序后的列表~~");
//list2.showList();
System.out.println("栈打印");
MyLinkedList.reversetPrint2(list2.getHead());
System.out.println("递归打印");
MyLinkedList.reversetPrint3(list2.getHead().next);
User user10 = new User(1, "张一");
User user20 = new User(2, "李二");
User user30 = new User(3, "王三");
User user40 = new User(4, "赵四");
User user50 = new User(5, "孙五");
user10.next = user40;
user20.next = user30;
user30.next = user50;
MyLinkedList list = new MyLinkedList();
list.getHead().next = MyLinkedList.mergeList(user10,user20);
System.out.println("合并后的顺序");
list.showList();
}
}