算法基础知识--数组、单链表、双向链表

最新推荐文章于 2024-06-16 20:54:56 发布
最新推荐文章于 2024-06-16 20:54:56 发布
阅读量57 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36255346/article/details/129221071
版权

什么是数据结构？
数据结构是数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据或者修改数据。

三种数据结构：线性结构（数组、链表、栈、队列哈希表（也叫做散列表））、树形结构、图形结构。

数组
是一种顺序存储的线性表，所有元素的内存地址是连续的，基于这样的存储方式，数组具备一个很大的优点：快速查询，通过索引可以快速获取到需要查询的数据。
数组具备以下几个概念。

1、长度：数组当前有多少个元素
2、容量：数组最大能够存放多少个元素

疑惑：当我们不确定数组需要存多少个元素怎么办？初始化无法设置具体容量

也可以自己写动态数组

package t;

public class MyOwnArrayList<E> {
	// 元素的数量
	private int size;

	private static final int ELEMENT_NOT_FOUND = -1;

	// 所有的元素,定义为泛型，适应不同数据类型
	private E[] data;

	// 初始容量
	private static final int DEFAULT_CAPACITY = 100;

	public MyOwnArrayList(int capacity) { // 容量小于100一律扩充为100
		capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
		data = (E[])new Object[capacity];
	}

	public MyOwnArrayList(){
		this(DEFAULT_CAPACITY);
	}

	/**
	 * 获取数组中的元素数量
	 * @return
	 */
	public int size(){
		return size;
	}

	/**
	 * 判断数组是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}

	/**
	 * 判断数组是否包含某个元素
	 * @param element
	 * @return
	 */
	public boolean contains(E element){
		// 如果等于 -1 ，表示数组不包含该元素
		// 如果不等于 -1 ，表示有正确的索引，数组包含该元素
		return indexOf(element) != ELEMENT_NOT_FOUND;
	}

	/**
	 * 添加元素到数组最末端
	 */
	public void add(E element){
		add(size,element);
	}

	/**
	 * 添加元素到索引 index 位置（增）
	 * @param index
	 * @param element
	 */
	public void add(int index, E element){
		// 检查下标越界
		rangeCheckAdd(index);

		// 保证有足够容量
		ensureCapacity(size + 1);
		//     ↓
		// 0 1 2 3 4 5 6 7 8 9 (索引index)
		// 1 2 3 4 5 6 x x x x (原数组)
		// 在 index = 2处，插入 9 ，元素全部后移
		// 1 2 9 3 4 5 6 x x x (add 后数组)
		// 从后往前, 将每个元素往后移一位, 然后再赋值
		for ( int i = size - 1 ; i >= index ; i-- ){
			data[i + 1] = data[i];
		}

		data[index] = element;

		size++;
	}

	/**
	 * 删除索引 index 位置的元素（删）
	 * @param index
	 * @return 删除的元素
	 */
	public E remove(int index){
		rangeCheck(index);
		E ret = data[index];
		for( int i = index + 1 ; i < size ; i++){
			data[i - 1] = data[i];
		}
		size--;
		// 删除元素后, 将最后一位设置为 null
		data[size] = null;
		return ret;
	}

	/**
	 * 获取索引 index 位置的元素（查）
	 * @param index
	 * @return 原来的元素ֵ
	 */
	public E get(int index){
		rangeCheck(index);
		return data[index];
	}

	/**
	 * 设置索引 index 位置的元素（改）
	 * @param index
	 * @param element
	 * @return 原来的元素ֵ
	 */
	public E set(int index, E element){
		rangeCheck(index);
		E ret = data[index];
		data[index] = element;
		return ret;
	}


	/**
	 * 查看某个元素所在的位置
	 * @param element
	 * @return
	 */
	public int indexOf(E element){
		for (int i = 0; i < size; i++) {
			if(data[i] == element) return i;
		}
		return ELEMENT_NOT_FOUND;
	}

	/**
	 * 删除所有元素
	 */
	public void clear(){
		// 使用泛型数组后要注意内存管理(将元素置null)
		for (int i = 0; i < size; i++) {
			data[i] = null;
		}
		size = 0;
	}

	/*
	 * 扩容操作
	 */
	private void ensureCapacity(int capacity){
		int oldCapacity = data.length;
		if(oldCapacity >= capacity) return;
		// 新容量为旧容量的 2 倍
		int newCapacity = oldCapacity * 2; // 1.5
		E[] newElements = (E[])new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = data[i];
		}
		data = newElements;
	}

	// 下标越界抛出的异常
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
	}
	// 检查下标越界(不可访问或删除size位置)
	private void rangeCheck(int index){
		if(index < 0 || index >= size){
			outOfBounds(index);
		}
	}
	// 检查add()的下标越界(可以在size位置添加元素)
	private void rangeCheckAdd(int index) {
		if (index < 0 || index > size) {
			outOfBounds(index);
		}
	}

	@Override
	public String toString() {
		StringBuilder string = new StringBuilder();
		string.append("size=").append(size).append(", [");
		for (int i = 0; i < size; i++) {
			if(0 != i) string.append(", ");
			string.append(data[i]);
		}
		string.append("]");
		return string.toString();
	}

}

动态数组中执行 插入 和 删除 操作需要移动大量的元素？
动态数组可能会造成内存空间的大量浪费？
链表

链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的，因为只有在每次新增数据的时候才会去申请内存地址，它是真正的动态数据结构。
结构如图
在这里插入图片描述
优点：真正的动态，不需要处理固定容量的问题
缺点，不能像像数组那样，用索引获取元素，随机访问
自定义单链表

package test;

public class MyLinkedList<E> {

	private class Node{
		// 1、当前节点存储的值
		public  E e;

		// 2、当前节点存储的执行下一个节点的地址
		public  Node next;

		public Node(E e, Node next){
			this.e = e;
			this.next = next;
		}

		public Node(E e){
			this(e, null);
		}

		public Node(){
			this(null, null);
		}
	}

	// 元素的数量
	private int size;

	private Node dummyHead;

	public MyLinkedList(){
		dummyHead = new Node();
		size = 0;
	}

	// 1、获取链表中的元素个数
	public  int getSize(){
		return size;
	}

	// 2、判断链表是否为空
	public boolean isEmpty(){
		return  size == 0;
	}

	// 3、在链表头添加元素
	public void addFirst(E e){
		add(0 ,e);
	}

	// 4、在链表中间添加元素
	public void add(int index ,E e){

		Node prev = dummyHead;

		// 需要遍历 index - 1 次，找到 prev 所在的位置
		for( int i = 0 ; i < index  ; i++){
			prev = prev.next;
		}

		Node node = new Node(e);

		node.next = prev.next;

		prev.next = node;

		size++;
	}

	// 5、在链表尾部添加元素
	public void addLast(E e){
		add(size,e);
	}

	// 6、获取链表的第 index 个位置的元素
	public E get(int index) {

		Node cur = dummyHead;

		for (int i = 0; i < index; i++) {
			cur = cur.next;
		}
		return cur.e;
	}

	// 获得链表的第一个元素
	public E getFirst(){
		return get(0);
	}

	// 获得链表的最后一个元素
	public E getLast(){
		return get(size - 1);
	}

	// 8、修改链表的第 index 个位置的元素
	public void set(int index,E e){

		Node cur = dummyHead;

		for (int i = 0; i < index; i++) {
			cur = cur.next;
		}

		cur.e = e;
	}

	// 9、查找链表中是否有该元素
	public boolean contains(E e){
		Node cur = dummyHead;

		// 从头到尾遍历所有元素，直到找到那个元素，或者遍历结束后找不到
		while (cur != null){
			if(cur.e.equals(e)){
				return  true;
			}
			cur = cur.next;
		}

		return  false;
	}

	// 10、删除链表的第 index 个位置的元素
	public E remove(int index){

		Node prev = dummyHead;

		for(int i = 0 ; i < index ; i++){
			prev = prev.next;
		}

		Node retNode = prev.next;
		prev.next = retNode.next;
		retNode.next = null;

		size--;
		return  retNode.e;
	}

	// 11、清空所有元素
	public void clear(){
		size = 0;
		dummyHead = null;
	}

	@Override
	public String toString(){
		StringBuilder res = new StringBuilder();

		Node cur = dummyHead.next;
		while(cur != null){
			res.append(cur.e + "->");
			cur = cur.next;
		}
		res.append("NULL");

		return res.toString();
	}

}

在这里插入图片描述
双向链表
单链表的基础上，每个节点额外增加了一个属性：前驱节点 prev 指针。
在这里插入图片描述

package test;

public class MyDoubleLinkedList<E> {

	private class Node{
		// 当前节点存储的值
		public  E e;

		// 当前节点存储的执行下一个节点的地址
		public  Node next;

		// 当前节点存储的执行前一个节点的地址
		public  Node prev;

		public Node(E e, Node next,Node prev){
			this.e = e;
			this.next = next;
			this.prev = prev;
		}

		public Node(E e){
			this(e, null,null);
		}

		public Node(){
			this(null, null,null);
		}
	}
	private Node dummyHead;

	// 头节点
	private Node head;
	// 尾节点
	private Node tail;
	// 元素的数量
	private int size;
	public MyDoubleLinkedList(){
		head = new Node();
		tail = new Node();
		size = 0;
	}
	// 获取链表中的元素个数
	public  int getSize(){
		return size;
	}

	// 判断链表是否为空
	public boolean isEmpty(){
		return  size == 0;
	}
	// 获取链表的第 index 个位置的元素
	public E get(int index) {

		if( index < size / 2){
			Node cur = head;
			// 这个节点是在前半部分，从头节点开始遍历
			for (int i = 0; i < index; i++) {
				cur = cur.next;
			}
			return cur.e;
		}else{
			Node cur = tail;
			// 这个节点是在后半部分，从尾节点开始遍历
			for (int i = size - 1; i > index; i--) {
				cur = cur.prev;
			}
			return cur.e;
		}
	}
	// 在双向链表头部添加元素
	public void addFirst(E e){
		// 1、新建插入节点 node
		Node node = new Node(e);
		// 2、head 前驱指向 node
		head.prev = node;
		// 3、node 后驱指向 head
		node.next = head;
		// 4、head 移动到 node 节点的位置
		head = node;
		size++;

	}
	// 在双向链表尾部添加元素
	public void addLast(E e){
		// 1、新建插入节点 node
		Node node = new Node(e);
		// 2、node 前驱指向 tail
		node.prev = tail;
		// 3、tail 后驱指向 node
		tail.next = node;
		// 4、tail 移动到 node 节点的位置
		tail = node;
		size++;

	}
	// 在链表中间添加元素
	public void add(int index ,E e){

		if(index == size){
			addLast(e);
		}else {
			// 新建插入节点 node
			Node node = new Node(e);
			// 找到插入 node 位置的前一个节点 preNode 和后一个节点 nextNode
			Node nextNode;
			if( index < size / 2){
				Node cur = head;
				// 这个节点是在前半部分，从头节点开始遍历
				for (int i = 0; i < index; i++) {
					cur = cur.next;
				}
				nextNode = cur;
			}else{
				Node cur = tail;
				// 这个节点是在后半部分，从尾节点开始遍历
				for (int i = size - 1; i > index; i--) {
					cur = cur.prev;
				}
				nextNode = cur;
			}
			Node preNode = nextNode.prev;

			// 3、 preNode 后驱指向 node
			preNode.next = node;
			// 4、nextNode 前驱指向 node
			nextNode.prev = node;
			// 5、node 前驱指向 preNode
			node.prev = preNode;
			// 6、node 后驱指向 nextNode 
			node.next = nextNode;
		}
		size++;

	}
	
}
猿来编码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[Python]数据结构--链表
Festinatione facit vastum
01-11 599
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
计算机二级公共基础知识
04-30
这样的表称为双向链表。 在线性链表中，各数据元素结点的存储空间可以是不连续的，且各数据元素的存储顺序与逻辑顺序可以不一致。在线性链表中进行插入与删除，不需要移动链表中的元素。 线性单链表中，HEAD称为头...
数组和表
Ehco00x0的博客
03-05 611
转载出处：http://www.cnblogs.com/skywang12345/p/3603935.html   数组 数组有上界和下界，数组的元素在上下界内是连续的。 存储10,20,30,40,50的数组的示意图如下： 数组的特点是：数据是连续的；随机访问速度快。 数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维
链表及双向链表
GoldenaArcher的博客
06-17 384
这里暂时不谈环形链表(circular linked list)。链表是一个非常有用的结构，与数组不同，它并不要求数据结构的内存地址保存在一起，而是可以通过指针/引用的方式，获取下一个结点的位置，因此，链表结构可以将散落的数据串联在一起，更大程度的利用空间，减少数据的重排。链表结构如下：1234null 每一个节点包含当前的值，以及下一个结点的引用。结点代码如下： 链表本身的实现就比较简单了，下面实现一些比较基础的功能。首先是 LinkedList 的基础结构： 这里简单的实现了一个 功能，直接打印会出现
数据结构和算法
qq_51399157的博客
05-24 318
JavaSe基础一、环境变量配置二、JDK,JVM和JREJDK、JRE、JVM三者之间的关系三、基本数据类型1.关于计算机存储单位 一、环境变量配置 目的：DOS命令窗口中可执行的命令都有路径配置在了环境变量path中 步骤： 1.点击我的电脑，右击属性 2.点击高级设置–点击环境变量 3.在系统变量中找到path，加上java命令的路径：C:\Program Files\Java\jdk1.8.0_101，用英文状态的分号;隔开 二、JDK,JVM和JRE JDK、JRE、JVM三者之间的关系 1.JD
Java数据结构和算法——数组、单向链表、双向链表
Dream It Possible
06-21 3518
概要线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本文先介绍线性表的几个基本组成部分：数组、单向链表（One-way LinkedList）、双向链表（two-way linked-list ）。数组数组有上界和下界，数组的元素在上下界内是连续的。存储10、20、30、40、50的数组的示意图如下：数组的特点： 1. 数据是连续的； 2. 随机访问速度快。数组中稍
从零学习数据结构与算法---三、数组(Array)与链表
qq_36697880的博客
06-08 237
数组和链表属于数据结构中的基础，是物理结构(数据结构的基础)。 在学习前了解两个概念：线性表和非线性表 第一是线性表（Linear List）。顾名思义，线性表就是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。其实除了数组，链表、队列、栈等也是线性表结构。 第二是非线性表，比如二叉树、堆、图等。之所以叫非线性，是因为，在非线性表中，数据之间并不是简单的前后关系。 一、 数组 数组（Array）是一种线性表数据结构。它用一组连续的内存空间...
【地铁上的面试题】--基础部分--数据结构与算法--数组和链表
喵叔
05-27 875
数据结构与算法》是《地铁上的面试题》专栏的第一章，重点介绍了技术面试中不可或缺的数据结构和算法知识。数据结构是组织和存储数据的方式，而算法是解决问题的步骤和规则。这一章的内容涵盖了常见的数据结构和算法，包括数组和链表、栈和队列、树和图，以及排序和搜索算法等。通过深入学习和理解这些基础概念，读者将能够优化代码、提高算法效率，并解决面试中常见的编程问题。每个主题都将提供清晰的解释、示例代码和常见面试题。
Java数据结构和算法(第二版)
03-09
Java中数组的基础知识 将程序划分成类 类接口 Ordered专题applet 有序数组的Java代码 对数 存储对象 大O表示法 为什么不用数组表示一切？ 小结 问题 实验 编程作业 第3章 简单排序 如何排序？ 冒泡排序 选择排序 ...
Delphi算法与数据结构 源码(下）
04-01
3．2双向链表 3．3链表的优缺点 3．4栈 3．5队列 3．6小结 .第4章查找 4．1比较例程 4．2顺序查找 4．3二分查找 4．4小结 第5章排序 5．1排序算法 5．2排序基础知识 5．3小结 第6章随机算法 6．1随机数生成 6．2其他...
数组实现双向链表、双向链表的操作
qq_40823802的博客
08-13 1821
分析： 思路： 遍历：和单链表一样，只是可以向前，也可以向后查找。 添加（默认添加到双向链表的最后） （1）.先找到双向链表的最后这个节点（temp） （2）.temp.next = newHeroNode （3）.newHeroNode.pre = temp; 修改思路和单链表一样 删除 （1）.以为是双向链表，因此，我们可以实现自我删除某个节点 （2）.直接找到要删除的这个节点，比...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 420
【代码】力扣LCP 08.剧情触发时间。
排序——希尔排序
2301_80662872的博客
06-16 420
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
代码随想录二刷DAY1~3
最新发布
illuosion7的博客
06-16 585
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
6-11 函数题：某范围中的最小值
qq_2937655951的博客
06-13 428
6-11 函数题：某范围中的最小值 分数 5 作者 雷丽兰 单位 宜春学院 有n(n
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 321
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 655
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
机器学习分类及算法
追求更专业的设计
06-12 996
1.1.1.5K近邻KNN还有 聚类（k-means）、随机森林等
双向链表-算法2.13-2.14
10-07
在算法2.13中，我们介绍了向一个已有的双向链表中插入一个新节点的操作。具体来说，算法2.13首先创建一个新节点，然后将新节点的前驱指针设置为当前节点的前驱指针，将新节点的后继指针设置为当前节点，然后将当前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值