Structure.List 线性表（包含顺序链表，单链表，双链表，双向循环链表的实现）

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量432 收藏
点赞数
分类专栏： 数据结构 文章标签： 线性表 数据结构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34690598/article/details/51174748
版权 
package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public interface ListInterface<E extends Comparable<E>> {
	public boolean IsFull();
	public boolean IsEmpty();
	public int Length();
	public boolean Insert(int i,E value);
	public boolean Delete(E value);
	public int Find(E value);
	public boolean Clear();
	public E Get(int index);
	public void Print();
}


package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class SeqList<E extends Comparable<E> > implements ListInterface<E> {
	private Object data_[];
	private int length_;
	private int maxSize_;
	private int initSize_;
	
	private void DoubleSize()
	{
		initSize_ = 2 * maxSize_ + 1;
		Object temp[] = new Object[initSize_];
		copy(temp);
		data_ = temp;
		maxSize_ = initSize_ - 1;
	}
	
	private void copy(Object other[])
	{
		for(int i = 1 ; i <= length_ ; ++i)
		{
			other[i] = data_[i]; 
		}
	}
	
	public SeqList(int initSize)
	{
		initSize_ = initSize;
		maxSize_ = initSize_ - 1;
		length_ = 0;
		data_ = new Object[initSize_];
	}

	@Override
	public boolean IsFull() {
		// TODO Auto-generated method stub
		return (length_ == maxSize_);
	}

	@Override
	public boolean IsEmpty() {
		// TODO Auto-generated method stub
		return (length_ == 0 );
	}

	@Override
	public int Length() {
		// TODO Auto-generated method stub
		return length_;
	}

	@Override
	public boolean Insert(int i, E value) {
		// TODO Auto-generated method stub
		if( i < 1 || i > maxSize_) 
			throw new IllegalArgumentException();
		
		if(maxSize_ == length_)
		{
			DoubleSize();
		}
		++length_;
		for(int j = length_ ; j > i ; --j)
		{
			data_[j] = data_[j-1];
		}
		data_[i] = (Object)value;
		return true;
	}

	@Override
	public boolean Delete(E value) {
		// TODO Auto-generated method stub
		int i = Find(value);
		if(i!=0)
		{
			for(int j = i ; j < length_ ; ++j)
			{
				data_[j] = data_[j+1];
			}
			--length_;
		}
		return true;
	}

	@Override
	public int Find(E value) {
		// TODO Auto-generated method stub
		if(data_ == null)
			throw new NullPointerException();
		data_[0] = value;
		int i = length_;
		while(i >= 0)
		{
			if(((E)data_[i]).compareTo(value) == 0 ) break;
			else --i;
		}
		return i;
	}

	@Override
	public boolean Clear() {
		// TODO Auto-generated method stub
		length_ = 0;
		return true;
	}

	@Override
	public E Get(int i) {
		// TODO Auto-generated method stub
		if( i < 1 || i > length_) 
			throw new IllegalArgumentException();
		return (E)data_[i];
	}

	@Override
	public void Print() {
		// TODO Auto-generated method stub
		for(int i = 1 ; i <= length_ ; ++i)
		{
			System.out.print((E)data_[i]+ " ,");
		}
		System.out.println();
	}

}

package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
class ListNode<E extends Comparable<E>>
{
	public ListNode<E> next_;
	public E data_;
	public ListNode(E data, ListNode<E> next){data_ = data ; next_ = next;}
}
public class SingleList<E extends Comparable<E>> {
	private ListNode<E> head_;
	private ListNode<E> current_;
	
	public SingleList(){head_ = null; current_ = head_;}
	
	public boolean IsEmpty(){return head_ == null;}
	public void Insert(E value)
	{
		if(head_ == null)
		{
			head_ = new ListNode<E>(value,null);
			current_ = head_;
		}
		else
		{
			current_.next_ = new ListNode<E>(value,current_.next_);
			current_ = current_.next_;
		}
	}
	
	public boolean Delete(E value)
	{
		ListNode<E> first = head_;
		if(first.data_.compareTo(value) == 0)
		{
			head_ = first.next_;
			current_ = head_;
			return true;
		}
		else
		{
			while(first.next_ != null && first.next_.data_.compareTo(value) != 0)
			{
				first = first.next_;
			}
			if(first.next_ == null) return false;
			else {
				first.next_ = first.next_.next_;
				current_ = head_;
				return true;
			}
		}
	}		
	
	public ListNode<E> Find(E value)
	{
		if(head_ == null) return null;
		else{
			ListNode<E> temp = head_;
			while( temp != null)
			{
				if( temp.data_.compareTo(value) == 0 ) return temp;
				else temp = temp.next_;
			}
		}
		return null;
	}
	
	public void Print() {
		// TODO Auto-generated method stub
		ListNode<E> temp = head_;
		while(temp != null)
		{
			System.out.print(temp.data_+", ");
			temp = temp.next_;
		}
		System.out.println();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SingleList<Double> sList = new SingleList<Double>();
		sList.Insert(1.0);
		sList.Insert(5.0);
		sList.Insert(2.0);
		sList.Insert(4.0);
		sList.Insert(2.0);
		sList.Insert(10.0);
		sList.Insert(12.0);
		sList.Print();
		
		ListNode<Double> e = sList.Find(2.0);
		if(e != null) System.out.println(e.data_);
		
		sList.Delete(1.0);
		sList.Print();
		
		sList.Delete(10.0);
		sList.Print();
		sList.Insert(20.0);
		sList.Print();
	}

}

package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
class NodeT<E extends Comparable<E> >
{
	NodeT<E> prev_;
	NodeT<E> next_;
	E data_;
	public NodeT(E data,NodeT<E> prev,NodeT<E> next)
	{
		data_ = data;
		prev_ = prev;
		next_ = next;
	}
};

public class LinkedList<E extends Comparable<E> > {
	private NodeT<E> head_;
	private NodeT<E> tail_;
	private NodeT<E> cur_;
	
	public LinkedList()
	{
		head_ = new NodeT<E>(null,null,null);
		tail_ = new NodeT<E>(null,null,null);
		head_.next_ = tail_;
		tail_.prev_ = head_;
		cur_ = null;
	}
	
	public void Insert(E value)
	{
		if(cur_ == null)
		{
			NodeT<E> n = new NodeT<E>(value,null,null);
			n.prev_ = head_;
			n.next_ = head_.next_;
			head_.next_ = n;
			n.next_.prev_ = n;
			cur_ = n;
		}
		else
		{
			NodeT<E> n = new NodeT<E>(value,cur_,cur_.next_);
			cur_.next_ = n;
			n.next_.prev_ = n;
			cur_ = n;
		}
	}
	
	public void Delete(E value)
	{
		NodeT<E> n = Find(value);
		if(n != null){
			n.prev_.next_ = n.next_;
			n.next_.prev_ = n.prev_;
			cur_ = null;
		}
	}
	
	public NodeT<E> Find(E value)
	{
		NodeT<E> n = null;
		for(n = head_.next_ ; n != tail_ ; n = n.next_)
		{
			if(n.data_.compareTo(value) ==0 )return n;
		}
		return null;
	}
	
	public void Print()
	{
		NodeT<E> n = null;
		for(n = head_.next_ ; n != tail_ ; n = n.next_)
		{
			System.out.print(n.data_+",");
		}
		System.out.println();
	}
	
	public static void main(String[] args)
	{
		LinkedList<Integer> list = new LinkedList<Integer>();
		list.Insert(1);
		list.Insert(5);
		list.Insert(6);
		
		list.Print();
		
		list.Delete(7);
		list.Print();
		
		list.Delete(5);
		list.Print();
		
		list.Delete(1);
		list.Print();
		
		list.Insert(8);
		list.Insert(10);
		list.Print();
		
		list.Delete(10);
		list.Print();
		
	}
	
}
package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */

class Node<E extends Comparable<E>>
{
	E data_;
	Node<E> prev_;
	Node<E> next_;
	public Node(E data,Node<E> prev,Node<E> next)
	{
		data_ = data;
		prev_ = prev;
		next_ = next;
	}
}

public class LinkedCircleList<E extends Comparable<E> > {
	public static void main(String[] args)
	{
		LinkedCircleList<Integer> list = new LinkedCircleList<Integer>();
		
		list.Insert(1);
		list.Insert(2);
		list.Insert(3);
		
		list.Print();
		list.Delete(4);
		list.Print();
		
		list.Delete(1);
		list.Print();
		
		list.Delete(2);
		list.Print();
		
		list.Insert(4);
		list.Insert(5);
		list.Print();
		
		list.Insert(7);
		list.Print();
		
		list.Delete(5);
		list.Print();
		
		list.Delete(7);
		list.Print();
		
		list.Delete(3);
		list.Print();
		
		list.Insert(10);
		list.Insert(15);
		list.Print();
	}
	
	private Node<E> head_;
	private Node<E> current_;
	private int size_;
	
	public LinkedCircleList(){head_ = null; current_ = null; size_ = 0;}
	
	public void Insert(E value)
	{
		if(head_ == null)
		{
			head_ = new Node<E>(value,null,null);
			head_.prev_ = head_;
			head_.next_ = head_;
			current_ = head_;
			++size_;
		}
		else
		{
			Node<E> newNode = new Node<E>(value,current_,current_.next_);
			current_.next_ = newNode;
			newNode.next_.prev_ = newNode;
			current_ = newNode;
			++size_;
		}
	}
	
	public void Delete(E value)
	{
		Node<E> n = Find(value);
		if(n == null)
		{
			return;
		}
		else
		{
			if( n == head_)
			{
				n.prev_.next_ = n.next_;
				n.next_.prev_ = n.prev_;
				head_ = n.next_;
				current_ = head_;
			}
			else
			{
				n.next_.prev_ = n.prev_;
				n.prev_.next_ = n.next_;
				current_ = head_;
			}
			--size_;
		}
	}
	
	public void Print()
	{
		Node<E> n = head_;
		for(int i = 0 ;i < size_ ; ++i)
		{
			System.out.print(n.data_+" ,");
			n = n.next_;
		}
		System.out.println();
	}
	
	public Node<E> Find(E value)
	{
		Node<E> n = head_;
		for(int temp = 0 ; temp < size_ ; ++temp)
		{
			if(n.data_.compareTo(value) == 0){return n;}
			else 
			{
				n = n.next_;
			}
		}
		return null;
	}
}

package Structure.List;
/*Author: CPlusPlus小码农
 *If any question, 
 *Please contact:           
 * http://daixiecplusplus.blog.163.com/
 * QQ:1926742804
 */
public class ListTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ListInterface<Integer> list = new SeqList<Integer>(5);
		list.Insert(1, 1);
		list.Insert(1, 4);
		list.Insert(2, 3);
		list.Insert(1, 2);
		list.Insert(1, 5);
		
		list.Print();
		
		list.Delete(0);
		list.Print();
		
		list.Delete(3);
		list.Print();
		
		list.Insert(1, 10);
		list.Insert(1, 7);
		list.Insert(1, 6);
		list.Insert(1, 4);
		list.Insert(1, 3);
		list.Insert(1, 2);
		list.Insert(1, 12);
		list.Insert(1, 14);
		list.Print();
		System.out.println(list.Length());
		
		Integer i = list.Get(5);
		System.out.println(i);
		
		int k = list.Find(5);
		System.out.println(k);
	}

}



qq_34690598
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Structure:List
bitdai2018
10-29 204
\\--------------------------- List.h----------------------- #pragma once // 链表结点 class Node { public: Node() { next = nullptr; } Node(int data, Node * node = nullptr) { this->data = data; thi...
Scheme数据类型之结构体-list/structure/record
热门推荐
Tumiz的技术天地
06-08 2万+
 下面举个例子，来加深一下对于record和structure的理解， 首先定义一个结构体，用define-structure命令 (define-structure (tasklist (type-descriptor )) task1 task2 task3) 这就声明了一个新结构体，名字叫tasklist，有三个成员task1，task2，task3 由structure得到一
Structure.BSTree（二叉树、排序树、平衡树、SB树）
04-17 1217
Structure.BSTree
Structure.Queue 队列（包含顺序队列，链表队列的实现）
04-17 344
Structure.Queue
线性表（数组、单链表、静态链表、循环链表、双向链表）
cp_Mark的博客
09-18 1346
线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 有几个地方需要强调： 首先它是一个序列，也就是说元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他每个元素都有且只有一个前驱和后继。 然后线性表强调的是有限的。 最后线性表中的数据元素必须是相同类型。 如果用数据语言来定义，可如下（配合下图理解）： 数学语言定义： 若将线性表记为（a1...
数据结构知识整理 - 链表（本篇包括单链表、循环链表以及双向链表）
春雪阁
12-21 397
主要内容 链表的基本概念 链表的基本术语和存储结构 链表的基本操作 循环链表 双向链表   链表的基本概念 链表的特点是：用一组任意的存储单元存储某逻辑结构的数据元素（存储单元可连续可不连续）。 因此，为了表示每个数据元素与其直接后继数据元素的逻辑关系，除了要存储数据元素本身的信息外，还需要存储一个指向直接后继数据元素的指针（对于线性表而言）。这两部分信息组成数据元素的存储映像，称...
单链表SingleLinkedList.zip_data structure
09-21
单链表是计算机科学中一种基础且重要的数据结构，它属于线性表的一种。线性表是由n（n>=0）个相同类型元素组成的有限序列，而单链表则是线性表在内存中的动态表示形式。在单链表中，每个元素称为节点，每个节点包含...
Data-structure--source-code.rar_查找排序
09-20
链表有单链表和双链表之分，单链表只包含指向下一个元素的指针，而双链表则同时包含指向前一个元素的指针，这使得双向操作更加灵活。 接着是线性表，它是最基础的数据结构之一，通常我们用数组或者链表来实现。List...
数据结构专有名词(双语).doc
11-26
12. 线性表（Linear List）：一串相互连接的数据元素，如单链表、双链表、循环链表等。 13. 栈（Stack）：具有“后进先出”（LIFO）特点的数据结构，主要用于实现函数调用、表达式求值等。 14. 队列（Queue）：...
C#数据结构之顺序表(SeqList)实例详解
01-01
本文实例讲述了C#数据结构之...线性表(List)是线性结构的一种典型实现，它又可以分为：顺序表(SeqList)和链表(LinkList)二大类. 顺序表（SeqList）的基本特征为：元素在内部存储时是一个接一个在存储单元中按顺序存储
数据结构知识点整理.pdf
08-22
循环链表是一种特殊的链表表示，其中链表的结尾结点的LINK域中不是NULL，而是存放了一个指向链表开始结点的指针，这样，只要知道表中任意一个结点的地址，就能遍历表中其他任意一个结点。 双向链表是一种特殊的链表...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 164
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 295
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 416
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 724
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 964
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1159
介绍了二叉搜索树的实现与模拟
线性表与链式存储：单链表、循环链表与双向链表解析
本文档主要讲解了线性表的不同链式表示和实现，包括单链表、循环链表和双向链表。其中，线性表是一种基本的数据结构，由相同类型的元素构成，按照线性顺序排列。链表作为线性表的链式存储方式，允许逻辑上相邻的元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值