玩转数据结构（一）数组

已于 2024-02-20 00:28:04 修改
阅读量219 收藏 1
点赞数 1
文章标签： 数组 数据结构
于 2019-05-25 17:54:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40086948/article/details/90549568
版权

数组

最近在网上学习数据结构，打算在这里做一下学习笔记。（本文先按课上的Java代码实现，然后再用C++语言实现一遍）

数组基础

  • 数组最大的优点：快速查询。数组与其他数据结构最大不同在于它有索引，可以方便直接访问第i个元素。
  • 数组最好应用于“索引有语意”的情况。但并非所用有语意的索引都适用于数组。故视实际情况而定。

本章课程主要是基于java的数组，二次封装属于我们自己的数组类。主要功能有：增、删、改、查。
制作属于我们自己的数组类
Java

public class Array{
	private int[] data;//使用private可保证类的封装性，使得外部无法修改
	private int size;
	//构造函数，传入数组的容量capacity构造Array
	public Array(int capacity){
		data = new int[capacity];
		size = 0;
	}
	//无参数的构造函数，默认数组容量capacity=10
	public Array(){
		this(10);
	}

	//获取数组中的元素个数
	public int getSize(){
		return size;
	}
	//获取数组的容量
	public int getCapacity(){
		return data.length;
	}

	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	｝
}

C++

class Arry{
private:
	int *data;
	int size;
	int capacity;

public:
	Array(int capacity){
		data = new int[capacity];
		size = 0;
		this->capacity = capacity; 
	}

	Array(){
		data = new int[10];
		size = 0;
		capacity = 10; 
	}

	int getSize(){
		return size;
	}
	int getCapacity(){
		return capacity;
	}

	bool isEmpty(){
		return size == 0;
	}
}

向数组中添加元素

Java

//在所有元素后面添加一个新元素
public void addLast(int e){
	//方法一：自己实现
	if(size == data.length){
		throw new IllegalArgumentException("添加失败.数组已满.");
	}
	data[size] = e;
	size++;
	
	//方法二：调用add函数
	add(size,e);
}

//在所有元素前添加一个新元素
public void addFirst(int e){
	add(0,e);
}

//在第index个位置插入一个新元素e
public void add(int index,int e){
	if(size == data.length){
		throw new IllegalArgumentException("添加失败.数组已满.");
	}
	if(index < 0 || index >size){
		//如果插入位置比size大的话会导致数组元素不连续，中间存在没插入的空格
		throw new IllegalArgumentException("添加失败.需要index >= 0，并且index <= size");
	}
	for(int i = size -1; i >= index; i--){
		data[i+1] = data[i];//将index到size之间的所有数全部往后挪一个位置
	}
	data[index] = e;
	size++;
}

C++

public:
	void addLast(int e){
		//方法一：自己实现
		if(size == capacity){
			printf("添加失败，数组已满.");
		}
		data[size] = e;
		size++;

		//方法二：调用add函数
		add(size,e);
	}
	
	void add(int index,int e){
		if(size == capacity){
			printf("添加失败，数组已满.");
		}
		if(index < 0 || index > size){
			printf("添加失败.需要index >= 0，并且index <= size");
		}
		for(int i = size-1; i >= index; i--){
			data[i + 1] = data[i];
		}
		data[index] = e;
		size++;
	}

数组中查询元素和修改元素

Java

//获取index索引位置的元素
int get(int index){
	if(index < 0 || index >= size)
		throw new IllegalArgumentException("获取失败.需要index >= 0，并且index <= size");
	return data[index];
}

//修改index索引位置的元素为e
void set(int index,int e){
	if(index < 0 || index >= size)
		throw new IllegalArgumentException("修改失败.需要index >= 0，并且index <= size");
		data[index] = e;
}

//打印函数
@Override  //覆盖覆盖父类的一个方法
public String toString(){
	StringBuilder res = new StringBuilder();
	res.append(String.format("Arrary: size = %d, capacity = %d\n",size,data.length));
	res.append('[');
	for(int i = 0; i < size; i++){
		res.append(data[i]);
		if(i  != size - 1)
			res.append(",");
	}
	res.append(']');
	return res.toString();
}

//Main.java
public class Main{
	pubilc static void main(String[] args){
		Array arr = new Array(20);
		for(int i = 0; i < 10; i++)
			arr.addLast(i);
		System.out.println(arr);//打印
	}
}

C++

public:
	int get(int index){
		if(index < 0 || index >= size)
			printf("获取失败.需要index >= 0，并且index <= size");
		return data[index];
	}

	void set(int index,int e){
		if(index < 0 || index >= size)
			printf("修改失败.需要index >= 0，并且index <= size");
			data[index] = e;
	}

	//打印数组的所有元素
	void printf(){
		std::cout<<"Array ： size = "<<size<<",capacity = "<<getCapacity()<<std::endl;
		std::cout<<"[";
		for(int i = 0; i < size; i++){
			std::cout<<data[i];
			if(i != size - 1){
				std::cout<<",";
			}
		}
		std::cout<<"]"<<endl;
	}

数组中的包含，搜索和删除元素

Java

//查找数组中是否有元素e
public boolean contains(int e){
	for(int i = 0; i <size;i++){
		if(data[i] == e)
			return true;
	}
	return false;
}

//查找数组中元素e所在的索引，如果不存在元素e，则返回-1
public int find(int e){
		for(int i = 0; i <size;i++){
			if(data[i] == e)
				return i;
	}
	return -1;
}

//从数组中删除index位置的元素，返回删除的元素
public int remove(int index){
	if(index < 0 || index >= size){
		throw new IllegalArgumentException("删除失败.index不合法.");
	}
	int ret = data[index];
	//将index后面的元素全部往前移一位
	for(int i = index +1; i < size; i++){
		data[i - 1] = data[i];
	}
	size--;
	return ret
}

//从数组中删除第一个元素，返回删除的元素
public int removeFirst(){
	return remove(0);
}

//从数组中删除最后一个元素，返回删除的元素
public int removeLast(){
	return remove(size - 1);
}

//从数组中删除元素e，若有多个元素e只删除最开头的那一个
public void removeElement(int e){
	int index = find(e);
	if(index != -1)
		remove(intdex);
}

C++

//查找数组中是否有元素e
public:
	bool contains(int e){
		for(int i = 0; i <size;i++){
			if(data[i] == e)
				return true;
		}
		return false;
	}

	int find(int e){
			for(int i = 0; i <size;i++){
				if(data[i] == e)
					return i;
		}
		return -1;
	}

	int remove(int index){
		if(index < 0 || index >= size){
			printf("删除失败.index不合法.");
		}
		int ret = data[index];
		//将index后面的元素全部往前移一位
		for(int i = index +1; i < size; i++){
			data[i - 1] = data[i];
		}
		size--;
		return ret
	}

	int removeFirst(){
		return remove(0);
	}

	int removeLast(){
		return remove(size - 1);
	}

	void removeElement(int e){
		int index = find(e);
		if(index != -1)
			remove(intdex);
	}

使用泛型

  • 让我们的数据结构可以放置“任何”数据类型
  • 不可以是基本数据类型，只能是类对象。即不能是boolean,byte,char,short,int,long,float,double
  • 每个基本数据类型都有对应的包装类，Boolean,Byte,Char, Short,Int,Long,Float,Double
    Java
public class Array<E>{
	private E[] data;//使用private可保证类的封装性，使得外部无法修改
	private int size;
	//构造函数，传入数组的容量capacity构造Array
	public Array(int capacity){
		data =(E[]) new Object[capacity];//Java不支持new一个泛型的数组
		size = 0;
	}
	//无参数的构造函数，默认数组容量capacity=10
	public Array(){
		this(10);
	}

	//获取数组中的元素个数
	public int getSize(){
		return size;
	}
	//获取数组的容量
	public int getCapacity(){
		return data.length;
	}

	//返回数组是否为空
	public boolean isEmpty(){
		return size == 0;
	｝
	
	//在所有元素后面添加一个新元素
	public void addLast(E e){
		//方法一：自己实现
		if(size == data.length){
			throw new IllegalArgumentException("添加失败.数组已满.");
		}
		data[size] = e;
		size++;
		
		//方法二：调用add函数
		add(size,e);
	}
	
	//在所有元素前添加一个新元素
	public void addFirst(E e){
		add(0,e);
	}
	
	//在第index个位置插入一个新元素e
	public void add(int index,E e){
		if(size == data.length){
			throw new IllegalArgumentException("添加失败.数组已满.");
		}
		if(index < 0 || index >size){
			//如果插入位置比size大的话会导致数组元素不连续，中间存在没插入的空格
			throw new IllegalArgumentException("添加失败.需要index >= 0，并且index <= size");
		}
		for(int i = size -1; i >= index; i--){
			data[i+1] = data[i];//将index到size之间的所有数全部往后挪一个位置
		}
		data[index] = e;
		size++;
	}

	//获取index索引位置的元素
	E get(int index){
		if(index < 0 || index >= size)
			throw new IllegalArgumentException("获取失败.需要index >= 0，并且index <= size");
		return data[index];
	}
	
	//修改index索引位置的元素为e
	void set(int index, E e){
		if(index < 0 || index >= size)
			throw new IllegalArgumentException("修改失败.需要index >= 0，并且index <= size");
			data[index] = e;
	}

	//查找数组中是否有元素e
	public boolean contains(E e){
		for(int i = 0; i <size;i++){
			if(data[i].equals(e))//两个类对象进行值的比较
				return true;
		}
		return false;
	}
	
	//查找数组中元素e所在的索引，如果不存在元素e，则返回-1
	public int find(E e){
			for(int i = 0; i <size;i++){
				if(data[i].equals(e))//两个类对象进行值的比较
					return i;
		}
		return -1;
	}
	
	//从数组中删除index位置的元素，返回删除的元素
	public E remove(int index){
		if(index < 0 || index >= size){
			throw new IllegalArgumentException("删除失败.index不合法.");
		}
		E ret = data[index];
		//将index后面的元素全部往前移一位
		for(int i = index +1; i < size; i++){
			data[i - 1] = data[i];
		}
		size--;
		data[size] = null;//loitering objects != memory leak
		return ret
	}
	
	//从数组中删除第一个元素，返回删除的元素
	public E removeFirst(){
		return remove(0);
	}
	
	//从数组中删除最后一个元素，返回删除的元素
	public E removeLast(){
		return remove(size - 1);
	}
	
	//从数组中删除元素e，若有多个元素e只删除最开头的那一个
	public void removeElement(E e){
		int index = find(e);
		if(index != -1)
			remove(intdex);
	}

		//打印函数
	@Override  //覆盖覆盖父类的一个方法
	public String toString(){
		StringBuilder res = new StringBuilder();
		res.append(String.format("Arrary: size = %d, capacity = %d\n",size,data.length));
		res.append('[');
		for(int i = 0; i < size; i++){
			res.append(data[i]);
			if(i  != size - 1)
				res.append(",");
		}
		res.append(']');
		return res.toString();
	}
}

//Main.java
public class Main{
	pubilc static void main(String[] args){
		Array<Integer> arr = new Array<>(20);
		for(int i = 0; i < 10; i++)
			arr.addLast(i);
		System.out.println(arr);//打印
	}
}

C++

//Array.h
#include <cassert>
#include <iostream>
template<class T>
class Array{
private:
	T *data;
	int size;
	int capacity;

public:
    Array(int capacity) {
        data = new T[capacity];
        size = 0;
        this->capacity = capacity;
    }

    Array() {
        data = new T[10];
        size = 0;
        capacity = 10;
    }

    int getCapacity() {
        return capacity;
    }

    int getSize() {
        return size;
    }

    bool isEmpty() {
        return size == 0;
    }

    void add(int index, T e) {
	assert(size < capacity && index >= 0 && index <= size);
        for (int i = size - 1; i >= index; --i) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    void addFirst(T e) {
        add(0, e);
    }

    void addLast(T e) {
        add(size, e);
    }

    T get(int index) {
        assert(index >= 0 && index < size);
        return data[index];
    }

    void set(int index, T e) {
        assert(index >= 0 && index < size);
        data[index] = e;
    }

    bool contains(T e) {
        for (int i = 0; i < size; ++i) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

    int find(T e) {
        for (int i = 0; i < size; ++i) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    T remove(int index) {
        assert(index >= 0 && index < size);
        T ret = data[index];
        for (int i = index + 1; i < size; ++i) {
            data[i - 1] = data[i];
        }
        size--;
        return ret;
    }

    T removeFirst() {
        return remove(0);
    }

    T removeLast() {
        return remove(size - 1);
    }

    void removeElement(T e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }
    
	//打印数组的所有元素
	void printf(){
		std::cout<<"Array ： size = "<<size<<",capacity = "<<getCapacity()<<std::endl;
		std::cout<<"[";
		for(int i = 0; i < size; i++){
			std::cout<<data[i];
			if(i != size - 1){
				std::cout<<",";
			}
		}
		std::cout<<"]"<<endl;
	}
}

动态数组

Java

//在第index个位置插入一个新元素e
public void add(int index,E e){
	if(index < 0 || index >size){
		throw new IllegalArgumentException("添加失败.需要index >= 0，并且index <= size");
	}
	if(size == data.length){
		throw new IllegalArgumentException("添加失败.数组已满.");
	}
	for(int i = size -1; i >= index; i--){
		resize(2 * data.length);//扩容两倍
	}
	data[index] = e;
	size++;
}
	
//从数组中删除index位置的元素，返回删除的元素
public E remove(int index){
	if(index < 0 || index >= size){
		throw new IllegalArgumentException("删除失败.index不合法.");
	}
	E ret = data[index];
	//将index后面的元素全部往前移一位
	for(int i = index +1; i < size; i++){
		data[i - 1] = data[i];
	}
	size--;
	data[size] = null;//loitering objects != memory leak

	//当现在使用的空间减小到总容量的一半
	if(size == data.length / 2)
		resize(data.length / 2);
	return ret;
}

private void resize(int newCapacity){
	E[] newData = (E[])new Object[newCapacity];
	for(int i = 0; i < size; i++){
		newData[i] = data[i];//将原本data里面所有元素放进newData中
	}
	data = newData;//将data指向newData空间
}

C++

public：
	void add(int index,E e){
		if(index < 0 || index >size){
			printf("添加失败.需要index >= 0，并且index <= size");
		}
		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++;
	}
	
	T remove(int index){
		if(index < 0 || index >= size){
			throw new IllegalArgumentException("删除失败.index不合法.");
		}
		T ret = data[index];
		//将index后面的元素全部往前移一位
		for(int i = index +1; i < size; i++){
			data[i - 1] = data[i];
		}
		size--;
		//当现在使用的空间减小到总容量的一半
		if(size == data.length / 2)
			resize(data.length / 2);
		return ret;
	}

private:
	void resize(int newCapacity){
		T newData = new T[newCapacity];
		for(int i = 0; i < size; i++){
			newData[i] = data[i];//将原本data里面所有元素放进newData中
		}
		data = newData;//将data指向newData空间
		capacity = newcapacity;
	}

简单的时间复杂度分析

  • O(1),O(n),O(lgn),O(nlogn),O(n^2)
  • 大O描述的是算法的运行时间和输入数据之间的关系。
  • O翻译成中文为渐进时间复杂度，描述n趋近于无穷的情况。

数组添加操作 O(n)
数组添加操作时间复杂度
数组删除操作 O(n)
数组删除操作时间复杂度
数组修改操作 O(1)
由于支持随机访问。数组修改操作时间复杂度
数组查找操作 O(1)
数组查找操作时间复杂度

均摊复杂度和防止复杂度的震荡

resize O(n)
addLast的均摊复杂度为O(1)
removeLast的均摊复杂度为O(1)

由于有可能存在刚好每次addLast一个元素，或removeLast一个元素刚好在n。会导致不停的调用resize()操作，进而导致时间复杂度为O(n)，这种问题称为复杂度震荡。
出现问题的原因：removeLast时resize过于着急。
改为size == capacity/4时，才将capacity减半。

Java

//从数组中删除index位置的元素，返回删除的元素
public E remove(int index){
	if(index < 0 || index >= size){
		throw new IllegalArgumentException("删除失败.index不合法.");
	}
	E ret = data[index];
	//将index后面的元素全部往前移一位
	for(int i = index +1; i < size; i++){
		data[i - 1] = data[i];
	}
	size--;
	data[size] = null;//loitering objects != memory leak

	//当现在使用的空间减小到总容量的四分之一时再缩容
	if(size == data.length / 4 && data.length / 2 != 0)
		resize(data.length / 2);
	return ret;
}

本文来源于慕课网上bobo老师上课内容。

老白学编程
关注
玩转数据结构
06-08 249
数组时间复杂度 将1次resize均摊给2n+1；所以每次addLast操作，进行2次基本操作；均摊时间复杂度O(1) 复杂度震荡 addLast和removeLast操作同时考虑： 在n/2时，这个临界点，扩容和缩容； 解决方案：Lazy 当数组中的数据为实际的1/4时，再进行缩容操作 data.length / 2 != 0 //当数组元素；当data.length等于1时，数组不能分配0个大小； 栈和队列 栈是一种线性结构； 只能从一端添加元素，也只..
玩转数据结构（一）玩转数据结构介绍
sinat_38368658的博客
06-26 308
为什么要学习数据结构 数据结构研究的 是数据如何在计算机中进行组织和存储，使得我们可以高效的获取数据或者修改数据。 在计算机的世界中，数据结构无处不在。 数据结构+算法=程序 课程设置 面向基础：递归，调试，复杂度分析 手把手的底层实现，创建属于自己的小型数据结构库 强调比较和优化 面向面试（前六个DS数组，栈，队列，链表，二分搜索树，堆，线段树，Trie更为重要，达到白板编...
玩转数据结构之创造自己的数组
01-20
刘宇波老师的玩转数据结构讲的非常不错，记个笔记。 学数据结构可以不用局限于语言，虽然课上使用的Java，但是同样可以使用其他任何语言来编写，这里记录Java的代码，后续会用Python重写上传github。 1. 定义一个...
【玩转数据结构】数组——使用泛型
weixin_43619860的博客
03-03 1560
【玩转数据结构】数组——使用泛型 第一章 数组的基础构造以及属性 第二章 数组的基本操作：增删改查 第三章 使用泛型——增加数组的可能性 文章目录【玩转数据结构】数组——使用泛型本章导论一、泛型的定义二、修改我们的数组，使之可以承载泛型2.1首先从构造函数开始修改2.1 获取数组的固有属性2.3 增删改查第一步——增加（Create）2.4 增删改查第二步——查找（Retrieve）2.5 增删改查第三步——修改（Update）2.6 增删改查第四步——删除（Delete）三、测试四、加入自定义类，测试
玩转数据结构.zip........
04-07
在“玩转数据结构”这个主题中，我们可以深入探讨一系列关键的数据组织方式，这些方式对于编写高效的算法至关重要。 1. **数组**：数组是最基本的数据结构，它是一个相同类型元素的有序集合。在数组中，可以通过索...
玩转数据结构 从入门到进阶
10-24
《玩转数据结构 从入门到进阶》这本书旨在为读者提供一个系统学习数据结构的途径，涵盖了从基础知识到高级应用的多个方面。 #### 二、数据结构基础知识 ##### 2.1 数组 数组是最基本的数据结构之一，它通过索引来...
玩转数据结构(01)--数组
姜皓的博客
07-25 1901
一、数据结构分类： 1.线性结构：数组、栈、队列、链表、哈希表... 2.树结构：二叉树、二分搜索树、AVL、红黑树、Treap、Splay、堆、Trie、线段树、K-D树、并查集、哈夫曼树... 3.图结构：邻接矩阵、邻接表 二、数组 1.定义：把数据码成一排进行存放 2.图解： 3.示例代码 Main.java public class Main { publ...
波波老师的数据结构课程的C++代码实现
01-02
波波老师的数据结构课程的C++代码实现，和波波老师的代码库目录一样：
【玩转数据结构Part1】数组/栈/队列/链表
aaon22357的博客
07-07 394
来自于慕课网上的教学课程《玩转数据结构》笔记 https://coding.imooc.com/class/71.html，该视频一共讲解了十二个数据结构。包括： 数组 栈 队列 链表 二分搜索树 堆 线段树 Trie 并查集 AVL 红黑树 哈希表 本课程不包含图结构，因为图论领域以算法为主。 面试常考的：前六个数据结构（要做到白板编程的水平） 面向竞赛：7，8，9 最后三个：面试常考，但由...
玩转数据结构从入门到进阶（四 集合set与映射map堆与优先队列，线段树：）
sinat_36748650的博客
04-16 526
项目源码：https://gitee.com/renqiqi/shujvjiegou 层序遍历：广度优先遍历 使用非递归方式实现。更快的找到想要的元素，主要应用于搜索。 删除任意节点：删除节点后，找到该节点的右子树中最小值，让他顶替该节点的位置，并在原来的位置上删除这个最 小值 用链表来实现set集合复杂度是O(n)，而用二分搜索树来实现Set，复杂度是O（logn）：其实是O(h)，h就是树的高...
玩转数据结构——均摊复杂度和防止复杂度的震荡（笔记）
believe_s的博客
06-22 1706
数据规模 时间复杂度 并不是所有的双层循环都是O（n^2）的 复杂度实验来确定复杂度 // O(N) 两倍增加 int findMax( int arr[], int n ){ assert( n &amp;gt; 0 ); int res = arr[0]; for( int i = 1 ; i &amp;lt; n ; i ++ ) ...
玩转数据结构从入门到进阶笔记（二 链表）
sinat_36748650的博客
04-16 503
链表Linked List： 上一篇中的动态数组，栈和两种队列底层依然依托于静态数组，其中动态是对于该数据结构的使用者来说的，依靠 resize方法解决动态扩容和缩容的问题。而链表是真正的动态数据结构，同时也是最简单的数据结构，是其他复杂数 据结构的基础。 它的数据储存在节点中，称之为Node，Node中储存了一个保存的数据和指向下一个节点的Node类型的引用next。下一 个节点没有数据则指向n...
掌握这些，玩转数据结构！
最新发布
ylx的博客
12-14 1280
本文纯手撸总结数据结构（线性表、队列、栈、树、图、排序）所有必须掌握知识附代码！可供初学者学习使用，考研人、保研人复习使用。加油吧！
玩转数据结构——第一章：数组
犟驴的博客
09-24 384
内容大纲： 使用Java中的数组 二次封装属于我们自己的数组 向数组中添加元素 数组中查询元素和修改元素 包含，搜索，删除功能 使用泛型 动态数组 简单的时间复杂度分析 均摊复杂度和防止复杂度振荡 一、java中的数组 把数据码成一排进行存放 java中一个简单的数组使用 public class Main { public static void main(...
玩转数据结构代码
独孤小标的博客
06-18 368
首先，这里只有代码，没有任何的讲解过程，因为自己本身也只是个新手，在探索的过程，在学习教程<玩转数据结构>后，根据视频和思路来手敲的代码，具体的工程在github上 github代码地址，后面会给上每个小数据结构实现的代码，这里的代码只是自己记录，方便以后忘了可以快速找到。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值