java 实现线性表

最新推荐文章于 2024-04-21 23:18:56 发布
最新推荐文章于 2024-04-21 23:18:56 发布
阅读量832 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010723885/article/details/37874549
版权


一、概念

对于常用的数据结构，可分为线性结构和非线性结构，线性结构主要是线性表，非线性结构主要是数和图。当n>0时，表可表示为：(a0,a1,a2,a3,…an)

1、 线性表的特征：

         1、存在唯一的被称作”第一个”的数据元素

         2、存在唯一的一个称作”最后一个的”数据元素”

         3、除第一个之外，集合中的每个数据元素均只有一个前驱

         4、除最后一个之外，集合中每个元素均只有一个后继

2、线性表的基本操作

         1、初始化：

         2、返回线性表长度

         3、获取指定索引处元素

         4、按值查找元素位置

         5、直接插入数据元素

         6、向指定位置插入元素

         7、直接删除元素

         8、删除指定位置元素

        

二、顺序存储结构

         线性表的顺序结构是指用一组地址连续的存储单元依次存放线性表的元素。下面采用数组实现顺序结构线性表。

import java.util.Arrays;

public class Sequence<T> {
	private Object[] elementData; <span style="color: rgb(0, 153, 0); font-family: Arial;">//定义一个数组</span>
	private int DEFAULT_SIZE = 1;  <span style="color:#009900;">//数组默认大小</span>
	private int capacity;  <span style="color:#009900;">//数组容量</span>
	private int size = 0;  <span style="color:#009900;">//当前数组大小</span>
	//初始化
	public Sequence(){
		capacity = this.DEFAULT_SIZE;
		elementData = new Object[capacity];
	}
	
	public Sequence(T element){
		this();
		elementData[0] = element;
		size++;
	}
	
	<span style="color:#009900;">//返回线性表长度</span>
	public int length(){
		return this.size;
	}
	
	<span style="color:#009900;">//返回指定索引处元素。</span>
	public T getElementByIndex(int index){
		
		if(index < 0 || index > (size-1)){
			System.out.println("索引范围越界！！！");
			System.exit(0);
		}
		return (T)elementData[index];
	}
	<span style="color:#009900;">//按值查找数据元素的位置</span>
	public int getIndexByValue(T value){
		for(int i = 0; i < elementData.length;i++ ){
			if(value.equals(elementData[i])){
				return i;
			}
		}
		return -1;<span style="color:#009900;">//未找到则返回-1</span>
	}
	
	<span style="color:#009900;">//向指定位置插入元素</span>
	public void insert(T element,int index){
		ensureCapacity();  <span style="color:#009900;">//确保线性表容量够</span>
		if(index >= 0 && index < size){
			int i = 0;
			<span style="color:#009900;">//将插入位置之后元素挨个后移1</span>
			for(i = (size-1); i >= index;i--){
				elementData[i+1] = elementData[i];
			}
			elementData[i+1] = element; <span style="color:#009900;">//插入该元素</span>
			size++;  <span style="color:#009900;">//数组当前容量+1</span>
		}
		else{
			throw new IndexOutOfBoundsException("插入元素位置越界！！！");
		}
	}
	
	<span style="color:#009900;">//想线性表末尾添加元素</span>
	public void add(T element){
		ensureCapacity();  <span style="color:#009900;">//确保线性表容量够</span>
		elementData[size] = element;
		size++;
	}
	
	<span style="color:#009900;">//删除线性表中指定位置元素</span>
	public void delete(int index){
		if(index >= 0 && index < size){
			int i;
			<span style="color:#009900;">//将要删除元素位置之后的元素挨个前移1，通过覆盖删除</span>
			for(i = index+1;i < size;i++){
				elementData[i-1] = elementData[i];
			}
			elementData[size-1] = null;
			
		}
		else{
			throw new IndexOutOfBoundsException("所要删除元素位置越界！！！");
		}
	}
	
	<span style="color:#009900;">//删除指定元素</span>
	public void delete(T value){
		int index = this.getIndexByValue(value);
		if(index != -1){
			this.delete(index);
		}
		else{
			System.out.println("您要删除的元素并不存在");
			System.exit(0);
		}
		size--;
	}
	
	<span style="color:#009900;">//判断线性表是否为空</span>
	public boolean isEmpty(){
		boolean b = false;
		if(this.length() != 0){
			b = true;
		}
		return b;
	}
	
	<span style="color:#009900;">//清空线性表</span>
	public void clear(){
		for(Object o:elementData){
			o = null;
		}
		size = 0;
	}
	
	<span style="color:#009900;">//显示线性表中所有元素</span>
	public void view(){
		System.out.print("当前线性表中元素为：");
		for(int i = 0;i < size;i++){
			System.out.print(elementData[i] + " ");
		}
		System.out.print("\n");
	}
	
	<span style="color:#009900;">//扩充线性表容量</span>
	public void ensureCapacity(){
		while((size+1) > capacity){
			capacity= capacity * 2;  <span style="color:#009900;">//线性表容量每次增大一倍</span>
			elementData = Arrays.copyOf(elementData, capacity);
		}
	}
	
	public static void main(String[] args) {
		Sequence<String> sequence = new Sequence<>();
		sequence.add("hello");
		sequence.add("world");
		sequence.add("java");
		sequence.add("perfect");
		sequence.view();
		sequence.insert("haha", 1);
		sequence.view();
		System.out.println("索引为3的元素为：" + sequence.getElementByIndex(3));
		System.out.println("字符串perfect的索引号为：" + sequence.getIndexByValue("perfect"));
		sequence.delete("hello");
		sequence.view();
		sequence.clear();
		System.out.println("clear之后线性表长度为：" + sequence.length());	
	}
}

 

三、链式存储结构

1、概念

链式存储结构的线性表(简称为链表)采用一组任意的存储单元存放线性表中的数据元素。链式存储结构的线性表不是按线性的逻辑顺序来保存数据元素，它需要在每个数据元素里保存一个引用下一个数据元素的引用。

         节点 = 数据元素 + 引用下一个节点的引用 + 引用上一个节点的引用

 

2、单链表基本操作

建立单链表方法：1头插法建表  2尾插法建表

查找操作：1按index查找指定数据元素  2在链表中查找指定的数据元素的index

插入操作：在第index个索引处插入元素

删除操作：删除第index个节点

 

3、单链表具体实现

public class LinkList<T>{
	<span style="color:#009900;">//定义Node节点</span>
	private class Node{
		private T data;
		private Node next;
		
		public Node(){
			
		}
		public Node(T element,Node next){
			this.data = element;
			this.next = next;
		}
	}
	<span style="color:#009900;">//成员变量</span>
	private Node header; <span style="color:#009900;">//头节点</span>
	private Node tail;  <span style="color:#009900;">//尾节点</span>
	private int size = 0;  <span style="color:#009900;">//链表长度</span>
	
	public LinkList(){
		header = null;
		tail = header;
	}
	
	public LinkList(T element){
		header = new Node(element, null);
		tail = header;
	}
	
	<span style="color:#009900;">//获取链表中指定索引处的元素</span>
	public T get(int index){
		return this.getNodeByIndex(index).data;
	}
	
	
	<span style="background-color: rgb(0, 153, 0);">//获取链表中指定索引处Node</span>
	public Node getNodeByIndex(int index){
		this.checkBorder(index);
		Node currentNode = header;
		for(int i = 0;i < size && currentNode != null;i++,currentNode = currentNode.next){
			if(i == index){
				return currentNode;
			}
		}
		return null;
	}
	
	<span style="background-color: rgb(255, 255, 255);"><span style="color:#009900;">//向指定索引处插入元素</span></span>
	public void insert(T element,int index){
		this.checkBorder(index);
		if(index == 0){
			this.addAtHeader(element);
		}
		else{
			Node prevNode = this.getNodeByIndex(index-1);//获取插入位置的前向Node
			prevNode.next = new Node(element,prevNode.next);
		}
		size++;
	}
	
	<span style="color:#009900;">//删除指定索引处Node</span>
	public T delete(int index){
		this.checkBorder(index);
		Node del = null;
		//删除的是header
		if(index == 0){
			del = header;
			header = header.next;
		}
		else{
			Node prevNode = this.getNodeByIndex(index);
			del = prevNode.next;
			prevNode.next = del.next; //将prevNode的后向Node设置为del.next
			del.next = null;
		}
		size--;
		return del.data;
	}
	
	<span style="color:#009900;">//头插法向链表中添加元素</span>
	public void addAtHeader(T element){
		header = new Node(element,header);//将新添加的Node的next设置为原先的header，然后将新的Node设置为新的header
		if(tail == null){
			tail = header;
		}
		size++;
	}
	
	<span style="color:#009900;">//尾插法</span>
	public void add(T element){
		//链表为空的情况
		if(header == null){
			header = new Node(element, null);
			tail = header;
		}
		else{
			tail.next = new Node(element, null); //将tail节点的next设置为new Node
			tail = tail.next; //将new Node设置为tail
		}
		size++;
	}
	<span style="color:#009900;">//遍历整个链表</span>
	public void view(){
		Node currentNode = header;
		System.out.print("当前链表元素：");
		while(currentNode != null){
			System.out.print(currentNode.data + " ");
			currentNode = currentNode.next;
		}
		System.out.println("");
		
	}
	
	<span style="color:#009900;">//检测索引是否越界</span>
	private void checkBorder(int index){
		if(index < 0 || index > size-1){
			throw new IndexOutOfBoundsException("链表索引已越界");
		}
	}
	
	public int length(){
		return this.size;
	}
	
	public static void main(String args[]){
		LinkList<String> linkList = new LinkList<>();
		linkList.add("hello");
		linkList.add("world");
		linkList.addAtHeader("header");
		System.out.println("当前链表长度为：" + linkList.length());
		linkList.view();
		System.out.print("插入test之后,");
		linkList.insert("test",2);
		linkList.view();
		linkList.delete(2);
		System.out.print("删除索引2处元素后，");
		linkList.view();
		System.out.println("索引1处元素为：" + linkList.get(1));
	}
}


 

4、双链表实现

public class DoubleLinkList<T> {
	
	<span style="color:#009900;">//定义双向链表节点</span>
	private class Node{
		private T data;
		private Node prev;
		private Node next;
		public Node(){
			
		}
		public Node(T element,Node prev,Node next){
			this.data = element;
			this.prev = prev;
			this.next = next;
		}
	}
	
	private Node header;
	private Node tail;
	private int size = 0;
	
	public DoubleLinkList(){
		header = null;
		tail = null;
	}
	
	public DoubleLinkList(T element){
		header = new Node(element,null,null);
		tail = header;
		size++;
	}
	<span style="color:#009900;">//获取链表长度</span>
	public int length(){
		return this.size;
	}
	
	<span style="color:#009900;">//检测index是否越界</span>
	public void checkBorder(int index){
		if(index < 0 || index > size-1){
			throw new IndexOutOfBoundsException("链表索引已越界");
		}
	}
	
	<span style="color:#009900;">//获取指定索引处Node</span>
	public Node getNodeByIndex(int index){
		checkBorder(index);//越界检测
		if(index < size/2){
			Node currentNode = header;
			for(int i = 0;i < size/2;i++,currentNode = currentNode.next ){
				if(i == index){
					return currentNode;
				}
			}
		}
		else{
			Node currentNode = tail;
			for(int i = size-1;i >= size/2;i--,currentNode = currentNode.prev){
				if(i == index){
					return currentNode;
				}
			}
		}
		return null;
	}
	
	<span style="color:#009900;">//获取链表中指定索引处的元素值</span>
	public T get(int index){
		return this.getNodeByIndex(index).data;
	}
	
	<span style="color:#009900;">//根据元素值查找元素索引</span>
	public int locate(T element){
		Node currentNode = this.header;
		for(int i = 0;i < size-1;i++,currentNode = currentNode.next){
			if(currentNode.data.equals(element)){
				return i;
			}
		}
		return -1;
			
	}
	
	<span style="color:#009900;">//向链表中以尾插法添加元素</span>
	public void add(T element){
		if(size == 0){
			header = new Node(element,null,null);
			tail = header;
		}
		else{
			Node newNode = new Node(element,tail,null);
			tail.next = newNode;
			tail = newNode;
		}
		size++;
	}
	
	<span style="color:#009900;">//头插法向链表添加元素</span>
	public void addAtHeader(T element){
		if(size == 0){
			header = new Node(element,null,null);
			tail = header;
		}
		else{
			Node newNode = new Node(element,null,header);
			header.prev = newNode;
			header = newNode;
		}
		size++;
	}
	
	
	<span style="color:#009900;">//根据索引插入元素</span>
	public void insert(T element,int index){
		this.checkBorder(index);
		Node prevNode = this.getNodeByIndex(index-1);
		Node nextNode = this.getNodeByIndex(index);
		Node insertNode = new Node(element, prevNode, nextNode);
		nextNode.prev = insertNode;
		prevNode.next = insertNode;
		size++;
	}
	
	<span style="color:#009900;">//根据索引删除元素</span>
	public void delete(int index){
		this.checkBorder(index);
		Node prevDelNode = this.getNodeByIndex(index-1);
		Node nextDelNode = this.getNodeByIndex(index+1);
		prevDelNode.next = nextDelNode;
		nextDelNode.prev = prevDelNode;
		size--;
	}
	
	<span style="color:#009900;">//遍历链表中元素</span>
	public void view(){
		System.out.print("当前链表中元素为：");
		for(int i = 0;i < size;i++){
			System.out.print(this.get(i) + " ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		DoubleLinkList<String> doubleLinkList = new DoubleLinkList<>();
		doubleLinkList.add("hello");
		doubleLinkList.add("world");
		doubleLinkList.insert("test", 1);
		doubleLinkList.addAtHeader("first");
		doubleLinkList.view();
		System.out.println("索引为0处的元素值为：" + doubleLinkList.get(0));
		System.out.println("test字符串在链表中索引号为： " + doubleLinkList.locate("test"));
		doubleLinkList.delete(1);
		System.out.print("删除索引号为1元素后，");
		doubleLinkList.view();
	}

}


 

 注：本文部分内容参考自《疯狂Java程序员的基本修养》和《数据结构(C语言版)》

 

 

 

 

 

 

 

 

 

 

whc20011
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java编写的线性表
07-01
java编写的线性表，用于理解数据结构中的线性表有很大帮助，使用Java原生sdk实现，内含源代码，可以运行。
线性表java实现
qq_41044209的博客
06-24 1245
通过数组实现，查询直接根据索引（index）查询，效率比较高；增删的效率比较低，因为需要大量的移动元素的位置，一旦创建，长度固定，当长度等于数组长度时，如果想要再插入数据就需要扩容处理。...
数据结构与算法 —— Java 实现（线性表）
最新发布
2401_84046545的博客
04-21 868
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
数据结构：线性表（java实现）
热门推荐
好好学java
06-05 2万+
一、线性表 一个线性表（Linear List）是由n(n≥0)个数据元素（结点，它可以是一个字母，数字，记录或更复杂的信息）所构成的有限序列。线性表逻辑地表示为：（a0,a1,…,an-1)。其中，n为线性表的长度，n=0时为空表。称i为ai在线性表中的位序号。 然后，我们对顺序存储结构用图来做一个理解。 1.1 顺序存储结构理解 顺序储存结构是用数组来保存数据的。如下图： ...
java模拟实现线性表及其相应操作
u010590120的博客
07-14 468
ADT 线性表 (List) Data Operation void initList(*L); //创建并初始化一个空线性表，如果成功返回true，修改表传指针 bool listEmpty(L); //判断一个线性表是否为空，不修改表传值 void clearList(*L); //清空一个线性表，成功返回true bool getEle...
java线性表的实验_线性表的操作（java语言实现）
weixin_30836221的博客
02-13 753
线性表的操作(java语言实现)一、需求分析本次实验主要完成以下内容：线性表基本操作的实现，分别采用数组和链表结构实现线性表，实现线性表的基本操作利用实现的线性表，存储一元n次多项式，完成多项式的输入、显示；实现多项式的加法操作经过分析，程序主要需求如下：输出的形式 ：控制台输出程序所能达到的功能 ：用户输入多项式每一项的系数和指数，控制台打印出该多项式测试数据输入输出1,3 4,5,二、概要...
java实现线性表
12-19
在这个主题中，我们将深入探讨如何使用Java语言来实现线性表。 Java是一种面向对象的编程语言，它提供了丰富的类库支持各种数据结构的实现。在给定的压缩包中，我们有两个.java文件：SeqList.java和LList.java，...
Java 实现线性表
06-27
总结来说，Java实现线性表可以根据实际需求选择数组或链表。数组适合于需要快速随机访问且对空间利用率较高的场景，而链表则更适合频繁的插入和删除操作。理解并掌握这两种实现方式对于理解和设计更复杂的数据结构至...
java实现线性表及其算法
08-27
在Java中，我们可以使用两种主要方式来实现线性表：顺序存储和链式存储。 1. **顺序存储**： 顺序存储的线性表，也称为顺序表，是通过将数据元素按照它们的逻辑顺序依次存放在一组连续的内存地址中。这种存储方式...
Java开发-线性表
07-16
Java开发线性表；Java开发线性表；Java开发线性表；Java开发线性表；Java开发线性表；Java开发线性表；Java开发线性表；Java开发线性表；
JAVA线性表JAVA线性表JAVA线性表
06-04
在Java中，线性表的实现通常包括两种主要方式：顺序表和链表。 **2.1 线性表的抽象数据类型** 线性表的抽象数据类型（Abstract Data Type, ADT）定义了线性表的基本操作。在Java中，我们可以定义一个名为`LList`的...
Java数据结构-线性表
qq_51938362的博客
10-16 1552
Java线性表、链表
【Java数据结构】线性表-顺序表
m0_72670269的博客
04-09 810
线性表（linear list）
java数据结构，线性表顺序存储（数组）的实现
m0_63622279的博客
11-20 1209
线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。接着用类去实现这一接口，重写其中的全部方法，因为有一些操作，使用静态方法更便捷，所以接口中只是部分的基础操作，线性表的增删改查。7）Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置。数据结构陆续更新中！3）Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）6）Locate（L，x） 这是一个函数，函数值为元素x在L中的位置。
JAVA基础-利用数组实现线性表
lwxklts的博客
02-02 469
1.有下标索引，基于下标操作速度很快2.数组存储占用一块连续的空间3.插入操作慢，且增加数据不能扩容4.删除操作需要后置数据前移1. 链表数据以节点的形式分散存储2.不需要扩容3.删除和插入操作很快这里附上全部代码//元素数量，下一次要存储的下标//当前数组链表长度//默认的初始容量//简单的构造方法，不传入参数size=0;//初始化方法size=0;//初始化数组链表长度，传入参数为自定义长度，分三种情况//必须大于0。
52.【Java 数据结构——线性表】
qq_69683957的博客
09-09 3263
增删改查
Java数据结构之线性表
SDDDDDSA的博客
10-12 869
以下内容来自黑马程序员 我摘抄部分关键内容 并进行批注 部分转载于黑马程序员 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后
数据结构之线性表（Java）
m0_46340286的博客
03-09 1688
Java写数据结构01 线性表 定义 ​ 线性表是最常用且最简单的一种数据结构。简言之，一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以有若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称文件。（为什么称为线性表，是因为符合线性结构：结构中的数据元素存在一个对一个的关系。而常见的非线性结构有：树，广义表，多维数组等等，他们都不是一对一的关系） 1.线性表的顺序表示 ​ 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。假设

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值