1.简介
- 误区
- 认为学习数据结构和算法需要很扎实的数学和编程功底，学起来并不容易;
- 数据结构和算法在平时开发过程中的应用并不多，而且都有现成的类库接口让我们调用，没必要花太多时间去研究。
- 疑问
- 为什么数据结构和算法使用率这么低，这些大公司还必问呢？这是因为数据结构和算法真的很重要，而且他们的使用率并不低，所有的程序中都有数据结构和算法的身影，他们默默的为程序服务，只是你没重视他们罢了。
- 列举我们为什么要学好数据结构和算法原因
- 提升代码性能，结省空间复杂度和时间复杂度;
- 算法锻炼自己的逻辑思维;
- 你会不自觉的考虑你写的代码处理的数据量级是多少，会考虑你的代码是否能处理大量数据的情况
- 更好的理解应用软件和框架，很多知名软件和框架中都大量用了数据结构算法，比如mysql的索引用了b+树，redis的list底层用了跳跃表，理解这些数据结构能更好的帮助我们理解使用这些软件。
- 掌握了数据结构与算法，你看待问题的深度，解决问题的角度就会完全不一样。
- 一流的程序员搞算法，二流的程序员搞架构，三流的程序员搞业务;
数据结构与算法的关系：
- 程序 = 数据结构 + 算法
- 数据结构是算法的基础。
- 图书馆储藏书籍你肯定见过吧？为了方便查找，图书管理员一般会将书籍分门别类进行“存储”。按照一定规律编号，就是书籍这种“数据”的存储结构。那我们如何来查找一本书呢？有很多种办法，你当然可以一本一本地找，也可以先根据书籍类别的编号，是人文，还是科学、计算机，来定位书架，然后再依次查找。笼统地说，这些查找方法都是算法。
- 数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。
线性结构与非线性结构：
- 线性结构：数组、队列、链表和栈。
- 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
- 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。
- 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素结点存放数据元素以及相邻元素的地址信息。
- 非线性结构：二维数组，多维数组，广义表，树，图。
2.单向链表
链表是一种物理存储单元上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
特点：
- 链表是以结点形式存储的，是链式存储。
- 每个结点包含data区域和next区域。
- 如上图各个结点并不是连续存储的。
- 链表分带头结点链表和没有带头结点链表，根据实际的需求来确定。
3.代码案例
我们首先需要一个实体类，它对应的便是单链表中每个节点的数据信息。
package com.szh.unidirectional;
/**
*
*/
public class GoodsNode {
public int id;
public String name;
public double price;
public GoodsNode next;
public GoodsNode(int id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "GoodsNode{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}
接下来，我们写一个具体对单链表进行CRUD的操作类。
package com.szh.unidirectional;
/**
*
*/
public class DLLinkedList {
private GoodsNode node = new GoodsNode(0, "", 0.0);
//在单向链表末尾插入节点
public void addLast(GoodsNode goodsNode) {
GoodsNode temp = node; //辅助变量
while (true) {
if (temp.next == null) {
break;
}
temp = temp.next;
}
temp.next = goodsNode;
}
//在单向链表中间某个位置插入节点
public void addOrder(GoodsNode goodsNode) {
GoodsNode temp = node; //辅助变量
boolean flag = false; //标记变量
while (true) {
if (temp.next == null) {
break;
}
if (temp.next.id > goodsNode.id) {
break;
} else if (temp.next.id == goodsNode.id) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
System.out.println("已经存在了该商品，不能添加重复元素");
} else {
goodsNode.next = temp.next;
temp.next = goodsNode;
}
}
//修改单向链表的某个节点
public void updateNode(GoodsNode goodsNode) {
//如果链表为空
if (node.next == null) {
System.out.println("链表为空....");
return;
}
GoodsNode temp = node.next; //辅助变量
boolean flag = false; //标记变量
while (true) {
if (temp == null) {
break;
}
if (temp.id == goodsNode.id) { //找到了要修改的链表节点
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.name = goodsNode.name;
temp.price = goodsNode.price;
} else {
System.out.println("在整个链表中未找到目标节点....");
}
}
//删除单向链表的某个节点
public void deleteNode(int id) {
//如果链表为空
if (node.next == null) {
System.out.println("链表为空....");
return;
}
GoodsNode temp = node; //辅助变量
boolean flag = false; //标记变量
while (true) {
if (temp.next == null) {
break;
}
if (temp.next.id == id) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.next = temp.next.next;
} else {
System.out.println("未找到删除的结点....");
}
}
//遍历单向链表，查看每个节点元素
public void list() {
//如果链表为空
if (node.next == null) {
System.out.println("链表为空....");
return;
}
GoodsNode temp = node.next; //辅助变量
int index = 0;
while (true) {
if (temp == null) {
break;
}
System.out.println("第 " + (++index) + " 个节点元素为：" + temp);
temp = temp.next;
}
//System.out.println("此单向链表中共有 " + index + " 个节点元素。");
}
//统计单向链表中节点的个数
public int getNodeNum() {
//如果链表为空
if (node.next == null) {
System.out.println("链表为空....");
return 0;
}
GoodsNode temp = node.next;
int num = 0;
while (temp != null) {
num++;
temp = temp.next;
}
return num;
}
}
最后是我们的主方法类，我们需要对上面写好的代码功能进行测试。
package com.szh.unidirectional;
/**
* 单向链表相关操作
*/
public class LinkedTest {
public static void main(String[] args) {
DLLinkedList dlLinkedList = new DLLinkedList();
GoodsNode goodsNode1 = new GoodsNode(1, "西游记", 55.55);
GoodsNode goodsNode2 = new GoodsNode(2, "水浒传", 66.66);
GoodsNode goodsNode3 = new GoodsNode(3, "红楼梦", 88.88);
GoodsNode goodsNode4 = new GoodsNode(4, "三国演义", 99.99);
System.out.println("单向链表的插入操作：");
dlLinkedList.addLast(goodsNode1);
dlLinkedList.addLast(goodsNode3);
dlLinkedList.addOrder(goodsNode4);
dlLinkedList.addOrder(goodsNode2);
dlLinkedList.list();
System.out.println("此单向链表中共有 " + dlLinkedList.getNodeNum() + " 个节点元素。");
System.out.println();
System.out.println("单向链表的修改操作：");
dlLinkedList.updateNode(new GoodsNode(3, "Java编程思想", 11.11));
dlLinkedList.list();
System.out.println("此单向链表中共有 " + dlLinkedList.getNodeNum() + " 个节点元素。");
System.out.println();
System.out.println("单向链表的删除操作：");
dlLinkedList.deleteNode(2);
dlLinkedList.list();
System.out.println("此单向链表中共有 " + dlLinkedList.getNodeNum() + " 个节点元素。");
}
}
4.单向链表的CRUD图解
在单向链表的末尾插入新的节点。
在单向链表的中间某个位置插入新的节点。
单向链表的修改操作。（比较简单）
单向链表的删除操作。
5.数组与链表的区别
- 数组和链表的区别：
- 数组的元素个数是固定的，而链表的结点个数可按需要增减。
- 数组元素的存储单元在定义时分配，链表节点的存储单元在执行时动态向系统申请。
- 数组的元素顺序关系由元素在数组中的位置（即下标）确定，链表中的节点关系由节点所包含的指针来体现。
- 对于不是固定长度的列表，用可能最大长度的数组来描述，会浪费许多的存储空间。
- 对于元素的插入、删除操作非常频繁的列表处理场合，用数组表示列表也不是不合适。若用链表实现，会使程序结构清晰，处理的方法也比较简便。
- 数组的特点
- 在内存中，数组是一块连续的区域。
- 数组需要预留空间，在使用前要先申请内存的大小，可能会浪费内存空间。
- 插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中要向后移。
- 随机读取率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给的地址数据。
- 并不利于扩展，数组定义的空间不够时要重新定义数组。
- 链表的特点
- 在内存中可以存在如何地方，不要求连续。
- 每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据。
- 增删数据很容易。查找数据时效率低，因为不具有随机访问性。
- 不指定大小，扩展方便。链表大小不用定义，数据随意增删。
6.单链表面试题
- 求单链表中有效节点的个数
- 查找单链表中的倒数第k个结点
- 单链表的反转
- 从尾到头打印单链表
package com.szh.linkedlist;
import java.util.Objects;
import java.util.Stack;
/**
*
*/
class HeroNode2 {
public int no;
public String name;
public String nickname;
public HeroNode2 next; //指向下一个节点
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 + "]";
}
}
class SingleLinkedList2 {
//先初始化一个头节点，头结点不要动，不存放具体数据
private HeroNode2 head = new HeroNode2(0, "", "");
//返回头节点
public HeroNode2 getHead() {
return head;
}
//在单向链表的中间某个位置添加新节点
public void addByOrder(HeroNode2 heroNode) {
//因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//temp是位于添加位置的前一个节点，否则插入不了
HeroNode2 temp = head;
boolean flag = false; //flag标志添加的编号是否存在，默认为false
while (true) {
if (temp.next == null) { //说明temp已经在链表的最后
break;
}
if (temp.next.no > heroNode.no) { //位置找到，就在temp的后面插入
break;
} else if (temp.next.no == heroNode.no) { //说明希望添加的heroNode的编号已然存在
flag = true;
break;
}
temp = temp.next; //向后移动遍历当前链表
}
if (flag) { //不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
} else {
//将新节点插入到temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
//遍历链表
public void list() {
//首先判断链表是否为空
if (Objects.isNull(head.next)) {
System.out.println("此单向链表为空....");
return;
}
//因为头节点不能动，所以将其存入一个辅助变量中
HeroNode2 temp = head.next;
while (true) {
//判断是否走到链表的末尾
if (Objects.isNull(temp)) {
break;
}
//输出当前链表节点的信息
System.out.println(temp);
//如果没有到链表的末尾，则将temp依次后移
temp = temp.next;
}
}
}
public class SingleLinkedListDemo2 {
//方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
public static int getLength(HeroNode2 head) {
if (head.next == null) { //空链表
return 0;
}
int length = 0;
HeroNode2 temp = head.next; //定义一个辅助的变量, 这里我们没有统计头节点
while (temp != null) {
length++;
temp = temp.next;
}
return length;
}
/**
* 查找单链表中的倒数第k个结点
* 思路
* 1. 编写一个方法，接收head节点，同时接收一个index
* 2. index 表示是倒数第index个节点
* 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
* 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
* 5. 如果找到了，则返回该节点，否则返回null
*/
public static HeroNode2 findLastIndexNode(HeroNode2 head, int index) {
//判断链表是否为空
if (head.next == null) {
return null;
}
//获取链表中所有节点个数（长度）
int size = getLength(head);
//对index做简单校验
if (index <= 0 || index > size) {
return null;
}
//定义给辅助变量， for循环定位到倒数index位的链表节点
HeroNode2 current = head.next;
//假设链表size=5，我们要找倒数第index=2的节点，则需要遍历到size-index=5-2=3的前一个位置（0 → 1 → 2）
//此位置所指向的下一个位置，即我们要找的倒数第index节点
for (int i = 0; i < size - index; i++) {
current = current.next;
}
return current;
}
//单向链表的反转
public static void reverseList(HeroNode2 head) {
//如果当前链表为空，或者只有一个节点，无需反转，直接返回
if(head.next == null || head.next.next == null) {
return;
}
//定义一个辅助的指针(变量)，帮助我们遍历原来的链表
HeroNode2 current = head.next;
//指向当前节点[current]的下一个节点
HeroNode2 next = null;
//反转之后的新链表
HeroNode2 reverseHead = new HeroNode2(0, "", "");
//遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
while (current != null) {
next = current.next; //先暂时保存当前节点的下一个节点，因为后面需要使用
current.next = reverseHead.next; //将current的下一个节点指向新的链表的最前端
reverseHead.next = current; //将current连接到新的链表上
current = next; //让current后移
}
//将 head.next 指向 reverseHead.next, 实现单链表的反转
head.next = reverseHead.next;
}
//逆序打印单向链表 (可以利用 栈 这种数据结构 先进后出 的特点来实现)
public static void reversePrint(HeroNode2 head) {
if (head.next == null) { //空链表直接返回
return;
}
//创建一个栈，将链表各个节点依次入栈
Stack<HeroNode2> stack = new Stack<>();
HeroNode2 current = head.next;
while (current != null) {
stack.push(current); //将节点压入栈中
current = current.next; //后移，这样就可以压入下一个节点
}
//将栈中元素（链表的各个节点）依次出栈
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
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, "林冲", "豹子头");
SingleLinkedList2 singleLinkedList = new SingleLinkedList2();
//向单向链表的中间某个位置添加节点
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero2);
//测试一下 求单链表中有效节点的个数
System.out.println("有效的节点个数 = " + getLength(singleLinkedList.getHead()));
System.out.println("反转之前的单链表：");
singleLinkedList.list();
//单向链表的反转
reverseList(singleLinkedList.getHead());
System.out.println("反转之后的单链表：");
singleLinkedList.list();
//逆序打印单向链表
System.out.println("测试逆序打印单链表, 没有改变链表的结构~~~");
reversePrint(singleLinkedList.getHead());
}
}
6109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
