作为程序员你真的清楚数据结构吗
Posted 苏州程序大白
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了作为程序员你真的清楚数据结构吗相关的知识，希望对你有一定的参考价值。
作为程序员你真的清楚数据结构吗
✨博主介绍
🌊 作者主页：苏州程序大白
🌊 作者简介：🏆CSDN人工智能域优质创作者🥇，苏州市凯捷智能科技有限公司创始之一，目前合作公司富士康、歌尔等几家新能源公司
💬如果文章对你有帮助，欢迎关注、点赞、收藏
💅 有任何问题欢迎私信，看到会及时回复
💅关注苏州程序大白，分享粉丝福利
🎍什么是数据结构
数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。
数据的逻辑结构和物理结构是数据结构的两个密切相关的方面，同一逻辑结构可以对应不同的存储结构。算法的设计取决于数据的逻辑结构，而算法的实现依赖于指定的存储结构。
数据结构的研究内容是构造复杂软件系统的基础，它的核心技术是分解与抽象。通过分解可以划分出数据的 3 个层次；再通过抽象，舍弃数据元素的具体内容，就得到逻辑结构。类似地，通过分解将处理要求划分成各种功能，再通过抽象舍弃实现细节，就得到运算的定义。上述两个方面的结合可以将问题变换为数据结构。这是一个从具体（即具体问题）到抽象（即数据结构）的过程。然后，通过增加对实现细节的考虑进一步得到存储结构和实现运算，从而完成设计任务。这是一个从抽象（即数据结构）到具体（即具体实现）的过程。
线性表和链表
链表与单链表介绍
链表（Linked LIst）是有序列表，但是它在内存中存储如下：
结合一个实际的工作案例，说明链表的实用价值。
- 链表是以节点的方式来存储，是链式存储。
- 每一个节点包含data域，next域：指向下个节点。
- 如上方图：发现链表的各个节点不一定是连续存储。
- 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
单链表（带头结点）逻辑结构示意如下：
单链表的应用
单链表的应用实列
使用带head头的单向链表实现——水浒英雄排行榜管理：
1、完成对英雄人物的增删改查操作。
2、第一种方法在添加英雄的时候，直接添加到链表的尾部。
3、第二种方式在添加英雄的时候，根据排名讲英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）。
代码实现单链表的 创建、遍历、插入以及顺序插入 如下：
public class SingleLinkedListTest
public static void main(String[] args)
// 01-创建几个节点
HeroNode heroNode1 = new HeroNode(1, "松江", "及时雨");
HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
// 02-创建一个链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
// singleLinkedList.add(heroNode1);
// singleLinkedList.add(heroNode4);
// singleLinkedList.add(heroNode3);
// singleLinkedList.add(heroNode2);
// 按照顺序加入
singleLinkedList.addByOrder(heroNode1);
singleLinkedList.addByOrder(heroNode4);
singleLinkedList.addByOrder(heroNode3);
singleLinkedList.addByOrder(heroNode2);
singleLinkedList.addByOrder(heroNode2);
// 03-显示单链表
singleLinkedList.showList();
/**
* 定义 SingleLinkedList 单链表管理我们的英雄
*/
class SingleLinkedList
// 01-初始化一个头节点，头节点不要动，不存放具体的数据
private HeroNode head = new HeroNode(0, "", "");
public HeroNode getHead()
return head;
// 02-添加节点到单向链表，直接添加到链表尾部
/**
* 思路分析：当不考虑编号顺序时
* 1. 找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
*/
public void add(HeroNode heroNode)
// 因为头节点不能动，所以我们需要一个辅助变量 temp
HeroNode temp = head;
// 遍历链表
while (true)
// 找到链表的最后
if (temp.next == null)
break;
// 如果没有找到最后，将 temp 后移
temp = temp.next;
// 当退出 while 循环时，temp 就指向了链表的最后
temp.next = heroNode;
// 根据排名将英雄添加到指定位置，即按照顺序添加
public void addByOrder(HeroNode heroNode)
HeroNode temp = head;
boolean flag = false; // 标志添加的编号是否存在，默认为 false
while (true)
if (temp.next == null) // 说明 temp 已经在链表最后
break;
if(temp.next.no > heroNode.no)
break;
else if(temp.next.no == heroNode.no) // 编号已经存在
flag = true; // 说明编号存在
break;
temp = temp.next;
if(flag) // 不能添加，编号存在
System.out.printf("待插入的英雄编号 %d 已经存在了，不能加入！", heroNode.no);
else
heroNode.next = temp.next;
temp.next = heroNode;
// 显示链表[遍历]
public void showList()
// 判断链表是否为空
if (head.next == null)
System.out.println("链表为空");
return;
HeroNode temp = head.next;
while (true)
if (temp == null)
break;
System.out.println(temp);
// 将 temp 后移，否则是死循环
temp = temp.next;
/**
* 单链表
*/
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;
// 为了显示方便，重写 toString
@Override
public String toString()
return "HeroNode" +
"no=" + no +
", name='" + name + '\\'' +
", nickname='" + nickname + '\\'' +
'';
单链表的节点信息的 修改操作 ，代码如下：
/* 以下三行代码加入到 main 方法里面 */
// 04-测试修改节点的代码
HeroNode heroNode = new HeroNode(2,"小卢","玉麒麟~~~");
singleLinkedList.update(heroNode);
singleLinkedList.showList();
/* 以下 update 方法加入到 SingleLinkedList 类里面 */
// 修改节点的信息，根据 no 编号来修改
public void update(HeroNode heroNode)
// 判断链表是否为空
if (head.next == null)
System.out.println("链表为空！！！");
return;
HeroNode temp = head.next;
boolean flag = false;
while (true)
if (temp.next == null)
break; // 到达了链表的最后
if (temp.no == heroNode.no)
flag = true;
break;
temp = temp.next;
if (flag)
temp.name = heroNode.name;
temp.nickname = heroNode.nickname;
else
System.out.printf("没有找到编号为 %d 的节点，不能修改！！！", heroNode.no);
单链表的节点信息的 删除操作 ，代码如下：
从单链表中删除一个节点的思路：
1、我们先要找到需要删除的这个节点的前一个节点temp。
2、temp.next=temp.next.next
3、被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收。
/* 以下四行代码加入到 main 方法里面 */
// 05-删除一个节点
singleLinkedList.delete(1);
singleLinkedList.delete(5);
System.out.println("删除后链表的情况~~~~~");
singleLinkedList.showList();
/* 以下 delete 方法加入到 SingleLinkedList 类里面 */
// 根据 no 删除节点
public void delete(int no)
HeroNode temp = head;
boolean flag = false;
while (true)
if (temp.next == null)
break;
if (temp.next.no == no) // 找到待删除结点的前一个结点 temp
flag = true;
break;
temp = temp.next;
if (flag)
temp.next = temp.next.next;
else
System.out.printf("要删除的 %d 节点不存在\\n", no);
单链表面试题（新浪、百度、腾讯）
1、求单链表中有效节点的个数。
2、查找单链表中的倒数第N个节点。
3、单链表的反转。
4、从尾到头打印单链表。
解决 第一个 题目：求单链表中有效节点的个数 ，代码如下：
/* 以下三行代码加入到 main 方法里面 */
HeroNode head = singleLinkedList.getHead();
int length = SingleLinkedList.getLength(head);
System.out.println("有效节点个数为：" + length);
/* 以下 getLength 方法加入到 SingleLinkedList 类里面 */
// 获取单链表的节点个数（如果是带头节点的单链表，则不统计头节点）
public static int getLength(HeroNode heroNode)
if (heroNode.next == null)
return 0;
int length = 0;
// 定义一个辅助遍历，这里就体现了没有统计头节点
HeroNode cur = heroNode.next;
while (cur != null)
length++;
cur = cur.next;
return length;
解决 第二个 题目：查找单链表中的倒数第 k 个节点 ，代码如下：
/* 以下四行代码加入到 main 方法里面 */
HeroNode res1 = SingleLinkedList.findNode(singleLinkedList.getHead(), 2);
System.out.println("res = " + res1);
HeroNode res2 = SingleLinkedList.findNode(singleLinkedList.getHead(), 5);
System.out.println("res = " + res2);
// 查找单链表中的倒数第 n 个节点
/**
* 思路分析：
* 1. 编写一个方法，接收 head 节点，同时接收一个 index
* 2. index 表示是倒数第 index 个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度，使用 getLength 方法
* 4. 得到 size 后，我们从链表的第一个车开始遍历 （size-index） 个，就可以得到
* 5. 如果找到了，则返回该节点，否则返回 null
*/
public static HeroNode findNode(HeroNode head, int index)
if (head.next == null)
return null;
int length = getLength(head);
if (index <= 0 || index > length)
return null;
HeroNode cur = head.next;
for (int i = 0; i < (length - index); i++)
cur = cur.next;
return cur;
解决 第三个 题目：单链表的反转，代码如下：
单链表的反转解题思路：
1、先定义一个节点reverseHead = new HeroNode()；
2、从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端。
3、原来的链表的head.next = reverseHead.next
/* 以下五行代码加入到 main 方法里面 */
// 单链表的反转测试
System.out.println("原来链表的情况~~~");
singleLinkedList.showList();
System.out.println("反转后链表的情况~~~");
SingleLinkedList.reverseList(head);
singleLinkedList.showList();
// 将单链表反转
public static void reverseList(HeroNode head)
// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null)
return;
// 定义一个辅助变量，帮助遍历原先的链表
HeroNode cur = head.next;
HeroNode next = null;
HeroNode reverseHead = new HeroNode(0, "", "");
// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
while (cur != null)
next = cur.next;
cur.next = reverseHead.next; // 将 cur 的下一个节点指向新的链表的最前端
reverseHead.next = cur; // 将 cur 连接到新的链表
cur = next; // 让 cur 后移
// 将 head.next 指向 reverseHead.next ，实现单链表的反转
head.next = reverseHead.next;
解决 第四个 题目：从尾到头打印单链表，代码如下：
// 逆序打印，以下一行加入到 main方法中
SingleLinkedList.revesrePrint(head);
// 实现逆序打印
public static void revesrePrint(HeroNode head)
if(head.next == null)
return;
Stack<HeroNode> stack = new Stack<>();
HeroNode cur = head.next;
// 压栈
while (cur != null)
stack.push(cur);
cur = cur.next;
// 出栈
while (stack.size() > 0)
System.out.println(stack.pop());
双向链表
学完单链表发现，单链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。因而出现了 双链表结构 。双链表 是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向 直接后继 和 直接前驱 。双链表结构如下图：
使用 双链表 对上述单链表的功能进行再次实现，代码如下：
/**
* @Author: 苏州程序大白
* @Create: 2022/4/8 12:51
* @Description: 双向链表案例
*/
public class DoubleLinkedListTest
public static void main(String[] args)
System.out.println("双向链表测试~~~");
// 01-创建几个节点
HeroDoubleNode heroNode1 = new HeroDoubleNode(1, "松江", "及时雨");
HeroDoubleNode heroNode2 = new HeroDoubleNode(2, "卢俊义", "玉麒麟");
HeroDoubleNode heroNode3 = new HeroDoubleNode(3, "吴用", "智多星");
HeroDoubleNode heroNode4 = new HeroDoubleNode(4, "林冲", "豹子头");
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
doubleLinkedList.add(heroNode1);
doubleLinkedList.add(heroNode2);
doubleLinkedList.add(heroNode3);
doubleLinkedList.add(heroNode4);
doubleLinkedList.showList();
// 修改测试
HeroDoubleNode newNode = new HeroDoubleNode(4, "Jack", "Jacky");
doubleLinkedList.update(newNode);
System.out.println("修改后双向链表~~~");
doubleLinkedList.showList();
// 删除测试
doubleLinkedList.delete(3);
System.out.println("删除后双向链表~~~");
doubleLinkedList.showList();
class DoubleLinkedList
// 01-初始化一个头节点，头节点不要动，不存放具体的数据
private HeroDoubleNode head = new HeroDouble以上是关于作为程序员你真的清楚数据结构吗的主要内容，如果未能解决你的问题，请参考以下文章