尚硅谷java数据结构与算法 韩顺平 双向链表增删改查 完成作业按序增 以及递归方式有序单链表合并

day4学习

 

 

package LinkedList;

public class DoubleLinkedListDemo {

	public static void main(String[] args) {
		System.out.println("双向链表测试：");
		
		//测试节点
		HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
		HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
		HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
		HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
		
//		//创建一个双向链表
//		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//		doubleLinkedList.add(hero1);
//		doubleLinkedList.add(hero2);
//		doubleLinkedList.add(hero3);
//		doubleLinkedList.add(hero4);
//		
//		doubleLinkedList.list();
//		
//		System.out.println("------------------");
//		//修改
//		HeroNode2 newHeroNode = new HeroNode2(4, "ooo", "kkkk");
//		doubleLinkedList.updata(newHeroNode);
//		doubleLinkedList.list();
//		System.out.println("------------------");
//		
//		//删除
//		doubleLinkedList.delete(3);
//		doubleLinkedList.list();
//		System.out.println("------------------");
		
		System.out.println("测试按序添加节点");
		DoubleLinkedList doubleLinkedList2 = new DoubleLinkedList();
		doubleLinkedList2.addByOrder(hero4);
		doubleLinkedList2.addByOrder(hero2);
		doubleLinkedList2.addByOrder(hero3);
		doubleLinkedList2.addByOrder(hero1);
		doubleLinkedList2.list();
	}

}

//创建一个双向链表类
class DoubleLinkedList {
	// 先初始化一个头节点，头结点不要动，不存放具体数据
	private HeroNode2 head = new HeroNode2(0, "", "");

	// 返回头结点
	public HeroNode2 getHead() {
		return head;
	}

	public void setHead(HeroNode2 head) {
		this.head = head;
	}

	// 显示链表
	public void list() {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 因为头结点不能动，因此我们需要一个辅助变量来遍历
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			// 输出节点信息
			System.out.println(temp);
			// temp后移
			temp = temp.next;
		}
	}

	// 添加一个节点到双向链表最后
	public void add(HeroNode2 heroNode) {
		// 因为head节点不能动 因此我们需要一个辅助变量temp
		HeroNode2 temp = head;
		// 遍历链表找到最后
		while (true) {
			if (temp.next == null) {
				break;

			}
			temp = temp.next;// temp节点后移
		}
		// 当退出while循环时temp就指向了链表的最后
		// 将最后这个节点的next指向新的节点
		temp.next = heroNode;
		heroNode.pre = temp;
	}
	
	//按编号顺序添加
	public void addByOrder(HeroNode2 heroNode) {
		// 因为head节点不能动 因此我们需要一个辅助变量temp
		HeroNode2 temp = head;
		boolean flag = false;// 标志添加的编号是否存在 默认不存在
		// 遍历链表找到最后
		while (true) {
			if (temp.next == null) {// 说明已经到最后
				break;
			}
			if (heroNode.no < temp.next.no ) {// 位置找到就在temp前插入
				break;

			} else if (temp.no == heroNode.no) {
				flag = true;// 说明编号存在
				break;
			}
			temp = temp.next;// temp节点后移
			
		}
		// 判断flag值
		if (flag) {
			System.out.println("英雄已经存在");

		} else {
			heroNode.next = temp.next;
			if(temp.next != null) {
				temp.next.pre = heroNode;
				}
			temp.next = heroNode;
			heroNode.pre = temp;
			
			System.out.println("添加成功");
		}
	}
	// 修改一个节点的内容

	public void updata(HeroNode2 heroNode) {
		// 判断是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 找到需要修改的节点
		// 定义一个辅助变量
		HeroNode2 temp = head.next;
		boolean flag = false;// 表示是否找到节点
		while (true) {
			if (temp == null) {
				break;// 遍历完
			}
			if (temp.no == heroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;

		}
		// 根据flag判断是否找到
		if (flag) {
			temp.name = heroNode.name;
			temp.nickname = heroNode.nickname;
		} else {
			System.out.println("没找到");
		}
	}

	// 删除一个节点
	public void delete(int no) {
		if (head.next == null) {
			System.out.println("链表为空，无法删除");
			return;
		}
		HeroNode2 temp = head.next;
		boolean flag = false;// 标志是否找到待删除节点
		while (true) {
			if (temp == null) {// 已经到链表最后
				break;
			}
			if (temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.pre.next = temp.next;
			if (temp.next != null) {
				temp.next.pre = temp.pre;
			}

		} else {
			System.out.println("没有找到需要删除的节点");
		}
	}

}


//定义一个HeroNode，每个对象都是一个节点
class HeroNode2 {
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;// 指向下一个节点  默认为null
	public HeroNode2 pre;// 指向前一个节点

	public HeroNode2(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "HeroNode2 [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
	
	
}

单链表类和节点的定义：

class SingleLinkedList {
	
	public HeroNode getHead() {
		return head;
	}

	public void setHead(HeroNode head) {
		this.head = head;
	}
	// 先初始化一个头节点，头结点不要动，不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");

	// 添加节点到单向链表
	// 思路：当不考虑编号的顺序时，找到当前链表的最后节点，将最后节点的next指向新节点
	public void add(HeroNode heroNode) {
		// 因为head节点不能动 因此我们需要一个辅助变量temp
		HeroNode temp = head;
		// 遍历链表找到最后
		while (true) {
			if (temp.next == null) {
				break;

			}
			temp = temp.next;// temp节点后移
		}
		// 当退出while循环时temp就指向了链表的最后
		// 将最后这个节点的next指向新的节点
		temp.next = heroNode;
	}

	// 第二种方式添加英雄时按排名插入到指定位置
	// 如果添加的排名重复了则添加失败
	public void addByOrder(HeroNode heroNode) {
		// 因为head节点不能动 因此我们需要一个辅助变量temp
		HeroNode temp = head;
		boolean flag = false;// 标志添加的编号是否存在 默认不存在
		// 遍历链表找到最后
		while (true) {
			if (temp.next == null) {// 说明已经到最后
				break;
			}
			if (temp.next.no > heroNode.no) {// 位置找到就在temp前插入
				break;

			} else if (temp.next.no == heroNode.no) {
				flag = true;// 说明编号存在
				break;
			}
			temp = temp.next;// temp节点后移
		}
		// 判断flag值
		if (flag) {
			System.out.println("英雄已经存在");

		} else {
			heroNode.next = temp.next;
			temp.next = heroNode;
			System.out.println("添加成功");
		}
	}

	// 修改节点信息，根据no编号来修改 即no不能被修改
	public void updata(HeroNode heroNode) {
		// 判断是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 找到需要修改的节点
		// 定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;// 表示是否找到节点
		while (true) {
			if (temp == null) {
				break;// 遍历完
			}
			if (temp.no == heroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;

		}
		// 根据flag判断是否找到
		if (flag) {
			temp.name = heroNode.name;
			temp.nickname = heroNode.nickname;
		} else {
			System.out.println("没找到");
		}
	}

	public void delete(int no) {
		HeroNode temp = head;
		boolean flag = false;// 标志是否找到待删除节点的前一个节点
		while (true) {
			if (temp.next == null) {// 已经到链表最后
				break;
			}
			if (temp.next.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.next = temp.next.next;
		} else {
			System.out.println("没有找到需要删除的节点");
		}
	}

	// 查找是否存在某序号节点
	public void query(int no) {
		HeroNode temp = head;
		boolean flag = false;// 标志是否找到节点
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			System.out.println("找到的节点是" + temp);
		} else {
			System.out.println("未找到匹配的节点");
		}

	}

	// 显示链表
	public void list() {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 因为头结点不能动，因此我们需要一个辅助变量来遍历
		HeroNode temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			// 输出节点信息
			System.out.println(temp);
			// temp后移
			temp = temp.next;
		}
	}
	
	
	//合并两个有序链表方法
	public static HeroNode ListMerge(HeroNode n1,HeroNode n2) {
		 if(n1 == null) {
	            return n2;
	        }
	        if(n2 == null) {
	            return n1;
	        }
	     
	     if(n1.no < n2.no ) {
	    	 n1.next = ListMerge(n1.next, n2);
	    	 return n1;
	     }else {
	    	 n2.next = ListMerge(n1, n2.next);
	    	 return n2;
	     }
		
		
	}
      

	
}

//定义一个HeroNode，每个对象都是一个节点
class HeroNode {
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;// 指向下一个节点

	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 + "]";
	}

	// 为了显示方便重写toString方法

}

测试类：

package LinkedList;
//单向链表按序合并的测试类
public class LinkListMerge {

	public static void main(String[] args) {
		// 先创建节点
				HeroNode n1 = new HeroNode(1, "宋江", "及时雨");
				HeroNode n2 = new HeroNode(2, "卢俊义", "玉麒麟");
				HeroNode n3 = new HeroNode(3, "吴用", "智多星");
				HeroNode n4 = new HeroNode(4, "入云龙", "公孙胜");
				HeroNode n5 = new HeroNode(5, "大刀", "关胜");
				HeroNode n6 = new HeroNode(6, "林冲", "豹子头");
				HeroNode n7 = new HeroNode(7, "秦明", "霹雳火");
				HeroNode n8 = new HeroNode(8, "双鞭", "呼延灼");

				// 创建链表
				SingleLinkedList L1 = new SingleLinkedList();
				SingleLinkedList L2 = new SingleLinkedList();
				SingleLinkedList L3 = new SingleLinkedList();
				
				L1.addByOrder(n1);
				L1.addByOrder(n5);
				L1.addByOrder(n7);
				L2.addByOrder(n4);
				L2.addByOrder(n6);
				L2.addByOrder(n3);
				L2.addByOrder(n2);
				L2.addByOrder(n8);
				System.out.println("L1链表中的节点有：");
				L1.list();
				System.out.println("L2链表中的节点有：");
				L2.list();
				System.out.println("----------------------");
				L3.getHead().next = SingleLinkedList.ListMerge(L1.getHead().next,L2.getHead().next);
				L3.list();

	}

}