Day16-数据结构(1)

最新推荐文章于 2020-11-23 22:00:15 发布
最新推荐文章于 2020-11-23 22:00:15 发布
阅读量178 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t384061961/article/details/100006116
版权

Day16

总结

我是最棒的！基础不牢，地动山摇！

数据结构

通过自己手动实现ArrayList和LinkedList的基本方法，来理解其含义

ArrayList（动态数组）查，改快

LinkedList（单向链表）插入，删除快

ArrayList

package cn.itsource.arraylist;

import java.util.Arrays;


/**
 *	     	3. 需求：
 *			1. 设计一个类可以保存多个任意类型的数据（基于Object数组）
 *			2. 可以任意添加任意类型的数据 void add(Object obj)
 *						version2 自动扩容
 *			3. 可以记录当前数据的个数 int size()
 *			4. 可以打印当前数据结构的对象，格式如下：[值1，值2.。。。。]
 *
 *			5. 查询指定下标的元素  Object searchByIndex(int index)
 *			6. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
 *
 *			7. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
 *			8. 删除指定下标处的元素，返回删除的元素  	Object deleteByIndex(int index)
 *			9. 删除的首次出现的指定元素     void deleteByElement(Object ele)
 *			10.插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
 *					
 *			11.将对象中所有元素清空 void clear();
 *			12.可以创建指定长度的ArrayList对象
 *			13.创建一个默认长度是10的ArrayList对象
 *			14.创建一个默认长度是10，且有指定元素的ArrayList对象
 *
 * @author tyx666
 *
 */
public class ArrayListDemo {
	private Object[] value;
	/**数组元素个数*/
	private int size;
	
	
	/**
	 * 12.可以创建指定长度的ArrayList对象
	 */
	public ArrayListDemo(int length){
		Object[] value = new Object[length];
		this.value = value;
	}
	
	public ArrayListDemo(){
		this.value = new Object[10];
	}
	
	public ArrayListDemo(Object obj){
		this.value = new Object[10];
		add(obj);
	}
	/**
	 * 添加元素
	 * @param obj
	 */
	public void add(Object obj){
		//自动扩容
		if(size >= value.length){
			value = Arrays.copyOf(value, value.length*2);
		}
		value[size] = obj;
		size++;
	}
	
	/**获取当前元素个数*/
	public int size(){
		return size;
	}
	
	/**
	 * 打印方法
	 */
	@Override
	public String toString() {
		Object[] newArr = Arrays.copyOf(value, size);
		return Arrays.toString(newArr);
	}
	
	/**
	 * 查询指定下标的元素
	 * @param index
	 * @return
	 */
	public Object searchByIndex(int index){
		if(index < 0 || index >= size){
			throw new IllegalArgumentException("数组下标不再范围内");
		}
		return value[index];
	}
	
	/**
	 * 返回一个元素第一次出现的位置
	 * @param ele
	 * @return
	 */
	public int searchByElement(Object ele){
		int index = 0;
		
		if(ele == null){
			for (int i = 0; i < value.length; i++) {
				if(value[i] == ele){
					break;
				}
				index++;
			}
		}else {
			for (int i = 0; i < value.length; i++) {
				if(ele.equals(value[i])){
					break;
				}
				index++;
			}
		}
		if(index == value.length){
			return -1;
		}
		return index;
	}
	
	/**
	 * 7. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
	 */
	public void updateByIndex(int index,Object obj){
		if(index < 0 || index >= size){
			throw new IllegalArgumentException("下标范围错误");
		}
		value[index] = obj;
	}
	/**
	 * 8. 删除指定下标处的元素，返回删除的元素  	Object deleteByIndex(int index)
	 */
	
	public Object deleteByIndex(int index){
		Object obj = value[index];
		
		Object[] newArr = new Object[size-1];
		for (int i = 0; i < index; i++) {
			newArr[i] = value[i];
		}
		for(int i = index ;i<newArr.length;i++){
			newArr[i] = value[i+1];
		}
		size--;
		value = newArr;
		return obj;
	}
	/**
	 * 9. 删除的首次出现的指定元素     void deleteByElement(Object ele)
	 */
	public void deleteByElement(Object ele){
		int index = searchByElement(ele);
		deleteByIndex(index);
	}
	
	/**
	 * 10.插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
	 * @param index
	 * @param obj
	 */
	public void insertByIndex(int index,Object obj){
		checkIndex(index);
		if(size >= value.length){
			value = Arrays.copyOf(value, value.length*2);
		}
		
		System.arraycopy(value, index, value, index+1, size-index);
		size++;
		value[index] = obj;
	}
	
	/**
	 * 将对象中所有元素清空 void clear();
	 */
	public void clear(){
		value = new Object[10];
	}
	
	/**
	 * 验证下标的合法性
	 * @param index
	 */
	public void checkIndex(int index){
		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("下标不在范围之内");
		}
	}
}

LinkedList

package cn.itsource.singlylinkedlist;
/**
 * 单向链表底层手动实现
 * @author tyx666
 *	 	1. 可以任意添加任意类型的数据 void add(Object obj)
 *		2. 可以记录当前数据的个数 int size()
 *		3. 可以打印当前数据结构的对象 toString()，格式如下：[值1，值2.。。。。]
 *
 *		4. 查询指定下标的元素  Object searchByIndex(int index)
 *		5. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
 *
 *		6. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
 *		7. 删除指定下标处的元素，返回删除的元素  	Object deleteByIndex(int index)
 *		8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
 *		9.插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
 *					
 *		11.将对象中所有元素清空 void clear();
 *
 *
 */
public class SinglyLinkedList {

	/**链表中的头*/
	private Node first;
	/**记录元素个数*/
	private int size;
	
	/**
	 * 无参构造
	 */
	public SinglyLinkedList(){
		
	}
	
	/**
	 * 有参构造
	 * @param value
	 */
	public SinglyLinkedList(Object value) {
		Node first = new Node(value);
		this.first = first;
		size++;
	}
	
	
	/**
	 * 1. 可以任意添加任意类型的数据 void add(Object obj)
	 * @param obj
	 */
	public void add(Object obj){
		//根据参数创建Node对象
		Node node = new Node(obj);
		//判断first是否为null，如果是，直接赋值
		if (first == null) {
			first = node;
		}else{
			//定义一个变量保存遍历到的位置
			Node temp = first;
			//遍历链表，直到next为null，添加进去
			while(temp.next != null){
				temp = temp.next;
			}
			temp.next = node;
		}
		size++;
	}
	
	/**
	 * 获取元素个数
	 * @return
	 */
	public int size(){
		return size;
	}
	
	/**
	 * 3. 可以打印当前数据结构的对象 toString()，格式如下：[值1，值2.。。。。]
	 */
	@Override
	public String toString() {
		//定义一个sb来拼接
		StringBuilder sb = new StringBuilder("[");
		//判断链表是否为空
		if(first == null){
			return sb.append("]").toString();
		}else {
			//定义临时变量保存位置
			Node temp = first;
			while(temp != null){
				sb.append(temp.value);
				if(temp.next != null){
					sb.append(",");
				}
				temp = temp.next;
			}
			
			sb.append("]");
			return sb.toString();
		}
	}

	 /**
	  * 4. 查询指定下标的元素  Object searchByIndex(int index)
	  * @param index
	  * @return
	  */
	 public Object searchByIndex(int index){
		 checkIndex(index);
		 //计数器
		 int count = 0;
		 //临时变量
		 Node temp = first;
		 while(temp != null){
			 if(count == index){
				 return temp.value;
			 }
			 count++;
			 temp = temp.next;
		 }
		 return null;
	 }
	 
	 /**
	  * 5. 查询指定的元素第一次出现的位置  int searchByElement(Object ele);
	  * @param ele
	  * @return
	  */
	 public  int searchByElement(Object ele){
		 if(ele == null){
			//计数器
			 int index = 0;
			 //临时变量
			 Node temp = first;
			 while(temp != null){
				 if(temp.value == ele){
					 return index;
				 }
				 temp = temp.next;
				 index++;
			 }
		 }else{
			//计数器
			 int index = 0;
			 //临时变量
			 Node temp = first;
			 while(temp != null){
				 if(temp.value.equals(ele)){
					 return index;
				 }
				 temp = temp.next;
				 index++;
			 }
		 }
		 return -1;
	 }
	 
	 /**
	  * 6. 修改指定下标处的元素  void updateByIndex(int index,Object obj)
	  * @param index
	  * @param obj
	  */
	 public void updateByIndex(int index,Object obj){
		 checkIndex(index);
		 //定义中间变量
		 Node temp = first;
		 //计数器
		 int count = 0;
		 while(temp != null){
			 if(count == index){
				 temp.value = obj;
			 }
			 count++;
			 temp = temp.next;
		 }
	 }
	 
	 /*7. 删除指定下标处的元素，返回删除的元素  	Object deleteByIndex(int index)
	 *		8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
	 *		9.插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)*/
	 /**
	  * 删除指定下标处的元素，返回删除的元素  	Object deleteByIndex(int index)
	  * @param index
	  * @return
	  */
	 public Object deleteByIndex(int index){
		 checkIndex(index);
		 //定义中间变量
		 Node temp = null;
		 //计数器
		 int count = 0;
		 if(index == 0){
			//将要删除的元素赋值给temp保存
			temp = first;
			//如果是要删除第一个元素，则直接将第二个元素赋值给first
			first = first.next;
			//元素个数-1
			size--;
			return temp.value;
		 }
		 while(temp != null){
			 temp = first;
			 if(count == index - 1 ){
				 Node temp2 = temp.next;
				 temp.next = temp2.next;
				 size--;
				 return temp2.value;
			 }
			 count++;
			 temp = temp.next;
		 }
		
		 return null;
	 }
	 
	 /**
	  * 8. 删除的首次出现的指定元素     void deleteByElement(Object ele)
	  * @param ele
	  */
	 public void deleteByElement(Object ele){
		int index = searchByElement(ele);
		if(index < 0){
			return;
		}
		deleteByIndex(index);
	 }
	 
	 /**
	  * 9.插入指定下标处一个指定元素 void insertByIndex(int index,Object obj)
	  */
	 public void insertByIndex(int index,Object obj){
		 checkIndex(index);
		 //创建对象
		 Node node = new Node(obj);
		 
		 //考虑在链表头
		 if(index == 0){
			 //将之前第一个元素的地址赋值给node对象
			 node.next = first;
			 //将新创建的元素地址赋值给node对象
			 first = node;
			 //元素个数-1
			 size--;
		 }
		 //中间变量
		 Node temp = first;
		 //计数器
		 int count = 0;
		 while(temp != null){
			 if(count == index - 1){
				 Node temp2 = temp.next;
				 temp.next = node;
				 node.next = temp2;
			 }
			 count++;
			 temp = temp.next;
		 }
		 
	 }
	 
	 /**
	  * 清除链表
	  */
	 public void clear(){
		 first = null;
		 size = 0;
	 }
	 
	 /**
	  * 判断下标的合法性
	  * @param index
	  */
	 public void checkIndex(int index){
		 if(index < 0 || index >= size){
			 throw new IllegalArgumentException("下标不在范围内");
		 }
	 }

	class Node{
		private Object value;
		private Node next;
		
		public Node(Object value) {
			super();
			this.value = value;
		}

		public Object getValue() {
			return value;
		}

		public void setValue(Object value) {
			this.value = value;
		}

		public Node getNext() {
			return next;
		}

		public void setNext(Node next) {
			this.next = next;
		};
		
	}
}
芮芮子天下第一
关注
X16数据结构部分05
men方法栈帧的博客
10-15 151
X16数据结构部分05递归调用打印问题迷宫问题递归实现总目录 递归调用打印问题 /* 递归能够解决什么样的问题呢 阶乘 8皇后 魔攻问题 最短路径问题 举个例子 球和篮子 如果是两个球放到两个篮子里面 就是3种结果(1 1)(2 0)(0 2) 像快速排序 二分查找 归并排序等算法都需要用到递归 递归需要遵循的重要规则 方法区内存是独立的，不受外部影响 如果递归的是引用数据
X16数据结构部分06
men方法栈帧的博客
10-18 176
X16数据结构部分06交换式希尔排序算法移动式希尔排序算法附赠3大排序算法快速排序算法实现归并排序算法实现基数排序算法实现总目录 交换式希尔排序算法 package du; /** * @author 404小恐龙 * @version 1.8 * @date 2021/10/4 11:53 */ public class m05 { /* 希尔排序实现思路（交换式实现） 假设有10个无序数 则初始增量 gap = 10 / 2 = 5
16、算法和数据结构
weixin_48512144的博客
07-12 603
一、排序 1、冒泡排序 两两比较，前一个数比后一个数大，交换位置。 2、选择排序 从第一个数开始，每个数与后边所有数比较，如果比第一个数小，记录下标，直到比完，最小下标和第一个数交换。 二、递归和折半查找 1、递归：自己调自己 2、折半查找： 前提：有序 用递归做折半查找 三、数据结构 ...
16 数据结构和算法——排序算法总结及代码实现（冒泡，选择，插入，Shell，快速，堆，合并）
热门推荐
数据知道的博客
07-15 3万+
1. 冒泡排序： 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。案例如下： java面试：冒泡排序详解 (Java经典编程案例) Go面试： 实现冒泡排序 (Golang经典编程案例) 2. 选择排序： java面试：选择排序代码实现 (Java经典编程案例) Go面试：实现选择排序 (Golang经典编程案例) 3...
数据结构和算法(16)查找算法
qq_44779506的博客
03-24 187
学习数据结构和算法的日常Demo 查找算法介绍 在java中,我们常用的查找有四种: 顺序(线性查找) 二分查找 插值查找 斐波拉契查找 线性查找算法 代码实现 public class 线性查找 { public static void main(String args[]) { int a[] = {6, 2, 32, 43, 8, 16, 21, 9, 77,...
Day16-30_Day16-30_python_
10-03
5. **数据结构进阶**： - 集合（set）：无序且不重复的元素集合，支持数学运算。 - 字典（dict）：键值对存储，通过键进行快速查找。 - 列表推导式和字典推导式：简洁地创建新的列表和字典。 - 序列切片和列表...
python爬虫-Day16 数据结构和算法.rar
08-29
python爬虫-Day16 数据结构和算法.rar
mysql高级笔记 P1 day01-02. MySQL 高级 - Linux上安装MySQL P2 day01-03. MyS
09-20
MySQL 高级 - 索引 - 数据结构 P6 day01-07. MySQL 高级 - 索引 - 数据结构 - BTREE P7 day01-08. MySQL 高级 - 索引 - 数据结构 - B+TREE P8 day01-09. MySQL 高级 - 索引 - 索引分类 P9 day01-10. MySQL 高级 - ...
12.20 day1 数据结构
12-20
12.20 day1 数据结构
100天拿下Python - Day 16-20（附源码）
08-12
Python语言进阶 1.数据结构和算法 2.函数的使用方式 3.面向对象相关知识 4.迭代器和生成器 5.并发编程 文件类型：markdown文档
数据结构（十六）— 图结构之图的定义及术语
WOLF
06-24 2498
图的定义 图的存储结构 遍历图
数据结构--关于插入排序
weixin_44628096的博客
11-23 1011
数据结构–关于插入排序 理解插入排序的过程 1.对于任意一个数组序列，可以是有序的，也可以是无序的，我们先取这个数组的第一个元素，将他视为一个有序数组（只有一个元素的数组当然可以认为是有序的啦），然后将第二个元素与他比较，如果比他大，则依旧保持原来位置，否则，交换位置，这样我们就可以得到前两个元素是有序的数组。 2.我们将第三个元素与第二个元素比较，如果比他大，则依旧保持原来位置，否则，交换位置，这里是和上面一样，但是我们还要比较第一个元素与第二个元素的大小，这是针对如果第三个和第二个交换的话，当然了，如果
Java用数组实现ArrayList
adminstor的博客
08-22 693
需要实现的功能有： 1. 设计一个类可以保存多个任意类型的数据（基于Object数组） 2. 可以任意添加任意类型的数据 void add(Object obj) version2 自动扩容 3. 可以记录当前数据的个数 int size() 4. 可以打印当前数据结构的对象，格式如下：[值1，值2.。。。。] 5. 查询指定下标的元素 Object searchByIndex(int inde...
数据结构(16)--图的存储及实现
小白的专栏
03-03 1万+
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 图状结构是一种比树形结构更复杂的非线性结构。在树状结构中，结点间具有分支层次关系，每一层上的结点只能和上一层中的至多一个结点相关，但可能和下一层的多个结点相关。而在图状结构中，任意两个结点之间都可能相关...
基于数组和变量的数据结构
cai_bird11的博客
07-21 271
数据结构 基于数组的数据结构：以数组为基础，储存不同数据类型的数据，数组的类型是Object` 基于变量的数据结构：Object类型的变量可以装任何类型的数据，因此可以设计一个类，类中有一个Object类的变量用用来存放各种类型的单一数据，想要使用类中变量，就得构造对象，而一个对象只有一个Object类的变量（如果在该类中声明多个Object类的变量是不划算且扩展性差）。并且不同对象之间没有任何关联，不方便保存多个数据，因此考虑将将该类的对象建构类类似数组的形式（通过在类中创建一个该类的变...
数据结构（十六）——左高树（含合并过程详细图解）
夜的第七章
07-18 2557
文章目录前言左高树什么是左高树?为什么要使用左高树?最大左高树实现及复杂度分析节点类和最大左高树类合并方法插入(push)、删除(pop）初始化左高树合并图解 前言 看到左高树的时候，对左高树的印象大概只有左高树这三个字了。看的时候费劲了一点，因为不知道这个数据结构是干嘛的。网上的资料也比较少。所以这篇文章理解能力有限，请见谅。 左高树 什么是左高树? 左高树大致分为高度优先左高树和重量优先左高树两类。 本文以高度优先左高树为例。 左高树中定义了几个新的概念，比如外部节点、内部节点和扩充二叉树。 外部节点
算法与数据结构（快速排序）
fujz123的博客
04-29 238
快速排序 Quick Sort 快速排序是对冒泡排序的一种改进 通过一趟排序将序列分为两个部分，其中一个部分的所有数据比另一个部分的所有数据都小，然后再分别对两个部分进行类似操作（递归），直到整个序列有序 基本思路： 随机找出一个数，或是取第一个或最后一个数为基准。然后将所有的数和基准比较，比基准小，就放左边，比基准大就放右边，这样就把一个序列分成了两个子序列。然后按照同样的方法对子序列排序...
5116-微信小程序电影院订票选座系统设计及实现+ssm（源码+数据库+lun文）.zip
最新发布
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
JavaScript 中的 `Array.prototype.filter` 方法全解析
09-15
在 JavaScript 编程中，处理数组是一项基本而重要的任务。数组的过滤操作是其中的一个常见需求，Array.prototype.filter 方法为此提供了强大的支持。本文将深入探讨 Array.prototype.filter 方法的工作原理、使用场景、代码示例以及与其他数组方法的比较。 Array.prototype.filter 是 JavaScript 中处理数组的强大工具，它允许开发者以声明式的方式轻松筛选出符合特定条件的元素。通过结合使用 Array.prototype.filter 和其他数组方法，可以解决各种复杂的数据筛选问题。 通过本文的详细介绍和示例代码，你应该能够掌握 Array.prototype.filter 的工作原理，并能够在实际开发中灵活运用它来处理数组数据。此外，了解其与 Array.prototype.map 和 Array.prototype.reduce 的结合使用，可以帮助你更好地编写高效且易于维护的代码。
Python基础入门：Day1-3编程概览与数据结构
Day 2 的内容转向更高级的数据结构，首先是字符串的深入处理，讲解ASCII、Unicode和UTF-8字符编码之间的关系及其相互转换。接着，学生将学习Python中的列表、元组这两种序列类型，以及哈希表（字典）和collections...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值