手写LinkList和arrayList

置顶从码农到码到成功

已于 2022-11-02 20:26:52 修改

阅读量279

点赞数 1

分类专栏： JAVA 文章标签：链表数据结构 java

于 2019-04-06 15:14:05 首次发布

本文链接：https://blog.csdn.net/weixin_39519454/article/details/89056040

版权

JAVA 专栏收录该内容

32 篇文章 2 订阅

订阅专栏

1、自己写的LinkList和arrayList。

2、基本数据结构：链表（list）

为了加深理解，我就自己写了下LinkList和arrayList。

下面贴下代码

链表代码


链表代码

	public class MyTwoLinkedList<AnyType> implements Iterable<AnyType> {
	private int theSize;
	private int modCount = 0;
	private Node<AnyType> beginMarker;
	private Node<AnyType> endMarker;

	private static class Node<AnyType> {
		public AnyType data;
		public Node<AnyType> prev;
		public Node<AnyType> next;

		public Node(AnyType d, Node<AnyType> p, Node<AnyType> n) {
			data = d;
			prev = p;
			next = n;
		}
	}

	public MyTwoLinkedList() {
		clear();
	}

	public void clear() {
		beginMarker = new Node<AnyType>(null, null, null);
		endMarker = new Node<AnyType>(null, beginMarker, null);
		beginMarker.next = endMarker;

		theSize = 0;
		modCount++;
	}

	public int size() {
		return theSize;
	}

	public Boolean add(AnyType x) {
		add(size(), x);
		return true;
	}

	public void add(int idx, AnyType x) {
		addBefore(getNode(idx), x);
	}

	//搜索节点，先判断节点在前半段还是后半段，略提高效率，双链表可以从两个方向查找
	private Node<AnyType> getNode(int idx) {
		Node<AnyType> p;//一个引用

		if (idx < 0 || idx > size())
			throw new IndexOutOfBoundsException();
		if (idx < size() / 2) {
			p = beginMarker.next;
			for (int i = 0; i < idx; i++)
				p = p.next;
		} else {
			p = endMarker;
			for (int i = size(); i > idx; i--)
				p = p.prev;
		}
		return p;
	}

	private void addBefore(Node<AnyType> p, AnyType x) {
		Node<AnyType> newNode = new Node<AnyType>(x, p.prev, p);//双链表，新增节点插入指向前后
		//前后两个节点的指向变化
		newNode.prev.next = newNode;
		p.prev = newNode;
		theSize++;
		//修改次数+1
		modCount++;
	}

	public AnyType get(int idx) {
		return getNode(idx).data;
	}

	public AnyType set(int idx, AnyType newVal) {
		//一个引用，改变节点值
		Node<AnyType> p = getNode(idx);
		AnyType oldVal = p.data;
		p.data = newVal;
		return oldVal;
	}

	public AnyType remove(int idx) {
		return remove(getNode(idx));
	}

	private AnyType remove(Node<AnyType> p) {
		p.next.prev = p.prev;
		p.prev.next = p.next;
		theSize--;
		//修改次数仍+1
		modCount++;
		return p.data;
	}


	public java.util.Iterator<AnyType> iterator() {
		//返回一个实例化的内部类，该类是迭代器，内部实现
		return new MyTwoLinkedList.LinkedListIterator();
	}

	//实现Iterator接口
	private class LinkedListIterator implements java.util.Iterator<AnyType> {
		//在内部指向第一个元素
		private Node<AnyType> current = beginMarker.next;

		//检测在迭代期间集合被修改的情况，分别在next()和迭代器自己的remove()中检查，如果修改次数不同说明在迭代器迭代之外发生了修改行为
		//迭代器自己的remove()调用外层类的remove,其中有modCount++,迭代器做出remove()动作后将expectecModCount++,保证迭代期间二者保持一致
		private int expectedModCount = modCount;

		//okToRemove在next()执行后被置为true,在迭代器自己的remove()执行完后置为false,迭代器自己的remove()执行前检查其是否为true才执行，保证迭代一次才能删除一个，没有其他迭代时删除的方式
		private boolean okToRemove = false;

		public boolean hasNext() {
			return current != endMarker;
		}

		public AnyType next() {
			if (modCount != expectedModCount)
				//同一时间修改冲突异常！！
				throw new java.util.ConcurrentModificationException();
			if (!hasNext())
				throw new java.util.NoSuchElementException();
			//用一个引用指向并从外部类获取前一个元素数据
			AnyType nextItem = current.data;
			//实际是改变一个引用的指向使其前进
			current = current.next;
			okToRemove = true;
			return nextItem;
		}

		public void remove() {
			if (modCount != expectedModCount)
				throw new java.util.ConcurrentModificationException();
			//不是迭代期间调用此迭代器remove()方法
			if (!okToRemove)
				throw new IllegalStateException();
			//调用外部类方法
			//next()使current先指向下一元素，这里移除current前一个元素，这样边迭代边移除，先后移后删除前一个元素


			MyTwoLinkedList.this.remove(current.prev);
			okToRemove = false;
			expectedModCount++;
		}
	}
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151

双链表头尾放置两个值为null的Node对象，这样使头尾节点的处理也正常化，不会是删除头尾元素成为特别的情况存在。双链表还有就是每个节点存储上下两个节点的信息。删除的开销，在链表来，只是修改删除元素首尾节点的指向而已。而且由于是双链表可以从两端开始遍历，这样，用getNode方法，确认元素是在哪个半段。这样能用最快的速度来遍历。后面的迭代器实现，主要是用modcount参数，来保证链表的一致性的。

ArrayList代码

ArrayList代码

	public class MyTestArrayList<AnyType> implements Iterable<AnyType> {
	//

	//默认容器
	private static final int DEFAULT_CAPACITY = 10;

	private int theSize;
	private AnyType[] theItems;

	public MyTestArrayList() {
		clear();
	}

	public void clear() {
		theSize = 0;
		ensureCapacity(DEFAULT_CAPACITY);
	}

	public void ensureCapacity(int newCapacity) {
		if (newCapacity < theSize) {
			return;
		}
		AnyType[] old = theItems;
		theItems = (AnyType[]) new Object[newCapacity];
		for (int i = 0; i < size(); i++) {
			theItems[i] = old[i];
		}

	}

	public Boolean add(AnyType x) {
		add(size(), x);
		return true;
	}

	public void add(int idx, AnyType x) {
		if (idx > size()) {
			throw new IndexOutOfBoundsException("Index:" + idx + " Size :" + size());
		}
		if (theItems.length == size())
			ensureCapacity(size() * 2);
		for (int i = theSize; i > idx; i--)
			theItems[i] = theItems[i - 1];
		theItems[idx] = x;
		theSize++;
	}

	public AnyType get(int idx) {
		if (idx < 0 || idx > size())
			throw new ArrayIndexOutOfBoundsException();
		return theItems[idx];
	}

	public AnyType set(int idx, AnyType x) {
		if (idx < 0 || idx > size())
			throw new ArrayIndexOutOfBoundsException();
		AnyType oldValue = theItems[idx];
		theItems[idx] = x;
		return oldValue;
	}

	public Boolean isEmpty() {
		return size() == 0;
	}

	public int size() {
		return theSize;
	}

	public AnyType remove(int idx) {
		AnyType deleteItem = theItems[idx];
		for (int i = idx; i < size() - 1; i++) {
			theItems[i] = theItems[i + 1];
		}
		// theSize--;
		theItems[--theSize] = null;
		return deleteItem;
	}

	public java.util.Iterator<AnyType> iterator(){
		return new ArrayListIterator();
	}

	public class ArrayListIterator implements java.util.Iterator<AnyType> {
		private int current = 0;

		public boolean hasNext() {
			return current < size();
		}

		public AnyType next(){
			if(!hasNext())
				throw new java.util.NoSuchElementException();

			return theItems[current++];
		}

		public void remove(){
			//MyArraList.this代表外层类MyArrayList的对象
			//--current这里暂解释为remove在next方法后调用，next让current++,
			//这里让current回到原来位置，删除它
			//因为如果不调用next直接remove,current会出现<0情况
			MyTestArrayList.this.remove(--current);
		}
	}

}

数组相较于上面的链表感觉删除就比较坑了，毕竟不知道要删除哪个元素。如果删除头元素，那么整个数组都要进行一次循环赋值，很坑的。其他的两者基本上都有点类似了。

基本数据结构：链表（list）

作者：C小加更新时间：2012-7-31

谈到链表之前，先说一下线性表。线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表有两种存储方式，一种是顺序存储结构，另一种是链式存储结构。

顺序存储结构就是两个相邻的元素在内存中也是相邻的。这种存储方式的优点是查询的时间复杂度为O(1)，通过首地址和偏移量就可以直接访问到某元素，关于查找的适配算法很多，最快可以达到O(logn)。缺点是插入和删除的时间复杂度最坏能达到O(n)，如果你在第一个位置插入一个元素，你需要把数组的每一个元素向后移动一位，如果你在第一个位置删除一个元素，你需要把数组的每一个元素向前移动一位。还有一个缺点，就是当你不确定元素的数量时，你开的数组必须保证能够放下元素最大数量，遗憾的是如果实际数量比最大数量少很多时，你开的数组没有用到的内存就只能浪费掉了。

我们常用的数组就是一种典型的顺序存储结构，如图1。

链式存储结构就是两个相邻的元素在内存中可能不是相邻的，每一个元素都有一个指针域，指针域一般是存储着到下一个元素的指针。这种存储方式的优点是插入和删除的时间复杂度为O(1)，不会浪费太多内存，添加元素的时候才会申请内存，删除元素会释放内存，。缺点是访问的时间复杂度最坏为O(n)，关于查找的算法很少，一般只能遍历，这样时间复杂度也是线性（O(n)）的了,频繁的申请和释放内存也会消耗时间。

顺序表的特性是随机读取，也就是访问一个元素的时间复杂度是O(1)，链式表的特性是插入和删除的时间复杂度为O(1)。要根据实际情况去选取适合自己的存储结构。

链表就是链式存储的线性表。根据指针域的不同，链表分为单向链表、双向链表、循环链表等等。

一、单向链表（slist）

链表中最简单的一种是单向链表，每个元素包含两个域，值域和指针域，我们把这样的元素称之为节点。每个节点的指针域内有一个指针，指向下一个节点，而最后一个节点则指向一个空值。如图2就是一个单向链表。

一个单向链表的节点被分成两个部分。第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历。

我写了一个简单的C++版单向链表类模板，就用这段代码讲解一下一个具体的单向链表该怎么写（代码仅供学习），当然首先你要具备C++基础知识和简单的模板元编程。

完整代码

首先我们要写一个节点类，链表中的每一个节点就是一个节点类的对象。如图3。

代码如下：

template<class T> class slistNode{
	public:
	slistNode(){next=NULL;}//初始化
	T data;//值
	slistNode* next;//指向下一个节点的指针
};

第二步，写单链表类的声明，包括属性和方法。

代码如下：

template<class T>
class myslist
{
    private:
    unsigned int listlength;
    slistNode<T>* node;//临时节点
    slistNode<T>* lastnode;//头结点
    slistNode<T>* headnode;//尾节点
    public:
        myslist();//初始化
        unsigned int length();//链表元素的个数
        void add(T x);//表尾添加元素
        void traversal();//遍历整个链表并打印
        bool isEmpty();//判断链表是否为空
        slistNode<T>* find(T x);//查找第一个值为x的节点,返回节点的地址,找不到返回NULL
        void Delete(T x);//删除第一个值为x的节点
        void insert(T x,slistNode<T>* p);//在p节点后插入值为x的节点
        void insertHead(T x);//在链表的头部插入节点
};

第三步，写构造函数，初始化链表类的属性。

代码如下：

template<class T>
myslist<T>::myslist()
{
    node=NULL;
    lastnode=NULL;
    headnode=NULL;
    listlength=0;
}

第四步，实现add()方法。

代码如下：

template<class T>
void  myslist<T>::add(T x)
{
    node=new slistNode<T>();//申请一个新的节点
    node->data=x;//新节点赋值为x
    if(lastnode==NULL)//如果没有尾节点则链表为空,node既为头结点,又是尾节点
    {
        headnode=node;
        lastnode=node;
    }
    else//如果链表非空
    {
        lastnode->next=node;//node既为尾节点的下一个节点
        lastnode=node;//node变成了尾节点,把尾节点赋值为node
    }
    ++listlength;//元素个数+1
}

第五步，实现traversal()函数，遍历并输出节点信息。

代码如下：

template<class T>
void  myslist<T>::traversal()
{
    node=headnode;//用临时节点指向头结点
    while(node!=NULL)//遍历链表并输出
    {
        cout<<node->data<<ends;
        node=node->next;
    }
    cout<<endl;
}

第六步，实现isEmpty()函数，判断链表是否为空，返回真为空，假则不空。

代码如下：

template<class T>
bool  myslist<T>::isEmpty()
{
    return listlength==0;
}

第七步，实现find()函数。

代码如下：

template<class T>
slistNode<T>* myslist<T>::find(T x)
{
    node=headnode;//用临时节点指向头结点
    while(node!=NULL&&node->data!=x)//遍历链表,遇到值相同的节点跳出
    {
        node=node->next;
    }
    return node;//返回找到的节点的地址,如果没有找到则返回NULL
}

第八步，实现delete()函数，删除第一个值为x的节点，如图4。

代码如下：

template<class T>
void  myslist<T>::Delete(T x)
{
    slistNode<T>* temp=headnode;//申请一个临时节点指向头节点
    if(temp==NULL) return;//如果头节点为空,则该链表无元素,直接返回
    if(temp->data==x)//如果头节点的值为要删除的值,则删除投节点
    {
        headnode=temp->next;//把头节点指向头节点的下一个节点
        if(temp->next==NULL) lastnode=NULL;//如果链表中只有一个节点,删除之后就没有节点了,把尾节点置为空
        delete(temp);//删除头节点
        return;
    }
    while(temp->next!=NULL&&temp->next->data!=x)//遍历链表找到第一个值与x相等的节点,temp表示这个节点的上一个节点
    {
        temp=temp->next;
    }
    if(temp->next==NULL) return;//如果没有找到则返回
    if(temp->next==lastnode)//如果找到的时候尾节点
    {
        lastnode=temp;//把尾节点指向他的上一个节点
        delete(temp->next);//删除尾节点
        temp->next=NULL;
    }
    else//如果不是尾节点,如图4
    {
        node=temp->next;//用临时节点node指向要删除的节点
        temp->next=node->next;//要删除的节点的上一个节点指向要删除节点的下一个节点
        delete(node);//删除节点
        node=NULL;
    }
}

第九步，实现insert()和insertHead()函数，在p节点后插入值为x的节点。如图5。

代码如下：

template<class T>
void  myslist<T>::insert(T x,slistNode<T>* p)
{
    if(p==NULL) return;
    node=new slistNode<T>();//申请一个新的空间
    node->data=x;//如图5
    node->next=p->next;
    p->next=node;
    if(node->next==NULL)//如果node为尾节点
    lastnode=node;
}
template<class T>
void  myslist<T>::insertHead(T x)
{
    node=new slistNode<T>();
    node->data=x;
    node->next=headnode;
    headnode=node;
}

最终，我们完成一个简单的单向链表。此单向链表代码还有很多待完善的地方，以后会修改代码并不定时更新。

二、双向链表

双向链表的指针域有两个指针，每个数据结点分别指向直接后继和直接前驱。单向链表只能从表头开始向后遍历，而双向链表不但可以从前向后遍历，也可以从后向前遍历。除了双向遍历的优点，双向链表的删除的时间复杂度会降为O（1），因为直接通过目的指针就可以找到前驱节点，单向链表得从表头开始遍历寻找前驱节点。缺点是每个节点多了一个指针的空间开销。如图6就是一个双向链表。

三、循环链表

循环链表就是让链表的最后一个节点指向第一个节点，这样就形成了一个圆环，可以循环遍历。单向循环链表可以单向循环遍历，双向循环链表的头节点的指针也要指向最后一个节点，这样的可以双向循环遍历。如图7就是一个双向循环链表。

四、链表相关问题

1、如何判断一个单链表有环

2、如何判断一个环的入口点在哪里

3、如何知道环的长度

4、如何知道两个单链表（无环）是否相交

5、如果两个单链表（无环）相交，如何知道它们相交的第一个节点是什么

6、如何知道两个单链表（有环）是否相交

7、如果两个单链表（有环）相交，如何知道它们相交的第一个节点是什么

从码农到码到成功

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
手写LinkList和arrayList

03-JAVAAPI-数据结构目录：1、自己写的LinkList和arrayList。2、基本数据结构：链表（list）为了加深理解，我就自己写了下LinkList和arrayList。下面贴下代码链表代码链表代码 public class MyTwoLinkedList<AnyType> implements Iterable...
复制链接

扫一扫