JAVA数据结构与算法笔记（基础一）

最新推荐文章于 2024-07-24 12:42:40 发布
最新推荐文章于 2024-07-24 12:42:40 发布
阅读量143 收藏
点赞数
分类专栏： 数据结构与算法 java 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42128246/article/details/105272335
版权

一、概述

数据结构概述

  1. 数据结构的定义：数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
  2. 数据存储结构：
    顺序存储
    链式存储
  3. 数据的逻辑结构：
    集合结构：其中的元素属于一个集合，它们是并列关系，没其它关系
    线性结构：元素之间一对一的关系
    树形结构：元素之间一对多的关系，比如文件跟文件夹的关系
    图形结构：元素多对多的关系，呈网状

算法概述

  1. 算法的定义：是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述结局问题的策略机制。
  2. 算法的特性：输入，输出，有穷性，无穷性，确定性，可行性
  3. 算法的基本要求：正确性，可读性，健壮性，时间复杂度，空间复杂度

二、线性结构

数组

数组的基本使用：

  1. 创建数组，赋值，取值：
//一维数组
int arr1[] = new int[]{1,2,3,4,5};
int arr2[] = {1,2,3,4};
//二维数组
int myarr[][] = {{1,2,3},{3,4,5,6}};   //为每一维分配内存的数组
  1. 处理数组：
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}
  1. 解决向数组添加元素，但因为数组的长度不可变，不能直接添加的问题
package domo;
import java.util.Arrays;
public class TestArray1{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要加入数组的目标元素
  int dst = 6;

  //创建一个新数组，长度是原数组+1
  int[] newArr = new int[arr.length+1];
  //把原数组中的数据全部复制到新的数组中
  for(int i=0;i<arr.length;i++>){
    newArr[i] = arr[i]
  }
  //把目标元素放入新数组的最后
  newArr[arr.length] = dst;
  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}
  1. 解决删除数组中的某个元素的问题
package domo;
import java.util.Arrays;
public class TestArray2{
  //创建数组并初始化
  int[] arr = new int[] {4,5,6,7,8,9};
  //快速查看数组中的元素
  System.out.println(Arrays.toString(arr));
  //要删除的元素的下标
  int dst = 3;

  //创建一个新数组，长度是原数组-1
  int[] newArr = new int[arr.length-1];
  //复制原数组中除了要删除的那个元素以外的其它元素
  for(int i=0;i<newArr.length;i++>){
    //要删除的元素之前的元素
    if(i<dst>){
      newArr[i] = arr[i];
    }else{
      newArr[i] = arr[i+1];
    }
  }

  //新数组替换原数组
  arr = newArr;
  System.out.println(Arrays.toString(arr));
}

面向对象的数组

数组对象类
1.数组的元素插入
2.数组的元素的删除
3.数组元素的修改
4.数组元素的查看
5.数组元素的遍历
6.数组元素的长度

package array;

public class ArrayUtil {

	//用于存储整形数据的数组
	private int[] elements;

	//重写构造方法
	public ArrayUtil(){
		//初始化数组
		elements=new int[0];
	}

/********         数组插入元素       **************/

	/**
	 * 向数组任意位置插入元素
	 * @param number
	 * @param element
	 * @return
	 */
	public int[] add(int number,int element){
		//判断插入位置的合理性
		if(number < 0  || number >elements.length){
			throw new RuntimeException("下标越界");
		}
		//创建一个新的数组，数组长度是原数组的长度+1
				int [] arr=new int[elements.length+1];
				//遍历原数组
				for(int i=0;i<elements.length;i++){
					//判断插入位置，留出插入位置
					if(i<number){
						arr[i]=elements[i];
					}else {
						arr[i+1]=elements[i];
					}
				}
				//插入位置添加元素
				arr[number]=element;
				//新数组赋值给原数组
				elements=arr;
				//返回原数组，数组插入元素完成
				return elements;
	}

	/**
	 * 向数组头部添加一个元素
	 * @param element
	 * @return
	 */
	public int[] addHead(int element){
				//创建一个新的数组，数组长度是原数组的长度+1
				int [] arr=new int[elements.length+1];
				//遍历原数组，将元素组的值通过下标一一赋值给新数组，新数组下标总是大于原数组下标1
				for(int i=0;i<elements.length;i++){
					arr[i+1]=elements[i];
				}
				//为新数组的第一个索引赋值需要添加的元素
				arr[0]=element;
				//新数组赋值给原数组
				elements=arr;
				//返回原数组，数组头部添加元素完成
				return elements;
	}




	/**
	 * 向数组末尾添加一个元素
	 * @param element
	 * @return
	 */
	public int[] addEnd(int element){
		//创建一个新的数组，数组长度是原数组的长度+1
		int [] arr=new int[elements.length+1];
		//遍历原数组，将元素组的值通过下标一一赋值给新数组
		for(int i=0;i<elements.length;i++){
			arr[i]=elements[i];
		}
		//为新数组的最后一个索引赋值需要添加的元素
		arr[elements.length]=element;
		//新数组赋值给原数组
		elements=arr;
		//返回原数组，数组末尾添加元素完成
		return elements;
	}



	/********         数组插入元素END       **************/







	/********         数组删除元素       **************/

	/**
	 * 删除任意位置的一个元素
	 * @param number
	 * @return
	 */

	public int[] delete(int number){
				//判断删除的元素是否为空数组
				if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
				}
				//判断删除下标位置的合理性
				if(number <0 || number >=elements.length){
					throw new RuntimeException("下标越界");
				}
				//创建一个新的数组，数组长度是原数组的长度+1
				int [] arr=new int[elements.length-1];
				if(elements.length == 1){
					//新数组赋值给原数组
					elements=arr;
				//返回原数组，数组末尾添加元素完成
				}else{
					//遍历数组
					for(int i=0;i<arr.length;i++){
						if(i<number){
							arr[i]=elements[i];
						}else{
							arr[i]=elements[i+1];
						}
					}
				}
			//新数组赋值给原数组
			elements=arr;
			//返回原数组，数组末尾添加元素完成
			return elements;
	}



	/**
	 * 删除头部第一个元素
	 * @return
	 */
	public int[] deleteHead(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
			throw new RuntimeException("这是一个空数组");
		}
		//创建一个新的数组，数组长度是原数组的长度+1
		int [] arr=new int[elements.length-1];

		if(elements.length == 1){
			//新数组赋值给原数组
			elements=arr;
		//返回原数组，数组末尾添加元素完成
		return elements;
		}else{
			//遍历新数组，将原数组的值通过下标一一赋值给新数组，
		for(int i=0;i<arr.length;i++){
			arr[i]=elements[i+1];
		}
		//新数组赋值给原数组
			elements=arr;
		//返回原数组，数组末尾添加元素完成
		return elements;
		}
	}




	/**
	 * 删除末尾的一个元素
	 * @return
	 */
	public int[] deleteEnd(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
			throw new RuntimeException("这是一个空数组");
		}
		//创建一个新的数组，数组长度是原数组的长度+1
		int [] arr=new int[elements.length-1];
		if(elements.length == 1){
			//新数组赋值给原数组
			elements=arr;
		//返回原数组，数组末尾添加元素完成
		return elements;}else{
		//遍历新数组，将原数组的值通过下标一一赋值给新数组，
		for(int i=0;i<arr.length;i++){
			arr[i]=elements[i];
		}
		//新数组赋值给原数组
			elements=arr;
		//返回原数组，数组末尾添加元素完成
		return elements;
	}
	}

	/********         数组删除元素END       **************/





	/********         数组修改元素       **************/

	/**
	 * 修改数组任意位置元素
	 * @param element
	 * @return
	 */
	public int[] alter(int number,int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		if(number <0 || number >=elements.length){
			throw new RuntimeException("下标越界");
		}

		elements[number]=element;
		//返回原数组，数组末尾添加元素完成
		return elements;
	}



	/**
	 * 修改头部第一个元素
	 * @param element
	 * @return
	 */
	public int[] alterHead(int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		elements[0]=element;
		//返回原数组，数组末尾添加元素完成
		return elements;
	}


	/**
	 * 修改尾部最后一个元素
	 * @param element
	 * @return
	 */
	public int[] alterEnd(int element){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		elements[elements.length-1]=element;
		//返回原数组，数组末尾添加元素完成
		return elements;
	}

/********         数组修改元素END       **************/




	/********         数组查询元素     **************/
	/**
	 * 查询数组头部第一个元素
	 * @return
	 */
	public int  inquireHead(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		return elements[0];
	}


	/**
	 * 查询数组尾部最后一个元素
	 * @return
	 */
	public int  inquireEnd(){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}
		return elements[elements.length-1];
	}



	/**
	 * 查询数组任意位置元素
	 * @param number
	 * @return
	 */
	public int  inquire(int number){
		//判断删除的元素是否为空数组
		if(elements.length<=0){
					throw new RuntimeException("这是一个空数组");
		}

		if(number <0 || number >=elements.length){
			throw new RuntimeException("下标越界");
		}

		return elements[number];
	}

/********         数组查询元素END       **************/




	/********         查寻数组    **************/

	public String arrayFor(){
		String str="[";
		if(elements.length ==0){
			str+="]";
			return str;
		}
		for(int i=0;i<elements.length;i++){
			str+=elements[i];
			if(i!=elements.length-1){
				str+=",";
			}
		}

		str+="]";
		return str;
	}

	/********         查询数组END       **************/

	/********         查询数组长度       **************/

	public int arrayLength(){
		int l=0;
		if(elements.length ==0){
			return l;
		}

		for(int i=0;i<elements.length;i++){
			l=i;
		}
		return l+1;
	}

	/********         查询数组长度       **************/
}

数组对象类之测试类

package array;

public class ArrayTest {
	public static void main(String[] args) {
		ArrayUtil au=new ArrayUtil();

	/************添加元素测试*****************/
		//任意位置添加数据（空数组，位置只能是0了）
		au.add(0, 1);
		//数组头部添加一个元素
		au.addHead(0);
		//数组尾部添加一个元素
		au.addEnd(2);

				//任意位置添加数据
				au.add(3, 3);
				//数组头部添加一个元素
				au.addHead(-1);
				//数组尾部添加一个元素
				au.addEnd(4);

		//查看添加元素后的数组
		System.out.println("查看添加元素后的数组"+au.arrayFor());
		//查看数组长度
		System.out.println("查看添加元素后的数组的长度"+au.arrayLength());

		System.out.println("----------------------------");

		/***********添加元素测试END***************/


		/***********删除元素测试***************/
		//删除任意位置的一个元素
			au.delete(3);
			System.out.println("查看删除任意位置元素后的数组"+au.arrayFor());
		//删除头部元素
			au.deleteHead();
			System.out.println("查看删除头部位置元素后的数组"+au.arrayFor());
		//删除尾部元素
			au.deleteEnd();
			System.out.println("查看删除尾部位置元素后的数组"+au.arrayFor());
			//查看数组长度
			System.out.println("查看添加元素后的数组的长度"+au.arrayLength());
			System.out.println("----------------------------");


		/***********删除元素测试END***************/



			/***********修改元素测试***************/
			//修改任意位置的一个元素
				au.alter(1, 200);
				System.out.println("查看修改任意位置元素后的数组"+au.arrayFor());
			//修改头部元素
				au.alterHead(100);
				System.out.println("查看修改头部位置元素后的数组"+au.arrayFor());
			//修改尾部元素
				au.alterEnd(300);
				System.out.println("查看修改尾部位置元素后的数组"+au.arrayFor());
				//查看数组长度
				System.out.println("查看修改元素后的数组的长度"+au.arrayLength());
				System.out.println("----------------------------");


			/***********修改元素测试END***************/


				/***********查询元素测试***************/

				//查询任意位置的一个元素
					System.out.println("查看任意位置1的元素"+au.inquire(1));
				//查询头部元素
					System.out.println("查看头部位置元素"+au.inquireHead());
				//查询尾部元素
					System.out.println("查看尾部位置元素"+au.inquireEnd());
					//查看数组长度
					System.out.println("查看数组的长度"+au.arrayLength());
					System.out.println("----------------------------");


				/***********查询元素测试END***************/
	}
}
小窝龟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法笔记 Java
Justdoforever的博客
12-14 322
算法笔记 Java hashMap HashMap<Integer, Integer> map = new HashMap<Integer, Integer>(); ** 不能用int，只能用Integer ** map.put(2,3); map.put(3,5); if(map.containsKey(2)){ int d = map.get(2) + 1; map.put(2, d); } //是否为空 if(!map.isEmpty()){ if(map.contains
基于JAVA的数据结构及算法（一）
Zwjue_的博客
12-02 193
数据的逻辑结构有4种：1.集合：数据仅仅属于同一个集合，没有其他的相互关系 2.线性：一对一 3.树形：一对多 4.图形：多对多 数据的逻辑结构一般采用二元组的形式定义： 数据结构 = （D,S) D：数据元素的集合。 S：D中元素之间的关系的集合...
java算法%_java算法笔记
weixin_30667487的博客
02-25 116
排序算法冒泡排序冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得名。举个栗子：对5,3,8,6,4这个无序序列进行冒泡排序。1.首先从后向前冒泡，4和6比较，把4交换到前面，序列变成5,3,8,4,6。2.同理4和8交换，变成5,3,4,8,6,3和4无需交换。3.5和3交换，变成3,5,4,8,6,3.这样一次冒...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法基础（java版）
weixin_41965053的博客
11-02 2259
前言 数据结构与算法是一门相对比较枯燥，但也是编程人员必学的课程。通过学习数据结构与算法，可以提高我们在编程中的思维逻辑；本人也是小白一枚，学习了一段时间后，在这边总结下；尽量以比较白话的方式，来进行更好的理解。 数据结构概述 数据结构可以简单的理解为数据与数据之间所存在的一些关系，数据的结构分为数据的存储结构和数据的逻辑结构。 存储结构 ...
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构---二叉树
weixin_47808575的博客
07-22 305
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 439
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 729
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 983
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 1169
介绍了二叉搜索树的实现与模拟
Java实现七大排序（一）
lllsure的博客
07-23 517
插入排序、希尔排序、选择排序、堆排序
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 468
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构1800题》基础回合总结——第2章 线性表
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 402
和删除第一个结点不必另作判断。另外，不论链表是否为空，链表指针不变。这个要能够表达清楚。如果不设置头结点，边界情况需要特殊处理~应用题看了一下，不想在基础回合更新了，其实程序填空各位也可以暂时忽略——主要是使插入和删除等操作统一，在第一个元素之前插入。如果能保证客观题正确率100%，这本题就没白刷~刷《1800》的意义在于，
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 334
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 916
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
java数据结构与算法笔记
07-25
Java数据结构与算法笔记是在学习B站尚硅谷Java数据结构与算法视频时所做的记录。\[1\]这个笔记包括了稀疏数组的作用和一个代码实例，以及不同时间复杂度的案例和空间复杂度的概念。\[2\]\[3\]在这个笔记中，你可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值