首页 / JAVA / 【数据结构】Java 实现单向链表
【数据结构】Java 实现单向链表
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了【数据结构】Java 实现单向链表，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5887字，纯文字阅读大概需要9分钟。
内容图文
单向链表
java实现泛型单向链表
List.java 接口
public interface List<E> {
static final int ELEMENT_NOT_FOUND = -1;
/**
* 清除所有元素
*/
void clear();
/**
* 元素的数量
* @return
*/
int size();
/**
* 是否为空
* @return
*/
boolean isEmpty();
/**
* 是否包含某个元素
* @param element
* @return
*/
boolean contains(E element);
/**
* 添加元素到尾部
* @param element
*/
void add(E element);
/**
* 获取index位置的元素
* @param index
* @return
*/
E get(int index);
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素?
*/
E set(int index, E element);
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
void add(int index, E element);
/**
* 删除index位置的元素
* @param index
* @return
*/
E remove(int index);
/**
* 查看元素的索引
* @param element
* @return
*/
int indexOf(E element);
}
AbstractList.java
public abstract class AbstractList<E> implements List<E>{
protected int size;
// 下标越界抛出的异常
protected void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
protected void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加元素)
protected void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public void add(E element) {
add(size, element);
}
}
LinkedList.java
import java.awt.font.NumericShaper.Range;
/**
* 有缩容功能的动态数组
* @author yusael
*
* @param <E>
*/
@SuppressWarnings("unchecked")
public class ArrayList2<E> extends AbstractList<E>{
private E[] elements; // 所有的元素
private static final int DEFAULT_CAPACITY = 10; // 初始容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList2(int capacity) { // 容量小于10一律扩充为10
capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
elements = (E[])new Object[capacity];
}
public ArrayList2(){
this(DEFAULT_CAPACITY);
}
/****************↓封装好的功能函数，遇到再读*******************/
// // 下标越界抛出的异常
// private void outOfBounds(int index) {
// throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
// }
// // 检查下标越界(不可访问或删除size位置)
// private void rangeCheck(int index){
// if(index < 0 || index >= size){
// outOfBounds(index);
// }
// }
// // 检查add()的下标越界(可以在size位置添加元素)
// private void rangeCheckForAdd(int index) {
// if (index < 0 || index > size) {
// outOfBounds(index);
// }
// }
// 扩容
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
if(oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[])new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i]; // 拷贝原数组元素到新数组
}
elements = newElements;
System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
}
// 缩容
private void trim(){
int oldCapacity = elements.length;
int newCapacity = oldCapacity >> 1; // 缩容为一半
if(size > newCapacity || newCapacity <= DEFAULT_CAPACITY) return;
// 剩余空间很多
E[] newElements = (E[]) new Object[newCapacity];
for(int i = 0; i < size; i++){
newElements[i] = elements[i];
}
elements = newElements;
System.out.println("size=" + size + ", 从" + oldCapacity + "缩容为" + newCapacity);
}
/****************↑封装好的功能函数，遇到再读*******************/
/**
* 元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(E element){
return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element){
rangeCheckForAdd(index); // 检查下标越界
ensureCapacity(size + 1); // 确保容量够大
// 0 1 2 3 4 5 6 7 8 9 (index)
// 1 2 3 4 5 6 x x x x (原数组)
// 在index=2处，插入9，元素全部后移
// 1 2 9 3 4 5 6 x x x (add后数组)
for (int i = size-1; i > index; i--) {
elements[i+1] = elements[i];
}
elements[index] = element;
size++;
}
// /*
// * 添加元素到最后面
// */
// public void add(E element){
// add(size, element);
// }
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素?
*/
public E get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素?
*/
public E set(int index, E element){
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 删除index位置的元素
* @param index
* @return
*/
public E remove(int index){
rangeCheck(index);
// 0 1 2 3 4 5 (index)
// 1 2 3 4 5 6 (原数组)
// 删除index为2的元素，元素前移
// 1 2 4 5 6 (remove后的数组)
E old = elements[index];
for (int i = index; i < size-1; i++) {
elements[i] = elements[i+1];
}
elements[--size] = null; // 删除元素后,将最后一位设置为null
trim(); // 数组缩容
return old;
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(E element){
/*
// 不对 null 进行处理也可以，但是健壮性不够
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
*/
if(element == null){ // 对 null 进行处理
for (int i = 0; i < size; i++) {
if(elements[i] == null) return i;
}
}else{
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
// 使用泛型数组后要注意内存管理
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
@Override
public String toString() {
// 打印形式为: size=5, [99, 88, 77, 66, 55]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if(0 != i) string.append(", ");
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
内容总结
以上是互联网集市为您收集整理的【数据结构】Java 实现单向链表全部内容，希望文章能够帮你解决【数据结构】Java 实现单向链表所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】