链表是有序的列表,链表是以节点的方式来存储,是链式存储 ;
每个节点包含 data 域, next 域:指向下一个节点.
链表的各个节点不一定是连续存储.
链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定
单链表
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 测试
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
// 按标号顺序加入
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
// 遍历
singleLinkedList.list();
System.out.println();
singleLinkedList.reverseNode(singleLinkedList.getHead());
singleLinkedList.list();
int length = singleLinkedList.getLength(singleLinkedList.getHead());
System.out.println( length);
HeroNode indexNode = singleLinkedList.findIndexNode(singleLinkedList.getHead(), 1);
System.out.println(indexNode);
reverseNode(singleLinkedList.getHead());
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.del(4);
// 遍历
singleLinkedList.list();
}
// 逆序输出单链表的所有节点
public static void reverseNode(HeroNode head){
if (head.next == null) {
return;
}
Stack<HeroNode> stack = new Stack<>();
HeroNode cur = head.next;
while (cur.next != null){
stack.push(cur);
cur = cur.next;
}
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
}
class SingleLinkedList{
// 初始化头结点
private HeroNode head = new HeroNode(0,"","");
//返回头节点
public HeroNode getHead() {
return head;
}
// 添加
public void add(HeroNode node){
// 辅助节点temp
HeroNode temp = head;
// 遍历链表,找到最后
while(true){
// 找到链表的最后
if(temp.next == null){
break;
}
// 如果没找到,将temp后移
temp = temp.next;
}
// 退出while循环时,temp指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = node;
}
// 顺序添加
public void addByOrder(HeroNode heroNode){
// 创建辅助指针
HeroNode temp = head;
boolean flag = false; // 标志添加的编号是否存在,默认为false
while (true){
// 表示temp已经在链表最后了
if(temp.next == null){
break;
}
if(temp.next.no > heroNode.no) { // 位置找到,就在temp后面
break;
}else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已经存在
flag = true;
break;
}
temp = temp.next; // 后移,遍历当前链表
}
// 判断flag的值
if(flag) {
System.out.printf("准备插入的编号%d 已经存在,不能添加",heroNode.no);
System.out.println();
}else {
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 更新
public void update(HeroNode newHeroNode){
// 判空
if (head.next == null){
System.out.println("链表为空。。");
return;
}
// 头结点不能动
HeroNode temp = head.next;
boolean flag = false;
while(true){
if (temp == null){
break;
}
if (temp.no == newHeroNode.no) {
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = newHeroNode.name;
temp.nickName = newHeroNode.nickName;
}else {
System.out.printf("没有找到编号为 %d 的节点\n",newHeroNode.no);
}
}
// 删除
public void del(int no) {
if (head.next == null) {
System.out.println("链表为空。。");
return;
}
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不存在\n",no);
}
}
// 显示链表【遍历】
public void list(){
// 判断是否为空
if(head.next == null){
System.out.println("链表为空");
return;
}
// 头结点不能动,创建一个辅助节点来遍历
HeroNode temp = head.next;
// 这里首先进行非空判断,对第一个节点来说其实是多余的,当头结点的下一个节点为空的时候,判空条件会直接执行
// 如果不为空的话,判空条件不会执行,第一轮循环也不会执行
// 这个if判断是为后面的条件在执行
// 但是只能放在这里
// 放在后面的话,会少输出一个节点的信息
while(true) {
// 判断是否到了最后
if(temp == null){
break;
}
// 输出节点信息
System.out.println(temp);
// 将next后移,不然是死循环
temp = temp.next;
}
}
// 显示链表长度,不包括头结点
public int getLength(HeroNode head) {
HeroNode temp = head;
if(temp.next == null) {
return 0;
}
int length = 0;
while(temp.next != null) {
length++;
temp = temp.next;
}
return length;
}
// 找到倒数第k个节点,倒数第k个和顺数第size() - index是同一个
public HeroNode findIndexNode(HeroNode head,int index){
if (head.next == null) {
return null;
}
int length = getLength(head);
if (index <= 0 || index > length) {
return null;
}
HeroNode temp = head.next;
for (int i = 0; i < length - index; i++){
temp = temp.next;
}
return temp;
}
// 链表反转
public void reverseNode(HeroNode head){
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指向已经接好的第一个节点
// 也就是将2号指向1号
cur.next = reverseHead.next;
// 将头结点指向2号
reverseHead.next = cur;
// 让cur后移
cur = next;
}
// 将头结点替换,实现单链表的反转
head.next = reverseHead.next;
}
}
// 节点数据,每一个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 +
'}';
}
}
双向链表
public class DoubleLinkedListDemo {
public static void main(String[] args) {
// 测试
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, "公孙胜", "入云龙");
doubleLinkedList.update(newHeroNode);
doubleLinkedList.list();
System.out.println();
doubleLinkedList.del(4);
doubleLinkedList.list();
}
}
class DoubleLinkedList{
// 初始化头结点
private HeroNode2 head = new HeroNode2(0,"","");
//返回头节点
public HeroNode2 getHead() {
return head;
}
public void add(HeroNode2 node){
// 辅助节点temp
HeroNode2 temp = head;
// 遍历链表,找到最后
while(true){
// 找到链表的最后
if(temp.next == null){
break;
}
// 如果没找到,将temp后移
temp = temp.next;
}
// 退出while循环时,temp指向了链表的最后
// 将最后这个节点的next指向新的节点
temp.next = node;
node.pre = temp;
}
// 修改双向列表节点的值
public void update(HeroNode2 newHeroNode){
// 判空
if (head.next == null){
System.out.println("链表为空。。");
return;
}
// 头结点不能动
HeroNode2 temp = head.next;
boolean flag = false;
while(true){
if (temp == null){
break;
}
if (temp.no == newHeroNode.no) {
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = newHeroNode.name;
temp.nickName = newHeroNode.nickName;
}else {
System.out.printf("没有找到编号为 %d 的节点\n",newHeroNode.no);
}
}
// 删除
public void del(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.printf("要删除的节点 %d不存在\n",no);
}
}
// 显示链表【遍历】
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);
// 将next后移,不然是死循环
temp = temp.next;
}
}
}
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;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName +
'}';
}
}
约瑟夫环
Josephu 问题为:设编号为 1,2,… n 的 n 个人围坐一圈,约定编号为 k(1<=k<=n)的人从 1 开始报数,数到 m 的那个人出列,它的下一位又从 1 开始报数,数到 m 的那个人又出列,依次类推,直到所有人出列为止,由此 产生一个出队编号的序列。
构建一个单向的环形链表思路
- 先创建第一个节点, 让 first 指向该节点,并形成环形
- 后面当我们每创建一个新的节点,就把该节点,加入到已有的环形链表中即可.
遍历环形链表
.先让一个辅助指针(变量) curBoy,指向first节点
然后通过一个while循环遍历 该环形链表即可 curBoy.next == first 结束
public class Josephu {
public static void main(String[] args) {
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.addBoy(5);
circleSingleLinkedList.showBoy();
circleSingleLinkedList.countBoy(1,2,5);
}
}
// 创建一个环形单项列表
class CircleSingleLinkedList{
// 创建一个first节点,当前没有编号
private Boy first = null;
// 添加小孩节点,构建成一个环形链表
public void addBoy(int nums) {
if(nums < 0) {
System.out.println("nums的值不正确");
return;
}
Boy curBoy = null; // 创建辅助指针
// 通过for循环创建环形链表
for (int i = 1; i <= nums ; i++) {
// 根据编号创建小孩节点
Boy boy = new Boy(i);
// 如果是第一个节点
if(i == 1){
first = boy;
first.setNext(first);// 构成环
curBoy = first; // 让curBoy指向第一个小孩
}else{
curBoy.setNext(boy); // 将最后一个节点指向新创建的节点
boy.setNext(first); // 将新的节点指向第一个节点
curBoy = boy; // 将辅助指针指向新的节点
}
}
}
public void showBoy(){
// 判断是否为空
if(first == null) {
System.out.println("空~~");
return;
}
Boy curBoy = first;
while (true) {
System.out.printf("小孩的编号 %d \n",curBoy.getNo());
if (curBoy.getNext() == first){ // 说明已经遍历完毕
break;
}
curBoy = curBoy.getNext(); // curBoy后移
}
}
public void countBoy(int startNo,int countNum,int nums) {
// 先对数据进行校验
if (first == null || startNo < 1 || startNo > nums) {
System.out.println("产生·参数输入有误,请重新输入");
return;
}
// 创建辅助指针,帮助完成小孩出圈
Boy helper = first;
// 将辅助指针指向环形变量的最后一个节点
while(true) {
if (helper.getNext() == first) {
break;
}
helper = helper.getNext();
}
// 小孩报数前,先将first和helper移动k-1次
// 因为first已经指向了第一个节点,所以移动k-1次的时候,
// 会将first直接指向准备出圈的那个元素,这是为第一步做准备
for (int j = 0;j < startNo - 1; j++) {
first = first.getNext();
helper = helper.getNext();
}
// 当小孩开始报数时,让first和helper指针同时移动 m-1 次,然后出圈
// 也就是数m下
// 这里是一个循环操作,直到圈里只有一个节点
while (true) {
if (helper == first) { // 说明圈里只有一个节点
break;
}
// 让first和helper指针同时移动countNum-1
for (int j = 0; j < countNum - 1; j++) {
first = first.getNext();
helper = helper.getNext();
}
// 这时first指向的节点,就是要出圈的小孩节点
System.out.printf("小孩 %d 出圈 \n",first.getNo());
// 然后将first指向的小孩节点出圈
first = first.getNext();
helper.setNext(first);
}
System.out.printf("最后留在圈中的小孩编号是%d \n",first.getNo());
}
}
class Boy{
private int no;
private Boy next;
public Boy (int no) {
this.no = no;
}
public int getNo() {
return no;
}
public Boy getNext() {
return next;
}
public void setNo(int no) {
this.no = no;
}
public void setNext(Boy next) {
this.next = next;
}
}