标签：反转链表 boolean ntc OLE 反向 方向 fir string 逻辑
链表是一个有序的列表,它分为单向链表,双向链表,单向环形链表
一.单向链表
链表在内存中的存储如下:
它有如下特性:
1.链表是以节点的方式,是链式存储
2.每个节点都包含data域,next域来指向下一个节点
3.每个链表在内存中的分布不一定是连续的
4.链表分为有头结点的链表和没有头结点的链表,根据实际的情况决定
链表的逻辑结构示意图
单链表可以用来存储数据,也可以对数据进行增删改查的操作
1.创建一个单链表
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; } public HeroNode() { } @Override public String toString() { return "HeroNode{" + "no=" + no + ", name=‘" + name + ‘\‘‘ + ", nickName=‘" + nickName + ‘\‘‘ + ‘}‘; } }
2.单链表的添加元素
public void add(HeroNode node){ /*添加操作*/ /*1.找到当前链表的最后一个节点*/ /*2.将最后这个节点的next指向这个新的节点*/ HeroNode temp = head; // 定义辅助指针来遍历链表 while (true){ if(temp.next == null){ // 找到链表的最后,退出循环 break; } temp = temp.next; // 如果没有找到最后,将链表后移 } // 当退出while循环时,temp就指向了链表的最后 // 将最后这个节点的next指向新的节点 temp.next = node; }
3.单链表按照顺序添加元素
public void addByOrder(HeroNode node){ /*按照顺序添加*/ /*因为是单链表,所以temp是要添加指针的前一个节点*/ boolean flag = false; // 表示英雄的编号是否存在,默认为false HeroNode temp = head; //辅助指针 while (true){ if (temp.next == null){ break; } if (temp.next.no > node.no){ // 位置已经找到,就在temp后面插入新节点 break; }else if (temp.no == node.no){ // 添加的新的节点已经存在 flag = true; break; } temp = temp.next; } if (flag){ System.out.printf("不能添加相同的英雄,%d",node.no); return; }else { // 将新元素插入到temp的后面 node.next = temp.next; temp.next = node; } }
4.修改元素
public void update(HeroNode newNode){ /*根据英雄的编号修改节点*/ HeroNode temp = head; boolean flag = false; // 是否找到 while (true){ if (temp.next == null){ break; } if (temp.no == newNode.no){ // 已经找到需要修改的节点 flag = true; break; } temp = temp.next; } if (flag){ temp.name = newNode.name; temp.nickName = newNode.nickName; }else { System.out.printf("没有找到编号为%d的节点",newNode.no); return; } }
5.删除元素
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.printf("没有找到编号为 %d的节点",no); return; } }
6.单链表元素显示
public void show(){ /*显示链表,直接遍历即可*/ HeroNode temp = head.next; while (true){ if (temp == null){ System.out.println("链表为空"); return; } System.out.println(temp); temp = temp.next; } }
7.单链表面试题
7.1 查看单链表中有效数据的个数
public int size(HeroNode head){ /*计算链表中有效数据的个数,不算头结点*/ if (head.next == null){ // 链表为空,返回0 return 0; } int length = 0; // 定义有效数据的个数 HeroNode temp = head.next; while (temp != null){ // 遍历,++,返回 length++; temp = temp.next; } return length; }
7.2 返回单链表中倒数第k个节点
public HeroNode printLastIndexNode(HeroNode head,int index){ /*打印倒数第k个节点*/ /*index表示倒数第几个节点*/ /*1.先获取链表的总的长度size*/ /*2.得到size后,从链表的第一个遍历到size-index个,返回该节点即可*/ if (head.next == null){ // 如果链表为空,返回null return null; } int size = size(head); if (index <= 0 || index > size){ // 数据校验,如果输入的index不合法,返回null return null; } HeroNode temp = head.next; for (int i = 0; i < size-index;i++){ // for循环定义倒数的节点个数,然后返回节点 temp = temp.next; } return temp; }
7.3 反转单链表
public void reverse(HeroNode head){ /*反转单链表*/ /*1.从头到尾遍历原先的链表,每遍历一次将其取出,放在新链表的最前端*/ /*2.原来链表的head.next 指向reserveHead.next即可*/ // 如果链表中没有元素,或者只有一个元素直接return if (head.next==null || head.next.next == null){ return; } HeroNode cur = head.next; // 定义辅助节点,遍历原链表 HeroNode next = null; // 定义当前节点的下一个节点 HeroNode reverseHead = new HeroNode(0,"",""); // 反转链表的头节点 while (cur != null){ next = cur.next; //保存当前节点的下一个节点 cur.next = reverseHead.next; // 将后面一个链表的元素挂到cur的前面 reverseHead.next = cur; // 将reserveHead的头连接到原来的链表上 cur = next; // cur下移 } head.next = reverseHead.next; }
7.4 反向打印输出单链表
public void reversePrint(HeroNode head){ /*反转打印单链表,不破坏原有的结构*/ /*使用栈这种数据结构就能简单的实现*/ if (head.next == null){ // 如果链表为空,直接return return; } HeroNode cur = head.next; // 创建一个栈,将元素压入到栈中 Stack<HeroNode> stack = new Stack<>(); while (cur!=null){ // 遍历链表,把所有的节点压进栈 stack.push(cur); cur = cur.next; } while (stack.size() > 0){ // 节点出栈 System.out.println(stack.pop()); } }
测试代码
public static void main(String[] args) { // 生成英雄的节点 HeroNode h1 = new HeroNode(1,"宋江","及时雨"); HeroNode h2 = new HeroNode(2,"卢俊义","玉麒麟"); HeroNode h3 = new HeroNode(3,"吴用","智多星"); HeroNode h4 = new HeroNode(4,"林冲","豹子头"); SingleLinkedList singleLinkedList = new SingleLinkedList(); // 添加 singleLinkedList.add(h1); singleLinkedList.add(h2); singleLinkedList.add(h3); singleLinkedList.add(h4); // 按照no添加 singleLinkedList.addByOrder(h1); singleLinkedList.addByOrder(h4); singleLinkedList.addByOrder(h2); singleLinkedList.addByOrder(h3); singleLinkedList.show(); //修改 HeroNode h5 = new HeroNode(2,"小卢卢","小麒麟"); singleLinkedList.update(h5); singleLinkedList.show(); //删除 singleLinkedList.delete(1); singleLinkedList.delete(4); singleLinkedList.show(); // 有效节点的个数 System.out.printf("一共有%d个有效节点",singleLinkedList.size(singleLinkedList.getHead())); // 倒数第k个节点 System.out.println("倒数第1个节点是: "+singleLinkedList.printLastIndexNode(singleLinkedList.getHead(),1)); // 反转单链表 singleLinkedList.reverse(singleLinkedList.getHead()); // 反转打印单链表 singleLinkedList.reversePrint(singleLinkedList.getHead()); }
二.单向环形链表(Josephu问题)
设编号为1,2,3,...n的人围坐一圈,约定编号为k的人从1开始报数,数到m的人出列,它的下一个又从1开始报数,数到m的人又出列,以此类推,直到所有的人都出列
为止.
示意图:
代码实现:
1.创建节点
class Child{ /*创建小孩节点*/ private int no; private Child next; public Child(int no) { this.no = no; } public Child() { } public int getNo() { return no; } public void setNo(int no) { this.no = no; } public Child getNext() { return next; } public void setNext(Child next) { this.next = next; } @Override public String toString() { return "Child{" + "no=" + no + ‘}‘; } }
2.操作节点
public void list(){ /*遍历环形链表*/ if (first == null){ //判断链表是否为空,如果为空直接return System.out.println("链表为空"); return; } Child cur = first; // 头节点不能使用,需要创建辅助节点 while (true){ System.out.println("当前小孩的编号"+cur.getNo()); if (cur.getNext() == first){ //如果已经到老了最后节点,则退出循环 break; } cur = cur.getNext(); // 节点下移 } }
public void addChildren(int nums){ /*添加节点*/ /*1.先创建第一个节点,然后让first指向该节点,构成环*/ /*2.每创建一个新的节点,将其加入到环中即可*/ if (nums < 1){ // 数据校验,不合法直接return System.out.println("添加的数要大于1"); return; } Child cur = null; // 使用辅助节点遍历 for (int i = 1; i <= nums; i++) { Child child = new Child(i); //根据编号创建小孩节点 if (i == 1){ // 如果是第一个小孩 first = new Child(1); first.setNext(first); // 构成环 cur = first; //让cur指向first }else { cur.setNext(child); // 将新的节点添加到环中 child.setNext(first); cur = child; // 让cur指向下一个节点 } } }
/** * * @param startNo 表示从第几个小孩开始数数 * @param countNum 表示数几下 * @param nums 表示最初有多少个小孩在圈中 如果 startNo = 1,countNum = 2,num = 5,最后的顺序是2->4->1->5->3 */ public void countChildren(int startNo,int countNum,int nums){ /*计算小孩出圈的队列*/ // 校验参数是否合法 if(startNo < 1 || nums < countNum || first == null){ System.out.println("输入的参数错误"); return; } //定义辅助节点 Child helper = first; while (true){ // 该节点需要指向当前链表的最后一个节点 if (helper.getNext() == first){ break; } helper = helper.getNext(); } //报数前,需要移动k-1次 for (int i = 0; i < startNo-1;i++){ first = first.getNext(); helper = helper.getNext(); } while (true){ if (helper == first){ // 只有一个节点 break; } // 当小孩报数时,辅助节点和first节点同时移动countNum-1次,然后出圈 for (int i = 0; i < countNum-1; i++) { first = first.getNext(); helper = helper.getNext(); } // 此时first就是要出圈的节点 System.out.println("小孩出圈的编号是"+first.getNo()); first = first.getNext(); helper.setNext(first); } System.out.println("最终留下的小孩的编号是"+first.getNo()); }
测试代码:
public static void main(String[] args) { CircleLinkedList circleLinkedList = new CircleLinkedList(); circleLinkedList.addChildren(5); circleLinkedList.list(); circleLinkedList.countChildren(1,2,5); }
三.双向链表
单向链表的缺点:
1.查找的方向只能是一个方向,双向链表可以向前或向后进行查找
2.单向链表不能自我删除,需要借助辅助节点,而双向链表可以自我删除
双向链表的操作(增删改查)
创建双向链表
class HeroNode2{ public int no; public String name; public String nickName; public HeroNode2 next; //指向后一个节点的指针 public HeroNode2 pre; // 指向前一个节点的指针 public HeroNode2(int no, String name, String nickName) { this.no = no; this.name = name; this.nickName = nickName; } public HeroNode2() { } @Override public String toString() { return "HeroNode2{" + "no=" + no + ", name=‘" + name + ‘\‘‘ + ", nickName=‘" + nickName + ‘\‘‘ + ‘}‘; } }
遍历双向链表(同单向链表一样)
public void list(){ if (head.next == null){ System.out.println("链表为空"); return; } HeroNode2 temp = head; // 定义头结点的辅助节点 while (true){ if (temp.next == null){ break; } temp = temp.next; System.out.println(temp); } }
新增节点
public void add(HeroNode2 node){ HeroNode2 temp = head; // 不停的遍历链表,找到链表的最后一个节点,退出 while (true){ if (temp.next == null){ break; } temp = temp.next; } // 当退出循环时,temp就指向了链表的最后 temp.next = node; // 将新的节点加入到temp后面 node.pre = temp; }
修改节点(同单向链表)
public void update(HeroNode2 node){ boolean flag = false; if (head.next == null){ System.out.println("链表为空,不能修改"); return; } HeroNode2 temp = head.next; while (true){ if (temp == null){ break; } if (temp.no == node.no){ flag=true; break; } temp = temp.next; } if (flag){ temp.name = node.name; temp.nickName = node.nickName; }else { System.out.println("没有找到要修改的节点"); return; } }
删除节点
public void delete(int no){ /*双向链表的删除可以直接找到要删除的节点,找到后,自我删除即可*/ if (head.next == null){ System.out.println("不能删除空链表"); return; } boolean flag = false; HeroNode2 temp = head.next; 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("没有找到待删除的节点"+no); return; } }
标签：反转链表 boolean ntc OLE 反向 方向 fir string 逻辑
原文地址：https://www.cnblogs.com/luhuajun/p/12235514.html
