自定义容器

于 2022-08-05 16:08:34 发布
阅读量127 收藏
点赞数
分类专栏： javase 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youraiai/article/details/126177673
版权

1.自定义栈

栈（Stack）是一种受限的线性数据结构，所谓受限是指栈只暴露栈顶和栈底的操作，其底层是由数组实现的。栈的特性是先进后出

在这里插入图片描述
用数组定义：

public class Stack {

	private Object[] data;
	private int size;
	private int capacity;
	
	public Stack() {
		// 默认创建一个10容量的栈
		this.capacity = 10;
		data = new Object[this.capacity];
	}
	
	public Stack(int capacity) {
		this.capacity = capacity;
		data = new Object[this.capacity];
	}
	
	//进栈一个元素
	public void push(Object e){
		// 先判断栈是否已经满了
		if (this.isFull()) {
			// 扩容
			// 扩容的规则是原有容量的1.5倍
			int length = this.capacity + (this.capacity >>> 1);
			this.resize(length);
		} else {
			this.data[size++] = e;
		}
	}		
	
	// 判断是否存满
	private boolean isFull() {
		return this.capacity == this.size;
	}
	
	// 扩容或缩容容器的大小
	private void resize(int len){
//		Object[] arr = new Object[len];
//		for (int i = 0; i < data.length; i++) {
//			arr[i] = data[i];
//		}
//		this.data = arr;
		this.data = Arrays.copyOf(this.data, len);
		this.capacity = len;
	}	
	
	// 判断栈是否为空
	public boolean isEmpty(){
		return this.size == 0;
	}			
	
	// 出栈一个元素
	public Object pop(){
		if (this.isEmpty()) {
			throw new RuntimeException("栈中已经没有元素了");
		}
		return this.data[--this.size];
	}	
	
	// 查看栈顶元素
	public Object peek(){
		return this.data[this.size - 1];
	}					
	
	// 获取栈中元素的个数
	public int size(){
		return this.size;
	}					
	
	// 清空栈
	public void clear(){
		this.size = 0;
	}
	
	// 返回栈的字符串形式
	public String toString(){
		return Arrays.toString(Arrays.copyOf(this.data, this.size));
	}	
	
	// 对比两个栈是否相等
	@Override
	public boolean equals(Object o)	{
		Stack s = (Stack) o;
		if (this.size != s.size()) {
			return false;
		}
		for (int i = 0; i < s.size() ; i++) {
			if (data[i] != s.data[i]) {
				return false;
			}
		}
		return true;
	}
}

2.自定义队列：

1.队列是一种由数组和链表作为底层构造的只暴露头和尾操作API的数据结构
2.特点：先进先出

在这里插入图片描述
通过数组实现：

public class Queue {

	private Object[] data;
	private int size;
	private int capacity;
	
	public Queue() {
		// 默认创建一个10容量的队列
		this.capacity = 10;
		data = new Object[this.capacity];
	}
	
	public Queue(int capacity) {
		this.capacity = capacity;
		data = new Object[this.capacity];
	}
	
	//进队一个元素
	public void push(Object e){
		// 先判断队列是否已经满了
		if (this.isFull()) {
			// 扩容
			// 扩容的规则是原有容量的1.5倍
			int length = this.capacity + (this.capacity >>> 1);
			this.resize(length);
		} else {
			this.data[size++] = e;
		}
	}		
	
	// 判断是否存满
	private boolean isFull() {
		return this.capacity == this.size;
	}
	
	// 扩容或缩容容器的大小
	private void resize(int len){
		this.data = Arrays.copyOf(this.data, len);
		this.capacity = len;
	}	
	
	// 判断队列是否为空
	public boolean isEmpty(){
		return this.size == 0;
	}			
	
	// 出队列一个元素
	public Object pop(){
		if (this.isEmpty()) {
			throw new RuntimeException("队列中已经没有元素了");
		}
		this.size--;
		Object temp = this.data[0];
		System.arraycopy(data, 1, this.data, 0, data.length - 1);
		return temp;
	}	
	
	// 查看队列顶元素
	public Object peek(){
		return this.data[this.size - 1];
	}					
	
	// 获取队列中元素的个数
	public int size(){
		return this.size;
	}					
	
	// 清空队列
	public void clear(){
		this.size = 0;
	}
	
	// 返回队列的字符串形式
	public String toString(){
		return Arrays.toString(Arrays.copyOf(this.data, this.size));
	}	
	
	// 对比两个队列是否相等
	@Override
	public boolean equals(Object o)	{
		Queue s = (Queue) o;
		if (this.size != s.size()) {
			return false;
		}
		for (int i = 0; i < s.size() ; i++) {
			if (data[i] != s.data[i]) {
				return false;
			}
		}
		return true;
	}
}

通过Stack实现：

public class Queue2 {
	
	private Stack stackA;					
	private Stack stackB;		

	public Queue2() {
		stackA = new Stack();
		stackB = new Stack();
	}
	
	// 进队一个元素
	public void offer(Object e){
		this.stackA.push(e);
	}	
	
	// 出队一个元素
	public Object poll(){
		remove();
		return stackB.pop();
	}

	private void remove() {
		if (this.stackB.size() == 0) {
			while (this.stackA.size() != 0) {
				this.stackB.push(this.stackA.pop());
			}
		}
	}	
	
	// 查看队首元素
	public Object element(){
		if (this.stackB.size() != 0) {
			return this.stackB.peek();
		} else {
			remove();
		}
		return this.stackB.peek();
	}		
	
	// 获取队列中元素的个数
	public int size(){
		remove();
		return this.stackB.size();
	}		
	
	// 判断队列是否为空
	public boolean isEmpty(){
		return this.stackB.size() == 0 && this.stackA.size() == 0;
	}
	
	// 清空队列
	public void clear(){
		this.stackA.clear();
		this.stackB.clear();
	}	
	
	// 返回队列的字符串形式
	public String toString(){
		return "展示B中的值";
	}
	
	public boolean equals(Object o) {
		return true;
	}
	
}```


3.自定义ArrayList：
	数组定义：
	
```java
public class ArrayList {
	
	private Object[] objs;
	private int size;
	private int capacity;
	
	public ArrayList() {
		this.capacity = 10;
		this.objs = new Object[this.capacity];
	}
	
	public ArrayList(int capacity) {
		this.capacity = capacity;
		this.objs = new Object[this.capacity];
	}
	
	public void add(Object obj) {
		if (this.isFull()) {
			// 扩容
			this.grow();
		}
		this.objs[size++] = obj;
	}

	private void grow() {
		// 1.5 倍
		int newCapaCity = this.capacity + (this.capacity >>> 1);
		System.out.println("扩容开始，容量由"+ this.capacity +"变为："+ newCapaCity);
		this.objs = Arrays.copyOf(this.objs, newCapaCity);
		this.capacity = newCapaCity;
		System.out.println("扩容成功");
	}

	private boolean isFull() {
		return this.size == this.capacity;
	}
	
	public void add(int index, Object obj) {
		if (this.isFull()) {
			this.grow();
		}
		for (int i = size; i > index ; i--) {
			this.objs[i] = this.objs[i - 1];
		}
		this.objs[index] = obj;
		this.size++;
	}

	public void remove(int index) {
		for (int i = index; i < this.size - 1; i++) {
			this.objs[index] = this.objs[index+1];
		}
		this.size--;
	}

	public void remove(Object obj) {
		int m=0;
		for(int i=0;i<this.size-1;i++){
			if(this.objs[i]==obj){
				m=i;
			}
		}
		for (int i = m; i < this.size - 1; i++) {
			this.objs[m] = this.objs[m+1];
		}
		this.size--;
	}
	
	public void update(int index, Object obj) {
		this.objs[index] = obj;
	}

	public Object load(Object Object) {
		
		return null;
	}

	public Object get(int index) {
		if (index < size) {
			return null;
		}
		return this.objs[index];
	}

	public Object[] list() {
		return Arrays.copyOf(this.objs, size);
	}

	public void clear() {
		this.size = 0;
	}

	public String toString() {
		return "ObjectMangerImpl [objs=" + Arrays.toString(objs) + ", size=" + size + ", capacity=" + capacity + "]";
	}
	
	public int size() {
		return this.size;
	}
	
}

4.自定义链表：

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。

class Node {
		Node prev;
		Node next;
		Object value;
		
		public Node() {
		}

		public Node(Node prev, Object value, Node next) {
			this.prev = prev;
			this.next = next;
			this.value = value;
		}
	}

5.自定义LinkedList
数组定义：


public class LinkedList {
	
	private Node first;
	private Node last;
	private int size;
	
	public LinkedList() {
	}
	//插入元素
	public void add(Object obj) {
		// 向尾部添加一个新的节点
		Node newNode = new Node();
		newNode.value = obj;
		// 判断是否是第一次添加
		if (first == null) {
			this.first = newNode;
			this.last = newNode;
		} else {
			newNode.prev = last;
			last.next = newNode;
			last = newNode;
		}
		this.size++;
	}
	//按照下标查找
	public Object get(int index) {
		if (index >= this.size || index < 0) {
			throw new RuntimeException("不存在这个下标");
		}
		Node temp = first;
		for (int i = 0; i < index; i++) {
			temp = temp.next;
		}
		return temp.value;
	}
	
	//按元素查找
    public Node getNodeByEle(Object ele) {
        Node currentNode = first;
        while (currentNode != null) {
            if (ele.equals(currentNode.ele)) {
                return currentNode;
            }
            currentNode = currentNode.next;
        }
        return null;
    }

  // 删除第一个节点
    public void removeFirst() {
        if (size == 0) {
            throw new IllegalArgumentException("链表中没有节点，无法删除");
        }
        first.ele = null;
        first = first.next;
        first.prev = null;
        size--;
    }

    // 删除最后一个节点
    public void removeLast() {
        if (size == 0) {
            throw new IllegalArgumentException("链表中没有节点，无法删除");
        }
        last.ele = null;
        last = last.prev;
        last.next = null;
        size--;
    }

    // 删除非头尾节点元素，
    public void removeInside(Node node) {
        node.ele = null;
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }
    
// 删除节点
    public  void removeNode(Node node) {
        if (node == first) {
            removeFirst();
        } else if (node == last) {
            removeLast();
        } else {
            removeInside(node);
        }
    }

    // 根据元素删除节点
    public void removeNodeByEle(Object ele) {
        Node node = getNodeByEle(ele); // 先查询该节点是否存在
        if (node == null) {
            throw new IllegalArgumentException("不存在该节点信息，无法删除");
        }
        removeNode(node);
    }

    // 根据索引删除节点
    public void removeNodeByIndex(int index) {
        Node node = getNodeByIndex(index); // 先查询该节点是否存在
        if (node == null) {
            throw new IllegalArgumentException("不存在该节点信息，无法删除");
        }
        removeNode(node);
    }

 // 获取链表长度
    public int getLength() {
        return size;
    }
    
public String toString() {
		return "ObjectMangerImpl [objs=" + Arrays.toString(objs) + ", size=" + size + ", capacity=" + capacity + "]";
	}
youraiai
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c# winform 自定义折叠容器
03-23
c# winform 自定义折叠容器。有慢动画效果。
利用servlet监听器，系统启动时创建自定义容器简单例子
06-01
NULL 博文链接：https://ruyi574812039.iteye.com/blog/2113545
Custom Container View Controller
一滴清水
07-29 842
转自Luke的博客 什么是Container View Controller?苹果文档是这么描述的:  A container view controller contains content owned by other view controllers.   也就是说一个View Controller显示的某部分内容属于另一个View Contr
Docker自定义容器镜像.docx
06-19
——学习参考资料：仅用于个人学习使用！ 本代码仅作学习交流，切勿用于商业用途，否则后果自负。若涉及侵权，请联系，会尽快处理! 未进行详尽测试，请自行调试!
jquery 自定义容器下雨效果可将下雨图标改为其他
10-26
主要介绍了jquery 自定义容器下雨效果可将下雨图标改为其他,需要的朋友可以参考下
java之自定义容器
weixin_45433052的博客
07-26 611
基于数组方式 public class IntArray { Object[] data; int size; IntArray(int length){ //自定义储存大小 data=new Object[length]; } IntArray(){ //调用有参的构造方法，默认储存大小 this(5); } //添加元素 public...
自定义列表容器
陈嘉怡的专栏
12-31 1288
一个自定义的列表容器。自己定义的列表主要是效率上稍微好些，不像stl那样的调用，有较多的封装。 其实功能跟stl::vector类似，封装更为简单，不使用迭代器 因为数组不需要使用，只要取出数据指针就可以直接使用了,所以重载了下操作符 inline operator T* () const { return m_pData; } ，这样可以直接直接取出使用  类似CBList list;myc
实现自定义容器类型
Jeffrey_bird的博客
01-01 242
想要实现一个自定义类，该类模仿普通的内置容器类型（例如list或dict）的行为。 但是，不确定要实现哪种方法。 collections.abc模块定义了各种抽象基类，这些基类在实现自定义容器类时非常有用。自定义类一般通过继承该模块的对应基类，然后实现所需要的类方法。如下： from collections.abc import Iterable class A(Iterable): ...
自定义通用容器
qq_43686329的博客
09-27 106
自定义通用容器 标签（空格分隔）： STL 类模板 一、需求分析 自定义实现一个通用的容器，能够支持插入多种不同的普通类型（包含 int char float double 等)和自定义结构体和自定义类的对象，并能根据每种不同类型的比较规则从容器中取得最大或最小的那个值或对象。 二、具体实现 借助STL现有的容器set,其底层结构为红黑树，里面的元素根据键值有序排列，默认的函数对象为less，也可以自定义仿函数，重载（）运算符即可。 代码如下： #ifndef _SIZEFILTER #define _S
自定义组件开发七 自定义容器
编程之美
06-19 589
概述 自定义容器本质上也是一个组件，常见的 LinearLayout、FrameLayout、GridLayout、ScrollView和 RelativeLayout 等等组件都是容器，容器除了有自己的外观，还能用来容纳各种组件，以一种特定的规则规定组件应该在什么位置、显示多大。 一般情况下，我们更关注自定义组件的外观及功能，但自定义容器则更关注其内的组件怎么排列和摆放，比如线性布局 Lin...
Element简单的容器布局
weixin_46981685的博客
05-26 568
Element简单的容器布局 <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <!-- import CSS --> <link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css"> <style> .el-head
如何自定义容器网络？- 每天5分钟玩转 Docker 容器技术（33）
weixin_34179968的博客
06-26 124
除了 none, host, bridge 这三个自动创建的网络，用户也可以根据业务需要创建 user-defined 网络。 Docker 提供三种 user-defined 网络驱动：bridge, overlay 和 macvlan。overlay 和 macvlan 用于创建跨主机的网络，我们后面有章节单独讨论。 我们可通过 bridge 驱动创建类似前面默认的 ...
c++自定义的容器实现
weixin_43293737的博客
01-29 3077
通常我们使用的int、char等数据类型可以创建数组去容纳数据，其实我们自定义的类也能够像基础类型一样去创建容器容纳各种数据。包括基础数据类型、自定义的类对象、以及对象指针等等数据 创建类对象的头文件 #pragma once #include "iostream" using namespace std; template &lt;typename T&gt;//泛型编程，可以使类存储任意形...
C++11 为自定义容器实现标准的forward迭代器
10km的专栏
11-21 4149
当前我的一个项目是基于C++11为基础开发的，在项目中需要用到哈希表来保持数据，C++11本身已经提供了丰富的容器类型(array,list,hashmap….vector)，但因为项目的特殊需要不能使用C++11现成的unordered_map容器。无奈所以我只能自己根据项目需要写了一个哈希表的模板类–HashTableAbstract–也就是自定义容器。 然后问题了，为了让这个自定义的容器也能
winform 自定义控件 容器
最新发布
01-01
Winform自定义控件容器可以通过继承自Control或者ContainerControl类来实现。以下是一个示例： ```csharp using System; using System.Windows.Forms; public class MyCustomControl : Control { public ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值