2、java数据结构和算法：单链表: 反转,逆序打印, 合并二个有序链表,获取倒数第n个节点, 链表的有序插入
什么也不说, 直接上代码:
功能点有:
1, 获取尾结点
2, 添加(添加节点到链表的最后面)
3, 添加(根据节点的no(排名)的大小, 有序添加)
4, 单向链表的 遍历
5, 链表的长度
6, 删除某一个节点
7, 更换指定位置的节点
8, 查询第n个节点
9, 查询倒数第n个节点
10, 链表反转, 使用递归实现
11, 逆序打印
12, 合并二个有序链表, 且结果仍然是有序的
//英雄节点
class HeroNodeLv{
public int no;//英雄排名
public String name;//名字
public String nickName;//花名
public HeroNodeLv next;//指向下一节点
public HeroNodeLv(int no, String name, String nickName) {
this.no = no;
this.name = name;
this.nickName = nickName;
}
@Override
public String toString() {
return "HeroNodeLv{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
//链表对象
class SingleLinkListLvcai {
//单链表是由节点组成, 节点由 数据+ next(指向下一节点)组成
// 定义一个头结点,为空
public HeroNodeLv head = new HeroNodeLv(0,"","");
public void setHead(HeroNodeLv head) {
this.head = head;
}
// 获取头结点
public HeroNodeLv getHeadNode(){return head;}
//1, 获取尾结点
public HeroNodeLv getLastNode(){
//head头结点不能动, 定义第三方对象来遍历
HeroNodeLv temp = head;
while(true){
if(temp.next == null){
//说明是尾结点
return temp;
}
temp = temp.next;
}
}
//2, 添加(添加节点到链表的最后面)
public void add(HeroNodeLv node){
//head头结点不能动, 定义第三方对象来遍历
HeroNodeLv temp = head;
while(true){
if(temp.next == null){
//说明是尾结点
break;
}
temp = temp.next;
}
//遍历完后,此时temp就是尾结点
temp.next = node;
}
//3, 添加(根据节点的no(排名)的大小, 有序添加)
public void addByHeroNo(HeroNodeLv node){
HeroNodeLv temp = head;
boolean flag = false; //该节点是否已存在标识, 默认false,不存在
while(true){
if (temp.next == null) {
//说明到尾节点
break;
}
if(temp.next.no > node.no){
//说明 node 是需要放在 temp的下一个节点
break;
}else if(temp.next.no == node.no){
flag = true;//该节点已存在
break;
}
temp = temp.next;
}
if(false){
System.out.println("该节点已存在");
}else{
//插在temp的后面, 这里先将node的next指定好,之后,再指定插入, 这二行代码顺序不能变,否则会出现死循环
node.next = temp.next;
temp.next = node;
}
}
//4, 单向链表的 遍历
public void show(){
if(head.next== null){
//空链表
System.out.println("空链表");
return;
}
HeroNodeLv temp = head;
while(true){
if(temp.next == null){
break;
}
System.out.println(temp);
temp = temp.next;
}
System.out.println(temp);
}
//5, 链表的长度
public int length(){
if(head.next == null){
return 0;//这里头节点 不计入长度
}
HeroNodeLv temp = head.next;//这里头节点 不计入长度
int count = 0;
while(temp!= null){
count++;
temp = temp.next;
}
return count;
}
//6, 删除某一个节点
public void delNode(int no){
HeroNodeLv temp = head;
boolean flag = false;//该链表是否存在这个节点,默认为false, 不存在
while(true){
if(temp.next == null){
break;//链表尾部
}
if(temp.next.no == no){
flag = true;
break;//删除此时的这个节点的下一节点
}
temp = temp.next;
}
//循环完后,,此时temp的 next就是要删除的节点
if(flag){
temp.next = temp.next.next;
}else {
System.out.println("链表中不存在这个节点");
}
}
//7, 更换指定位置的节点
public void updateNode(int no,HeroNodeLv node){
HeroNodeLv temp = head;
boolean flag = false;//该链表是否存在这个节点, 默认为false 不存在
while (true) {
if (temp.next == null) {
break;//链表尾部
}
if (temp.next.no == no) {
flag = true; //temp的next就是要替换的节点
break;
}
temp = temp.next;
}
if (flag) {
//更换
temp.next = node;//更换next.
node.next = temp.next.next;//指定node的next
}else{
System.out.println("不存在这个节点");
}
}
//8, 查询第n个节点
public HeroNodeLv getByNo(int no){
//获取链表长度
if(no == 0){
return getHeadNode();//头结点
}
if(no >length()){
System.out.println("超出链表的长度:"+length());
return null;
}
HeroNodeLv temp = head.next;
int count = 0;
while(temp != null){
count++;
if(count == no){
//这就是要找的节点
break;
}
temp = temp.next;
}
return temp;
}
//9, 查询倒数第n个节点
public HeroNodeLv getByBackwordNum(int no){
//思路: 查询倒数第n个节点, 就是查询正数第 length-n+1 个节点
//如果为0 或者超出链表长度, 返回null
if(no == 0 || no > length()){
System.out.println("不能为0,或者,超出链表长度:链表长度为"+length());
return null;
}
return getByNo(length() - no +1);
}
}
//10, 链表反转, 使用递归实现
public static void reverseList(HeroNodeLv node){
//思路: 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
if(node.next == null || node.next.next == null){
return ;//空链表,只有一个节点的链表
}
HeroNodeLv cur = node.next;//定义指针变量,便于遍历原来的链表
HeroNodeLv next = null;//next 指的是当前节点(cur)的下一个节点
HeroNodeLv reverseHead = new HeroNodeLv(0,"","");
while(cur!= null){
next = cur.next;//先保存当前节点的写一个节点
cur.next = reverseHead.next;//将cur的下一个节点 指向新链表的最前端
reverseHead.next = cur;//将cur连接到新的链表上
cur = next;//后移
}
//循环完之后,newNode就是一个反转的链表了,,此时将newNode链表的头节点 , 变为原来链表的头节点
node.next = reverseHead.next;
}
//11, 逆序打印
public static void reversePrint(HeroNodeLv node){
//思路: 将单链表遍历,一个个取出,放到栈中,然后栈遍历, 利用栈的特点:先进后出
if(node.next == null){
return;
}
HeroNodeLv cur = node.next;
Stack<HeroNodeLv> stack = new Stack<HeroNodeLv>();
while(cur != null){
stack.push(cur);
cur = cur.next;
}
//遍历stack
while(stack.size() > 0){
System.out.println(stack.pop());
}
}
//12, 合并二个有序链表, 且结果仍然是有序的, 此方法的入参节点,从第一个节点开始, 不带头节点
public static HeroNodeLv mergeLinkList(HeroNodeLv node1 ,HeroNodeLv node2){
if(node1 == null && node2 == null){
return null;
}
if(node1 == null){
return node2;
}
if (node2 == null) {
return node1;
}
HeroNodeLv head = null ;
if(node1.no > node2.no){
head = node2;
head.next = mergeLinkList(node1,node2.next);
}else if(node1.no < node2.no){
head = node1;
head.next = mergeLinkList(node1.next,node2);
}else{
//相等的情况
head = node1;
head.next = mergeLinkList(node1.next,node2.next);
}
return head;
}
测试结果:
合并链表:
public static void main(String[] args) {
HeroNodeLv node1 = new HeroNodeLv(1, "宋江", "及时雨");
HeroNodeLv node2 = new HeroNodeLv(2, "吴用", "神算子");
HeroNodeLv node3 = new HeroNodeLv(3, "卢俊义", "玉麒麟");
HeroNodeLv node4 = new HeroNodeLv(4, "武松", "打老虎");
HeroNodeLv node5 = new HeroNodeLv(5, "吕财", "打老虎");
HeroNodeLv node6 = new HeroNodeLv(6, "吴二娘", "打老虎");
HeroNodeLv node7 = new HeroNodeLv(7, "吴二娘", "打老虎");
HeroNodeLv node8 = new HeroNodeLv(8, "吴二娘", "打老虎");
HeroNodeLv node9 = new HeroNodeLv(9, "吴二娘", "打老虎");
HeroNodeLv node10 = new HeroNodeLv(10, "吴二娘", "打老虎");
SingleLinkListLvcai linkListLv = new SingleLinkListLvcai();
linkListLv.add(node1);
linkListLv.add(node7);
linkListLv.add(node8);
linkListLv.addByHeroNo(node3);//这里的添加,是有序添加
linkListLv.addByHeroNo(node9);
System.out.println("链表linkListLv:");
linkListLv.show();// 1-3-7-8-9
System.out.println("==============================================");
SingleLinkListLvcai linkListLv2 = new SingleLinkListLvcai();
linkListLv2.addByHeroNo(node7);
linkListLv2.addByHeroNo(node4);
linkListLv2.addByHeroNo(node2);
linkListLv2.addByHeroNo(node8);
linkListLv2.addByHeroNo(node6);
linkListLv2.addByHeroNo(node5);
System.out.println("链表linkListLv2:");
linkListLv2.show();//2-4-5-6-7-8
System.out.println("==============================================");
HeroNodeLv heroNodeLv = mergeLinkList(linkListLv.getHeadNode().next, linkListLv2.getHeadNode().next);
//合并后的链表没有头结点,所以需要加上头结点
HeroNodeLv newLinkList = new HeroNodeLv(0, "", "");
newLinkList.next= heroNodeLv;
linkListLv.setHead(newLinkList);
System.out.println("合并后的新链表为:newLinkList");
linkListLv.show();//1-2-3-4-5-6-7-8
}
合并二个有序链表结果:
链表反转结果:
链表反转打印的结果,不破坏原有链表结构:
获取链表倒数第n个节点:
其余的几个功能点可以自己测试......
