【数据结构（Java）】链表
线性表
定义：可以在任意位置进行插入和删除操作的、由n个相同类型元素组成的线性结构；线性表每个元素的数据类型都是抽象元素的数据类型。
线性表可以用顺序存储结构和链式存储结构存储；用顺序存储结构实现的线性表称为顺序表，用链式存储结构实现的线性表称作链表。链表主要有单链表、双向链表和环形链表（双向循环链表）。
操作集合：
初始化ListInitiate(L)
求当前元素个数ListLength(L):返回L的元素个数；
插入/删除/取出元素ListInsert(L,i,x)/ListDelete(L,i,x)/ListGet（L，i，下）：插入或删除表中第i个元素
链表
节点：由一个元素域(data)及若干个指针域(next)组成的结构体
分为带头节点和不带头节点
单链表
定义：除first和last元素外，每个元素只有一个前驱元素和一个后继元素。
节点：一个元素域及一个或若干个指针域组成的结构体。
1)链表是以节点的方式来存储
2)每个节点包含data域：存放数据；next域：指向下一个节点.
3)链表的各个节点不一定是连续存储，而是通过next域的指向来连接的
4)链表分带头节点的链表和不带头节点的链表，根据实际的需求来确定(一般为带头节点)
public class SingleLinkedListDemo {
public static void main(String[] args) {
SingleLinkedList s = new SingleLinkedList();
HeroNode h1 = new HeroNode(1, "1", "01");
HeroNode h2 = new HeroNode(2, "2", "02");
HeroNode h3 = new HeroNode(3, "3", "03");
s.add(h1);
s.add(h2);
s.add(h3);
s.list();
s.del(2);
s.list();
HeroNode n1 = new HeroNode(1, "01", "001");
s.update(n1);
s.list();
System.out.println(s.getLength(s.getHead()));
HeroNode r = s.find(s.getHead(), 2);
System.out.println(r);
s.reverseList(s.getHead());
s.list();
}
}
//单链表类
class SingleLinkedList {
private HeroNode head = new HeroNode(0, "", "");
private HeroNode Head;
public HeroNode getHead() {
return head;
}
//增加节点
public void add(HeroNode heroNode) {
HeroNode temp = head;//定义一个temp指针指向链表的头节点
while (true) {
if (temp.next == null) {
break;//当指针temp的next指向null时说明到了链表的最后
}
temp = temp.next;//指向下一个节点
}
temp.next = heroNode;
}
//查看链表
public void list() {
if (head.next == null) {
System.out.println("空");//判断链表是否为空，头节点的next为空则为空链表
}
HeroNode temp = head.next;
while (true) {
if (temp == null) {
break;
}
System.out.println(temp);
temp = temp.next;
}
}
//删除节点
public void del(int no) {
HeroNode temp = head.next;
while (true) {
if (temp == null) {
break;
} else if (temp.next.no == no) {//
temp.next = temp.next.next;
System.out.println("删除成功");
break;
}
temp = temp.next;
}
}
//更改节点信息
public void update(HeroNode newHeroNode) {
HeroNode temp = head.next;
while (true) {
if (temp.next == null) {
break;
} else if (temp.no == newHeroNode.no) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
System.out.println("修改成功");
break;
} else System.out.printf("无该no");
temp = temp.next;
}
}
//获取链表长度
public int getLength(HeroNode head) {
if (head.next == null) {
return 0;
}
int length = 0;
while (head.next != null) {
length++;
head = head.next;
}
return length;
}
public void reverseList(HeroNode head){
if(head.next == null || head.next.next == null){
return;
}
HeroNode cur =head.next;
HeroNode next ;
HeroNode reverseHead = new HeroNode(0,"","");
while (cur != null){
next = cur;
reverseHead.next = next;
cur = cur.next;
}
head.next = reverseHead.next;
}
//查找指定序号节点
public HeroNode find(HeroNode h, int no) {
int l = getLength(head);
if (no <= 0 && no > l) {
return null;
}
HeroNode temp = head.next;
for (int i = 0; i < l-no; i++) {
temp = temp.next;
}
return temp;
}
}
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 String toString() {
return "HeroNode[no = " + no + ",name=" + name + ",nickname= " + nickname + "]";
//重写toString方法返回属性
}
}
双向链表
定义：每个节点除了后继指针外还有一个前驱指针域pre,指向前一个节点
实现思路：
1)遍历方和单链表一样，只是可以向前，也可以向后查找
2)添加（默认添加到双向链表的最后）
(1)先找到双向链表的最后这个节点
(2)temp.next =newHeroNode
(3)newHeroNode.pre =temp;
3)修改思路和原理的单向链表一样.
4)删除
(1)因为是双向链表，因此，我们可以实现自我删除某个节点
(2)直接找到要删除的这个节点，比如temp
(3)temp.pre.next =temp.next
(4)temp.next.pre=temp.pre;
package work1.sjjg.linkedlist;
public class DoubleLinkedList {
public static void main(String[] args) {
HeroNode2 heroNode2 = new HeroNode2(1, "01", "001");
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
HeroNode2 h1 = new HeroNode2(1, "1", "01");
HeroNode2 h2 = new HeroNode2(2, "2", "02");
HeroNode2 h3 = new HeroNode2(3, "3", "03");
doubleLinkedList.add(h1);
doubleLinkedList.add(h2);
doubleLinkedList.add(h3);
doubleLinkedList.list();
doubleLinkedList.del(2);
doubleLinkedList.list();
HeroNode n1 = new HeroNode(1, "01", "001");
doubleLinkedList.update(n1);
doubleLinkedList.list();
// System.out.println(doubleLinkedList.getLength(doubleLinkedList.getHead()));
}
private HeroNode2 head = new HeroNode2(0, "", "");
private HeroNode2 Head;
public HeroNode2 getHead() {
return head;
}
public void add(HeroNode2 heroNode) {
HeroNode2 temp = head;
while (true) {
if (temp.next == null) {
break;
}
temp = temp.next;
}
temp.next = heroNode;
heroNode.pre = temp;
}
public void list() {
if (head.next == null) {
System.out.println("空");
}
HeroNode2 temp = head.next;
while (true) {
if (temp == null) {
break;
}
System.out.println(temp);
temp = temp.next;
}
}
public void del(int no) {
HeroNode2 temp = head.next;
while (true) {
if (temp == null) {
break;
} else if (temp.no == no) {
temp.pre.next = temp.next;
temp.next.pre = temp.pre;
System.out.println("删除成功");
break;
}
temp = temp.next;
}
}
public void update(HeroNode newHeroNode) {
HeroNode2 temp = head.next;
while (true) {
if (temp.next == null) {
break;
} else if (temp.no == newHeroNode.no) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
System.out.println("修改成功");
break;
} else System.out.printf("无该no");
temp = temp.next;
}
}
public int getLength(HeroNode head) {
if (head.next == null) {
return 0;
}
int length = 0;
while (head.next != null) {
length++;
head = head.next;
}
return length;
}
}
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 String toString() {
return "HeroNode[no = " + no + ",name=" + name + ",nickname= " + nickname + "]";
}
}
环形链表
环形链表顾名思义就是各个节点相连成环
我们带入约瑟夫问题中去了解环形链表，约瑟夫问题：有n个小孩围坐成一圈，随机从一个小孩开始逆时针报数，当报到指定数x的小孩出圈，下一个小孩再从1开始报数，直到圈中小孩数小于x.
实现思路：
1.先创建第一个节点，让fist指向该节点，并形成环形
2.后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可
遍历环形链表
1.先让一个辅助指针（变量）curBoy,指向first节点
2.然后通过一个while循环遍历该环形链表即可curBoy.next==first结束
package work1.sjjg.linkedlist;
public class Josefu {
public static void main(String[] args) {
CircleLinkedList circleLinkedList = new CircleLinkedList();
circleLinkedList.add(125);
circleLinkedList.list();
circleLinkedList.countBoy(10,20,125);
}
}
class CircleLinkedList {
private Boy first = new Boy(1);
public void add(int n) {
if (n < 2) {
System.out.printf("n不正确");
return;
}
Boy cur = null;
;
for (int i = 1; i < n; i++) {
Boy boy = new Boy(i);
if (i == 1) {
first = boy;
first.setNext(first);
cur = first;
} else {
cur.setNext(boy);
boy.setNext(first);
cur = boy;
}
}
}
public void list() {
if (first == null) {
return;
}
Boy curboy = first;
while (true) {
System.out.println("no=" + curboy.getNext());
curboy = curboy.getNext();
if (curboy == first) {
break;
}
}
}
public void countBoy(int nums, int countNum, int startNo) {
if (first == null || nums < 1 || startNo > nums) {
System.out.println("输入有误");
}
Boy temp = first;
while (true){
if(temp.getNext() == first){
break;
}
for (int j = 0; j < startNo - 1; j++) {
first = first.getNext();
temp = temp.getNext();
}
}
while (true) {
if (temp == first) {
break;
}
for (int i = 0; i < countNum - 1; i++) {
first = first.getNext();
temp = temp.getNext();
}
System.out.println("no:" + first.getNo());
first = first.getNext();
temp.setNext(first);
}
}
}
class Boy {
private int no;
private Boy next;
public Boy(int no) {
this.no = no;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public Boy getNext() {
return next;
}
public void setNext(Boy next) {
this.next = next;
}
}
