数据结构之链表
Posted scanner小霸王
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构之链表相关的知识，希望对你有一定的参考价值。
链表的特点：
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;
以上是关于数据结构之链表的主要内容，如果未能解决你的问题，请参考以下文章