数据结构概述与动态数组

最新推荐文章于 2022-12-29 18:31:58 发布

再听一遍就睡

最新推荐文章于 2022-12-29 18:31:58 发布

阅读量163

点赞数

分类专栏：数据结构与算法知识点文章标签：数据结构概述与动态数组

本文链接：https://blog.csdn.net/jxc47/article/details/100611780

版权

数据结构与算法知识点专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文是day1的学习总结，探讨了数据结构的重要性和选择合适数据结构的必要性。重点介绍了动态数组作为顺序存储结构的实现，讨论了Java内置数组的优缺点，并展示了如何封装动态数组以实现线性表。同时强调了在分析算法效率时考虑最坏情况的时间复杂度。

摘要由CSDN通过智能技术生成

day1学习总结

第一章概述

为什么要学习数据结构？？？
我们是要用计算机解决问题，我们从具体问题中抽象出一个数据模型，设计可以解决这类模型的算法，然后在编写程序就可以得到一个实用的软件。

数据：能够被计算机识别、存储和计算的东西都是数据（二进制）

结构：数据与数据之间一种或多种特定的关系

数据结构：数据+数据之间的关系

（官方）数据结构是相互之间存在一种或多种特定关系的数据元素的集合

数据结构的逻辑结构：是指数据对象中数据元素之间的相互关系

1.集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系
2.线性结构：线性结构中的数据元素之间是一对一的关系
3.树形结构：树形结构中的数据元素之间存在一种一对多的层次关系
4.图形结构：图形结构的数据元素是多对多的关系

数据结构的物理结构：是指数据的逻辑结构在计算机中的存储形式

1.顺序存储结构：开辟一组连续的空间存储数据
通常用数组来实现，数组中空间本身是连续的，保证了数据之间的关系
2.链式存储结构：开辟一组随机的空间存储数据
通常用节点来实现，节点不仅要存储数据，还要存储下一个节点的位置以保证数据之间的关系

注意：我们需要根据应用场景的不同灵活选择最合适的数据结构！！！

算法：解决问题的步骤

（官方）算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作

评价算法：

1.事后统计方法
2.事前分析估算方法
一个程序的运行时间，依赖于算法的好坏和问题的输入规模。

算法时间复杂度
在这里插入图片描述
推导大O阶的步骤

常见的时间复杂度的比较

注意：我们考虑的时间复杂度都是最坏情况

第二章动态数组

Java内置数组特点：

1.数组的长度一旦确定则不可更改
2.数组只能存储同一类型的数据
3.数组中每个存储空间大小一致且地址连续
4.数组提供角标的方式访问元素

Java内置数组的潜在问题：

1.容量不够用
2.指定位置插入或者删除办不到
3.数组对象只有length属性不够用

动态数组的封装
我们可以用面向对象的思想把数组的相关属性和相关行为封装在类中
类似字符串String类，形成数组对象.排序、数组对象.插入（元素）、数组对象.查找（角标）等调用形式

如何封装动态数组

1.属性方面
int size	数组的有效元素个数
int capacity	数组的最大容量data.length
E[]data		数据的存储容器
2.行为方面
增（）
删（）
改（）
查（）
其他（）

注意：动态数组是顺序存储结构的具体实现！！！

线性表：零个或多个数据元素的有限序列

线性表元素的个数 n(n>=0) 定义为线性表的长度，当n=0时，称为空表

	先写一个List接口

package com.oupeng.线性表;
/**
 * List是线性表的最终父接口 
 * */
public interface List<E> {
	
	/**
	 * 获取线性表中元素的个数(线性表的长度)
	 * @return 线性表中有效元素的个数
	 * */
	public int getSize();
	
	/**
	 * 判断线性表是否为空
	 * @return 是否为空的布尔类型值
	 * */
	public boolean isEmpty();
	
	/**
	 * 在线性表中指定的index角标处添加元素e
	 * @param index 指定的角标 0<=index<=size
	 * @param e	要插入的元素
	 * */
	public void add(int index,E e);
	
	/**
	 * 在线性表的表头位置插入一个元素
	 * @param e 要插入的元素 指定在角标0处
	 * */
	public void addFirst(E e);
	
	/**
	 * 在线性表的表尾位置插入一个元素
	 * @param e 要插入的元素 指定在角标size处
	 * */
	public void addLast(E e);
	
	/**
	 * 在线性表中获取指定index角标处的元素
	 * @param index 指定的角标 0<=index<size
	 * @return 该角标所对应的元素
	 * */
	public E get(int index);
	
	/**
	 * 获取线性表中表头的元素
	 * @return 表头元素 index=0
	 * */
	public E getFirst();
	
	/**
	 * 获取线性表中表尾的元素
	 * @return 表尾的元素 index=size-1
	 * */
	public E getLast();
	
	/**
	 * 修改线性表中指定index处的元素为新元素e
	 * @param index 指定的角标
	 * @param e 新元素
	 * */
	public void set(int index,E e);
	
	/**
	 * 判断线性表中是否包含指定元素e 默认从前往后找
	 * @param e 要判断是否存在的元素
	 * @return 元素的存在性布尔类型值
	 * */
	public boolean contains(E e);
	
	/**
	 * 在线性表中获取指定元素e的角标 默认从前往后找
	 * @param e 要查询的数据
	 * @return 数据在线性表中的角标
	 * */
	public int find(E e);
	
	/**
	 * 在线性表中删除指定角标处的元素 并返回
	 * @param index 指定的角标 0<=index<size
	 * @return 删除掉的老元素
	 * */
	public E remove(int index);
	
	/**
	 * 删除线性表中的表头元素
	 * @return 表头元素
	 * */
	public E removeFirst();
	
	/**
	 * 删除线性表中的表尾元素
	 * @return 表尾元素
	 * */
	public E removeLast();
	
	/**
	 * 在线性表中删除指定元素e
	 * */
	public void removeElement(E e);
	
	/**
	 * 清空线性表
	 * */
	public void clear();
	
}

重写了一个ArrayList类来实现List接口

package com.oupeng.线性表;

import java.util.Arrays;

/**
 * 用顺序存储结构实现的List-顺序线性表-顺序表
 * */
public class ArrayList<E> implements List<E> {
	
	private static int DEFAULT_SIZE=10; //容器的默认容量
	private E[] data;	//存储数据元素的容器
	private int size;	//线性表的有效元素的个数 
						//data.length表示线性表的最大容量Capacity
	/**
	 * 创建一个容量默认为10的一个线性表
	 * */
	public ArrayList(){
		this(DEFAULT_SIZE);
	}
	/**
	 * 创建一个容量为指定capacity的一个线性表
	 * */
	public ArrayList(int capacity){
		this.data=(E[]) new Object[capacity];
		this.size=0;
	}
	/**
	 * 将一个数组封装成为一个线性表
	 * */
	public ArrayList(E[] arr){
		// TODO
	}
	
	@Override
	public int getSize() {
		
		return size;
	}

	@Override
	public boolean isEmpty() {
		
		return size==0;
	}

	@Override
	public void add(int index, E e) {
		if(index<0||index>size){
			throw new ArrayIndexOutOfBoundsException("add函数角标越界");
		}
		//判断是否以满
		if(size==data.length){
			resize(2*data.length);
		}
		for(int i=size-1;i>=index;i--){
			data[i+1]=data[i];
		}
		data[index]=e;
		size++;
	}
	/**
	 * 改变data的长度(扩容,缩容)
	 * @param 新数组的长度
	 * */
	private void resize(int newLen) {
		E[] newData=(E[]) new Object[newLen];
		for(int i=0;i<size;i++){
			newData[i]=data[i];
		}
		data=newData;
	}
	
	@Override
	public void addFirst(E e) {
		add(0,e);
	}

	@Override
	public void addLast(E e) {
		add(size,e);
	}

	@Override
	public E get(int index) {
		
		if(index<0||index>size-1){
			throw new ArrayIndexOutOfBoundsException("get函数角标越界");
		}
		
		return data[index];
	}

	@Override
	public E getFirst() {
		return get(0);
	}

	@Override
	public E getLast() {
		return get(size-1);
	}

	@Override
	public void set(int index, E e) {
		if(index<0||index>size-1){
			throw new ArrayIndexOutOfBoundsException("set函数角标越界");
		}
		data[index]=e;
	}

	@Override
	public boolean contains(E e) {
		if(isEmpty()){
			return false;
		}
		for(int i=0;i<size;i++){
			if(data[i]==e){
				return true;
			}
		}
		return false;
	}

	@Override
	public int find(E e) {
		if(isEmpty()){
			return -1;
		}
		for(int i=0;i<size;i++){
			if(data[i]==e){
				return i;
			}
		}
		return -1;
	}
	
	@Override
	public E remove(int index) {
		if(index<0||index>size-1){
			throw new ArrayIndexOutOfBoundsException("remove函数角标越界");
		}
		E e=get(index);
		for(int i=index+1;i<=size-1;i++){
			data[i-1]=data[i];
		}
		size--;
		
		//判断是否缩容
		//1.最短不能缩过默认容量
		//2.有效元素的个数小于等于容量的1/4
		if(data.length>DEFAULT_SIZE&&size<=data.length/4){
			resize(data.length/2);
		}
		return e;
	}

	@Override
	public E removeFirst() {
		return remove(0);
	}

	@Override
	public E removeLast() {
		return remove(size-1);
	}

	@Override
	public void removeElement(E e) {
		int index=find(e);
		if(index==-1){
			throw new IllegalArgumentException("删除元素不存在");
		}
		remove(index);
	}

	@Override
	public void clear() {
		size=0;
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("ArrayList: size="+size+",capacity="+data.length+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append('[');
			for(int i=0;i<size;i++){
				sb.append(data[i]);
				if(i==size-1){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		return sb.toString();
	}
	public int getCapacity(){
		return data.length;
	}
	public void swap(int i,int j){
		//i j 判断
		E temp=data[i];
		data[i]=data[j];
		data[j]=temp;
	}
	@Override
	public boolean equals(Object obj) {
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof ArrayList){
			ArrayList l=(ArrayList) obj;
			if(getSize()==l.getSize()){
				for(int i=0;i<getSize();i++){
					if(get(i)!=l.get(i)){
						return false;
					}
				}
				return true;
			}
		}
		return false;
	}
}

再写一个主函数来测试

package com.oupeng.线性表;

public class Main {
	public static void main(String[] args) {
		ArrayList<Integer> list=new ArrayList<Integer>();
		System.out.println(list);
		for(int i=1;i<=5;i++){
			list.addFirst(i);
		}
		System.out.println(list);
		for(int i=6;i<=10;i++){
			list.addLast(i);
		}
		System.out.println(list);
		list.add(5, 0);
		System.out.println(list);
		for(int i=11;i<=30;i++){
			list.addLast(i);
		}
		System.out.println(list);
		for(int i=1;i<=10;i++){
			System.out.println(list.removeFirst());
		}
		System.out.println(list);
		for(int i=1;i<=10;i++){
			System.out.println(list.removeLast());
		}
		System.out.println(list);
		list.remove(5);
		System.out.println(list);
		list.removeElement(10);
		System.out.println(list);
//		list.removeElement(15);
		for(int i=1;i<=4;i++){
			list.removeFirst();
		}
		System.out.println(list);
		for(int i=1;i<=4;i++){
			list.removeFirst();
		}
		System.out.println(list);
//		list.swap(-1, 10);
		ArrayList<Integer> list2=new ArrayList<Integer>();
		list2.addFirst(20);
		System.out.println(list2);
		System.out.println(list.equals(list2));
	}
}

以上代码就是关于一个线性表的数据结构的实现过程