链表的特点：
1）链表是为节点的方式来存储；
2）每一个节点包含data域，next域：指向下一个节点；
3）链表的各个节点不一定是连续存放的
4）链表分带头节点和没有头节点的链表
单向链表
1）添加
2）按照编号节点添加
3）删除节点
代码实现
package 数据结构.链表;
public class SingleLinkedListDemo{
public static void main(String[] args) {
//测试
//创建节点
HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");
//创建一个连包括
SingleLinkedList singleLinkedList = new SingleLinkedList();
/*singleLinkedList.add(heroNode1);
singleLinkedList.add(heroNode2);
singleLinkedList.add(heroNode3);
singleLinkedList.add(heroNode4);*/
singleLinkedList.addByOrder(heroNode3);
singleLinkedList.addByOrder(heroNode2);
singleLinkedList.addByOrder(heroNode1);
singleLinkedList.addByOrder(heroNode4);
//测试修改节点
HeroNode newHeroNode = new HeroNode(2,"小卢","小玉");
singleLinkedList.update(newHeroNode);
singleLinkedList.delete(2);
singleLinkedList.list();
}
}
class SingleLinkedList{
//先初始化一个头节点，头节点不要动
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向链表
//思路：当不考虑编号顺序时
//1.找到当前链表的最后节点
//2.将最后这个节点的next指向新的节点
public void add(HeroNode heroNode){
//因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode temp = head;
while (true){
//找到链表的最后
if(temp.next==null){
break;
}
temp = temp.next;
}
//如果没有找到最后，将temp后移
temp.next = heroNode;
}
//删除节点
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 update(HeroNode heroNode){
//判断是否为空
if (head.next==null){
System.out.println("链表为空。。");
return;
}
//找到需要修改的节点，根据no编写
//定义一个辅助变量
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.printf("没有找到 编号 %d 的节点，不能修改\n",heroNode.no);
}
}
//按照编号添加
public void addByOrder(HeroNode heroNode){
HeroNode temp = head;
boolean flag =false;
while (true){
if(temp.next==null){
break;
}
//找到temp的前一个节点
if(temp.next.no>heroNode.no){
break;
}else if (temp.next.no==heroNode.no){
flag = true;//说明编号存在
}
temp = temp.next;
}
//判断flag的值
if(flag){
//不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号%d 存在,不能再添加\n",heroNode.no);
}else {
//插入链表中，temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//遍历
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.next;
}
}
}
class HeroNode {
int no;
String name;
String nickName;
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 +
'}';
}
}
面试题
ii）遍历统计就行
//方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
/**
*
* @param head 链表的头节点
* @return 返回的就是有效节点的个数
*/
public static int getLength(HeroNode head) {
if(head.next == null) { //空链表
return 0;
}
int length = 0;
//定义一个辅助的变量, 这里我们没有统计头节点
HeroNode cur = head.next;
while(cur != null) {
length++;
cur = cur.next; //遍历
}
return length;
}
ii）先统计个数size，将倒数第k个，转换为正数第（size-k）个，有头节点
/思路
//1. 编写一个方法，接收head节点，同时接收一个index
//2. index 表示是倒数第index个节点
//3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
//4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
//5. 如果找到了，则返回该节点，否则返回nulll
public static HeroNode findLastIndexNode(HeroNode head, int index) {
//判断如果链表为空，返回null
if(head.next == null) {
return null;//没有找到
}
//第一个遍历得到链表的长度(节点个数)
int size = getLength(head);
//第二次遍历 size-index 位置，就是我们倒数的第K个节点
//先做一个index的校验
if(index <=0 || index > size) {
return null;
}
//定义给辅助变量， for 循环定位到倒数的index
HeroNode cur = head.next; //3 // 3 - 1 = 2
for(int i =0; i< size - index; i++) {
cur = cur.next;
}
return cur;
}
ii）单链表反转
//将单链表进行反转
public static void reversetList(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的节点进行存储
next = cur.next;
//插入新链表的第一个位置
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;
}
head.next = reverseHead.next;
}
ii）从尾部打印到头部（可以上面的方式，但是会改变链表的结构，不建议使用）
//利用栈这个数据结构，实现逆序打印
public void reversePrint(HeroNode heroNode){
if(heroNode.next==null){
return;
}
//创建一个栈，将各个节点压入栈
Stack<HeroNode> heroNodeStack =new Stack<HeroNode>();
HeroNode cur = head.next;
while (cur!=null){
heroNodeStack.push(cur);
cur = cur.next;
}
//逆序打印
while(heroNodeStack.size()>0){
System.out.println(heroNodeStack.pop());
}
}
双向链表
单向链表的缺点：
ii）单向链表只能是一个方向，而双向链表可以往前或者往后查找；
ii）单向链表不能自我删除，需要找到前一个节点；而双向链表可以自我删除；
双向链表的操作分析：
完整代码
package 数据结构.链表;
import java.util.Stack;
public class DoubleLinkedListDemo{
public static void main(String[] args) {
//测试
//创建节点
HeroNode2 heroNode1 = new HeroNode2(1,"宋江","及时雨");
HeroNode2 heroNode2 = new HeroNode2(2,"卢俊义","玉麒麟");
HeroNode2 heroNode3 = new HeroNode2(3,"吴用","智多星");
HeroNode2 heroNode4 = new HeroNode2(4,"林冲","豹子头");
//创建一个连包括
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
/* doubleLinkedList.add(heroNode1);
doubleLinkedList.add(heroNode2);
doubleLinkedList.add(heroNode3);
doubleLinkedList.add(heroNode4);*/
doubleLinkedList.addByOrder(heroNode3);
doubleLinkedList.addByOrder(heroNode2);
doubleLinkedList.addByOrder(heroNode1);
doubleLinkedList.addByOrder(heroNode4);
System.out.println("反转之前--");
doubleLinkedList.list();
/* //利用栈来逆序打印
System.out.println("利用栈来逆序打印");
doubleLinkedList.reversePrint(doubleLinkedList.getHead());
// HeroNode newHead = new HeroNode(0,"","");
doubleLinkedList.reversetList(doubleLinkedList.getHead());
System.out.println("反转之后--");
doubleLinkedList.list();*/
//测试一下，看是否得到倒数第k个节点
/* HeroNode res = singleLinkedList.findLastIndexNode(singleLinkedList.getHead(),1);
System.out.println("倒数："+res);*/
//测试修改节点
HeroNode2 newHeroNode = new HeroNode2(2,"小卢","小玉");
doubleLinkedList.update(newHeroNode);
// doubleLinkedList.delete(2);
doubleLinkedList.list();
}
}
class DoubleLinkedList{
//先初始化一个头节点，头节点不要动
private HeroNode2 head = new HeroNode2(0,"","");
//利用栈这个数据结构，实现逆序打印
public void reversePrint(HeroNode2 heroNode){
if(heroNode.next==null){
return;
}
//创建一个栈，将各个节点压入栈
Stack<HeroNode2> heroNodeStack =new Stack<HeroNode2>();
HeroNode2 cur = head.next;
while (cur!=null){
heroNodeStack.push(cur);
cur = cur.next;
}
//逆序打印
while(heroNodeStack.size()>0){
System.out.println(heroNodeStack.pop());
}
}
//将单链表进行反转
public static void reversetList(HeroNode2 head){
//如果当前链表为空，或者只有一个节点，无需反转
if(head.next ==null || head.next.next==null){
return;
}
//定义一个辅助的指针（变量），帮助我们来遍历之前的链表
HeroNode2 cur = head.next;
HeroNode2 next = null;//用来存储当前节点的下一个节点
HeroNode2 reverseHead = new HeroNode2(0,"","");
while (cur!=null){
//先对next的节点进行存储
next = cur.next;
//插入新链表的第一个位置
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;
}
head.next = reverseHead.next;
}
//返回头节点
public HeroNode2 getHead() {
return head;
}
//添加节点到单向链表
//思路：当不考虑编号顺序时
//1.找到当前链表的最后节点
//2.将最后这个节点的next指向新的节点
public void add(HeroNode2 heroNode){
//因为head节点不能动，因此我们需要一个辅助遍历temp
HeroNode2 temp = head;
while (true){
//找到链表的最后
if(temp.next==null){
break;
}
temp = temp.next;
}
//如果没有找到最后，将temp后移
//形成一个双向链表
heroNode.pre = temp;
temp.next = heroNode;
}
//删除节点
//对应双向链表直接找到要删除的节点就可以，不需要是当前节点的上一个节点
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("没有找到--");
}
}
//修改节点
public void update(HeroNode2 heroNode){
//判断是否为空
if (head.next==null){
System.out.println("链表为空。。");
return;
}
//找到需要修改的节点，根据no编写
//定义一个辅助变量
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.printf("没有找到 编号 %d 的节点，不能修改\n",heroNode.no);
}
}
//按照编号添加
public void addByOrder(HeroNode2 heroNode){
HeroNode2 temp = head;
boolean flag =false;
while (true){
if(temp.next==null){
break;
}
//找到temp的前一个节点
if(temp.next.no>heroNode.no){
break;
}else if (temp.next.no==heroNode.no){
flag = true;//说明编号存在
}
temp = temp.next;
}
//判断flag的值
if(flag){
//不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号%d 存在,不能再添加\n",heroNode.no);
}else {
//插入链表中，temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//遍历
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.next;
}
}
//查找单链表中的倒数第k个结点 【新浪面试题】
//思路
//1. 编写一个方法，接收head节点，同时接收一个index
//2. index 表示是倒数第index个节点
//3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
//4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
//5. 如果找到了，则返回该节点，否则返回nulll
public static HeroNode findLastIndexNode(HeroNode head, int index) {
//判断如果链表为空，返回null
if(head.next == null) {
return null;//没有找到
}
//第一个遍历得到链表的长度(节点个数)
int size = getLength(head);
//第二次遍历 size-index 位置，就是我们倒数的第K个节点
//先做一个index的校验
if(index <=0 || index > size) {
return null;
}
//定义给辅助变量， for 循环定位到倒数的index
HeroNode cur = head.next; //3 // 3 - 1 = 2
for(int i =0; i< size - index; i++) {
cur = cur.next;
}
return cur;
}
//方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
/**
*
* @param head 链表的头节点
* @return 返回的就是有效节点的个数
*/
public static int getLength(HeroNode head) {
if(head.next == null) { //空链表
return 0;
}
int length = 0;
//定义一个辅助的变量, 这里我们没有统计头节点
HeroNode cur = head.next;
while(cur != null) {
length++;
cur = cur.next; //遍历
}
return length;
}
}
class HeroNode2 {
int no;
String name;
String nickName;
HeroNode2 next;//指向下一个节点
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 +
'}';
}
}
单向环形链表（约瑟夫环）
package 数据结构.链表;
public class Josepfu {
public static void main(String[] args) {
CircleSingLinkedList circleSingLinkedList = new CircleSingLinkedList() ;
circleSingLinkedList.addBoy(5);//加入5个小孩
circleSingLinkedList.showBoy();
//测试出圈
circleSingLinkedList.contentBoy(1,2,5);
}
}
class CircleSingLinkedList{
//第一个小孩，当前没有编号
private Boy first = null;
//出圈的顺序
/**
*
* @param startNo 从第几个小孩开始数
* @param countNum 表示数几下
* @param nums 表示最初有几个小孩在圈中
*/
public void contentBoy(int startNo,int countNum,int nums){
//先对数据进行校验
if(first==null || startNo<1 || startNo>nums){
System.out.println("参数输入有误，请重新输入");
return;
}
//创建要给辅助指针，帮助小孩出圈
Boy helper = first;
//先找到辅助变量，即：first的前一个
while (true){
if(helper.getNext()==first){
break;
}
helper = helper.getNext();
}
//小孩报数时候，让first和helper同时移动m-1次，
for(int j=0;j<startNo-1;j++){
first = first.getNext();
helper = helper.getNext();
}
//然后出圈，这里是一个循环操作，知道圈里只有一个节点
while (true){
if(helper ==first){
break;
}
//让first和helper指针同时移动countNum-1
for(int j=0;j<countNum-1;j++){
first = first.getNext();
helper = helper.getNext();
}
//出圈的小孩
System.out.printf("小孩%d出圈\n",first.getNo());
//出圈
first = first.getNext();
//因为helper.getNext()其实是指，出圈的first，所以不能这么写
// helper = helper.getNext();
helper.setNext(first);
}
System.out.printf("最终的小孩%d编号\n",first.getNo());
}
//添加
public void addBoy(int nums){
if(nums<1){
System.out.println("num的值不对");
return;
}
Boy curBoy = null;
//使用for来创建我们的环形链表
for(int i=1;i<=nums;i++){
Boy boy = new Boy(i);
if(i==1){
first = boy;
first.setNext(boy);
curBoy = first;
}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();
}
}
}
//
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;
}
}