链表
1.单链表
1.单链表的定义
1.逻辑结构
线性表的链式存储方式
2.物理结构
- 有无头结点；
- 链表是以结点的方式链式存储的，结点有数据域和指针域；
- 内存中各结点不一定是连续存储的；
2.单链表的常见操作
要想创建单链表，首先要定义结点类，结点类的对象就是一个结点：
- 实际的结点类：
class Node{
//数据域
int no;
String name;
String nickName;
//指针域，指向下一个结点。在Java中，下一结点就是另一个结点对象！
Node next;
//构造器
public Node(int no, String name, String nickName) {
this.no = no;
this.name = name;
this.nickName = nickName;
}
//为了显示对象的具体信息，重写toString方法
@Override
public String toString() {
return "Node{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
有结点类就相当于有了结点，接下来需要完成单链表的创建：
- 单链表的创建：
根据单链表的逻辑结构可知，只要有了头指针就相当于知道了链表的全部信息，所以考虑带有头结点的单链表，创建单链表的过程就是一个动态生成链表的过程。即从“空表”的初始状态起，一次建立各元素结点，并逐个插入链表即可；
代码实现：单链表类
仅需头指针即可完成对链表的访问，插入，删除等操作。
class SingleLinkedList01{
//带头结点，头结点数据域一般不放信息
Node head = new Node(0,"","");//头结点
}
上面的代码创建了带有头结点的单链表类，为了实现增删改查等方法，还需要进一步添加方法！
- 1.增（插入节点）尾插法
//1.增（插入结点），这里写的是尾插法，尾插法需要先遍历整个链表至尾部，再插入新的结点
public void addNode(Node hero){
Node temp = head;
while(true){
if(temp.next == null) break;//不能是temp == null
temp = temp.next;
}
temp.next = hero;//上面的temp要是null的话这里会出现空指针异常
}
- 2.显示链表（打印链表）
//为了验证写的代码，写一个显示的方法
public void list(){
Node temp = head.next;
if(head.next == null){
System.out.println("空链表");
return;
}
while(temp != null){
System.out.println(temp);
temp = temp.next;
}
}
测试上面两个代码
public static void main(String[] args) {
//测试1
Node hero1 = new Node(1,"宋江","及时雨");
Node hero2 = new Node(2,"卢俊义","玉麒麟");
Node hero3 = new Node(3,"吴用","智多星");
//建立空表
SingleLinkedList01 list = new SingleLinkedList01();
//插入测试1的结点
list.addNode(hero1);
list.addNode(hero2);
list.addNode(hero3);
//显示
list.list();
}
/* 结果
Node{no=1, name='宋江', nickName='及时雨'}
Node{no=2, name='卢俊义', nickName='玉麒麟'}
Node{no=3, name='吴用', nickName='智多星'}
*/
- 3.按照编号顺序插入结点
主要考察的是怎么在两个结点中插入新的结点
s.next = p.next
p.next = s;
//2.按照顺序添加结点，已有编号的结点无法插入
public void addNodeByOrder(Node hero){
Node temp = head;
boolean flag = false;//标志是否有重复编号
while(true){
if(temp.next == null) break;
else if(temp.next.no > hero.no){
break;
}else if (temp.next.no == hero.no) {
flag = true;
break;
}
temp = temp.next;
}
if(flag){
System.out.println("元素已经存在！");
}else {
hero.next = temp.next;
temp.next = hero;
}
}
测试上面的按顺序插入
public static void main(String[] args) {
//测试1
Node hero1 = new Node(1,"宋江","及时雨");
Node hero2 = new Node(2,"卢俊义","玉麒麟");
Node hero3 = new Node(3,"吴用","智多星");
Node hero4 = new Node(4,"林冲","豹子头");
//建立空表
SingleLinkedList01 list = new SingleLinkedList01();
//插入测试1的结点
/*list.addNode(hero1);
list.addNode(hero2);
list.addNode(hero3);
list.addNode(hero4);*/
//按顺序插入测试一的结点
list.addNodeByOrder(hero4);
list.addNodeByOrder(hero3);
list.addNodeByOrder(hero2);
list.addNodeByOrder(hero1);
//显示
list.list();
}
/*
Node{no=1, name='宋江', nickName='及时雨'}
Node{no=2, name='卢俊义', nickName='玉麒麟'}
Node{no=3, name='吴用', nickName='智多星'}
Node{no=4, name='林冲', nickName='豹子头'}
*/
- 4.按照结点的序号修改结点的属性
//3.根据编号修改节点
public void update(Node hero){
Node temp = head.next;
boolean flag = false;
if(head.next == null){
System.out.println("空链表");
return;
}
while(true){
if(temp == null){
break;
}else if(temp.no == hero.no){
flag = true;
break;
}
temp = temp.next;
}
if(flag){
temp.name = hero.name;
temp.nickName = hero.nickName;
System.out.println("修改成功");
}else {
System.out.println("修改的结点不属于该链表");
}
}
测试通过：
public static void main(String[] args) {
//测试1
Node hero1 = new Node(1,"宋江","及时雨");
Node hero2 = new Node(2,"卢俊义","玉麒麟");
Node hero3 = new Node(3,"吴用","智多星");
Node hero4 = new Node(4,"林冲","豹子头");
Node hero5 = new Node(1,"11","111");
//建立空表
SingleLinkedList01 list = new SingleLinkedList01();
//插入测试1的结点
/*list.addNode(hero1);
list.addNode(hero2);
list.addNode(hero3);
list.addNode(hero4);*/
//按顺序插入测试一的结点
list.addNodeByOrder(hero4);
list.addNodeByOrder(hero3);
list.addNodeByOrder(hero2);
list.addNodeByOrder(hero1);
//测试按序号修改结点的信息
list.update(hero5);
//显示
list.list();
}
-
- 求单链表的长度
//5.求单链表的长度
public static int getLength(SingleLinkedList01 linkedList01){
Node temp = linkedList01.getHead().next;
int length = 0;
if(linkedList01.getHead().next == null){
System.out.println("链表为空");
return 0;
}
while(temp != null){
length++;
temp = temp.next;
}
return length;
}
测试代码：
public static void main(String[] args) {
//测试1
Node hero1 = new Node(1,"宋江","及时雨");
Node hero2 = new Node(2,"卢俊义","玉麒麟");
Node hero3 = new Node(3,"吴用","智多星");
Node hero4 = new Node(4,"林冲","豹子头");
Node hero5 = new Node(1,"11","111");
//建立空表
SingleLinkedList01 list = new SingleLinkedList01();
//按顺序插入测试一的结点
list.addNodeByOrder(hero4);
list.addNodeByOrder(hero3);
list.addNodeByOrder(hero2);
list.addNodeByOrder(hero1);
System.out.println("====================");
//显示
list.list();
System.out.println(getLength(list));//4
list.del(1);//删除一个
System.out.println(getLength(list));//3
}
- 6.查找单链表的倒数第K个结点，并返回该结点
//6.查找单链表的倒数第K个结点
public static Node findLastIndexNode(SingleLinkedList01 linkedList01,int k){
Node temp = linkedList01.getHead().next;
int length = getLength(linkedList01);
if(temp == null){
System.out.println("链表为空");
return null;
}else if(k <=0 || k > length){
System.out.println("不在查找范围");
return null;
}
for(int i = 0;i < length-k;++i){
temp = temp.next;
}
return temp;
}
测试代码
System.out.println(findLastIndexNode(list, 4));
- 7. 反转链表
1.头插法
//7.单链表的反转
//（1）利用头插法
//（2)利用栈
public static void reverse(SingleLinkedList01 linkedList01){
if(linkedList01.getHead().next == null || linkedList01.getHead().next.next == null)
return;//链表为空，或只有一个结点
Node temp = linkedList01.getHead().next;
Node reverseHead = new Node(0,"","");//建立一个头插法的头结点
Node next = null;
while (temp != null){//刚刚这里一直用的getLength(linkedList01)，然而第一次遍历后，原来的链表就被截断了，该方法只能返回0
next = temp.next;
temp.next = reverseHead.next;
reverseHead.next = temp;
temp = next;//头插法
}
linkedList01.getHead().next = reverseHead.next;//反转完成
}
测试：
public static void main(String[] args) {
//测试1
Node hero1 = new Node(1,"宋江","及时雨");
Node hero2 = new Node(2,"卢俊义","玉麒麟");
Node hero3 = new Node(3,"吴用","智多星");
Node hero4 = new Node(4,"林冲","豹子头");
Node hero5 = new Node(5,"11","111");
//建立空表
SingleLinkedList01 list = new SingleLinkedList01();
//按顺序插入测试一的结点
list.addNodeByOrder(hero4);
list.addNodeByOrder(hero3);
list.addNodeByOrder(hero2);
list.addNodeByOrder(hero1);
list.addNodeByOrder(hero5);
//显示
list.list();
System.out.println("====================");
reverse(list);
list.list();
}
/*
Node{no=1, name='宋江', nickName='及时雨'}
Node{no=2, name='卢俊义', nickName='玉麒麟'}
Node{no=3, name='吴用', nickName='智多星'}
Node{no=4, name='林冲', nickName='豹子头'}
Node{no=5, name='11', nickName='111'}
====================
Node{no=5, name='11', nickName='111'}
Node{no=4, name='林冲', nickName='豹子头'}
Node{no=3, name='吴用', nickName='智多星'}
Node{no=2, name='卢俊义', nickName='玉麒麟'}
Node{no=1, name='宋江', nickName='及时雨'}
*/
- 利用栈实现反转
栈是一种先进后出的线性表，只有一端可以进出：压栈和弹栈。
//2)利用栈,需要导入栈的包
//import java.util.Stack;
public static void reverse1(SingleLinkedList01 linkedList01){
if(linkedList01.getHead().next == null || linkedList01.getHead().next.next == null)
return;
Stack<Node> nodeStack = new Stack<>();
Node temp = linkedList01.getHead().next;
while(temp != null){
nodeStack.push(temp);
temp = temp.next;
}
while(nodeStack.size() > 0){
System.out.println(nodeStack.pop());
}
}
上面是利用栈逆序打印，下面是利用栈反转单链表
//利用栈实现单链表反转
public static void reverse1(SingleLinkedList01 linkedList01){
if (linkedList01.getHead().next == null || linkedList01.getHead().next.next == null)
return;
Node temp = linkedList01.getHead().next;
Stack<Node> stack = new Stack<>();
while(temp != null){
stack.push(temp);
temp = temp.next;//将链表元素全部压栈
}
//linkedList01.getHead().next = null;
Node cur = linkedList01.getHead();
while(stack.size() >0){
//System.out.println(stack.pop());
temp = stack.pop();
cur.next = temp;
cur = cur.next;//这里不会有空指针异常
}
cur.next = null;
}
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
