Java 版 数据结构 （线性表一）

最新推荐文章于 2023-09-18 14:59:36 发布
最新推荐文章于 2023-09-18 14:59:36 发布
阅读量174 收藏
点赞数 1
分类专栏： # 常用算法 文章标签： 链表 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QuantumYou/article/details/114901063
版权

文章目录

线性表

  • 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列
  • 前驱元素：若A元素在B元素的前面，则称A为B的前驱元素
  • 后继元素：若B元素在A元素的后面，则称B为A的后继元素

顺序表

定义

  • 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

代码

package list;

/**
 * @author LZH.create
 * Date 2012.3.16
 * 效率
 */
public class SequenceList {

	
	private String [] eles  ;
	// 当前 线性表 元素的个数
	private int n ;
	
	
	
	// 构造方法    capacity  容量
	public  SequenceList(int  capacity) {
	eles = new String [capacity] ;
	n = 0 ;
	}
	
	
    public void clear() {
    	n = 0 ;
    	// 将整个数据置空
    	eles = new String [eles.length] ;
    } 
    
    
    // 判空 
    public boolean isEmpty() {
    	return n == 0 ;
    }
    
    public int length () {
    	return   n ;
    }

    
    public String get(int index) {
    	
    	if (index < 0 || index >= n) {
    		System.err.println("当前元素不存在")   ;
    		return null ;
    	}
    	
    	return  eles[index];
    }
    
    
    // 在线性表第 i  个元素之前插入  v
    
    public void insert(int i , String v) {
    	
    	// 判断是否已表满
    	if( n == eles.length) {
    		System.err.println("当前表以满") ;
    		  return ;
    		}  
    	
    	
    	if(i >= eles.length) {
    		System.err.println("下标位置非法") ;
    	}
    	
    	// 判断 i  是否合法
    	if (i < 0 ||  i > n ) {
    		System.err.println("下标位置非法") ;
    		return ;
    	}
    	
    	//  把  v  放于 i(index ) 处
    	eles[i] = v ;
    	n++ ;
     }
    
    
    public void insert(String v) {
    	if( n == eles.length) {
    		System.err.println("当前表以满") ;
    		  return ;
    		}  
    	
    	eles[n++] = v ;
    }
    
    
    public String remove( int index) {
    	
    	if (index < 0 || index >= n) {
    		System.err.println("当前元素不存在")   ;
    		return null ;
    	}
    	
    	// 获取要删除的元素
    	String result = eles[index] ;
    	
    	for( int i = index  ; i < n- 1 ; i++) {
    		eles [i] = eles [i + 1] ; 
    	}  
    	
    	n -- ;
    	
    	return  result  ;
    }
    
    
    
    // 返回线性表 首次出现的元素的索引
    public int indexOf(String v) {
    	return 0 ;
    }
}

class Test1{
	public static void main(String [] args) {
		SequenceList list = new SequenceList(10) ;
		list.insert("热爱");
		list.insert("效率");
		list.insert("格局");
		list.insert("心态");
		
         System.out.println(list.get(1));
         System.out.println(list.remove(0));
         System.out.println(list.get(0));
         list.clear(); 
         System.out.println(list.length());
		
	}
}

链表

定义

  • 链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能直观的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每个元素称为结点）组成结点可以在运行时动态生成。

代码

package list;

public class LinkList {
	
	// 首结点
	private  Node head ;
	// 链表长度
	private int n ;
	
	
	public LinkList() {
		n = 0 ;
		head = new Node(null,null) ;
	}
	
	
	// 对象  结构体
	private  static class Node {

		public String item ;
		public Node next ;
		
	
		//  右键 source  构造方法快捷键
		public Node(String item, Node next) {
			super();
			this.item = item;
			this.next = next;
		}
	
		
	}
	
	
	   public void clear() {
		   
		   head.item = null ;
		   head.next = null ;
		   n = 0 ;
	    	
	    } 
	    
	    
	    // 判空 
	    public boolean isEmpty() {
	    	return n== 0 ;
	    }
	    
	    public int length () {
	    	return   0 ;
	    }

	    
	    public String get(int index) {
	    	
	         if(index < 0  || index >= n) {
	        	 System.err.println("下标不合法") ;
	        	 return null;
	         }
	    	
		    // 获取第一个结点
	    	Node item = head.next  ;
	    	for (int i = 0 ; i < index ; i++) {
	    		item = item.next ;
	    	}  
	    	return item.item ;
	    }


    	
    	
	    
	    // 在线性表第 i  个元素之前插入  v
	    
	    public void insert(int index , String v) {
	    	if (index < 0 || index >= n) {
	    		System .err.println("位置不合法");
	    	    return ;
	    	} 
	    	
	    	Node pre = head ;
	    	for( int i = 0 ; i < index ; i++) {
	    		pre = pre.next ;
	    	} 
	    	
	    	Node next = pre.next ;
	    	
	    	Node newNode = new Node(v,next) ;
	    	pre.next = newNode ;
	    	
	    	n++ ;
	           
	     }
	    
	    
	    public  void  resize(int newSize) {
	    	
	    }
	    
	    
	    // 尾插法
	    public void insert(String v) {
	    	
	    	Node  node = head ;
	    	
	    	while(node.next != null) {
	    		node = node.next ;
	    	}
	    	
	    	
	    	Node newNode = new Node(v,null) ;
	    	node.next = newNode ;
	    	n ++ ;
	    	
	    }
	    
	    
	    public String remove( int index) {
	    	if(index < 0 || index >= n) {
	    		System.err.println("下标位置不合法") ;
	    		return null ;
	    	}  
	     
	    	Node pre = head  ;
	    	// 寻找  index  之前的元素
	    	for (int i = 0 ; i < index ; i++) {
	    		pre = pre.next ;
	    	}
	    	
	    	
	    	// 获取 当前结点的位置
            // current 为当前节点的位置    	    	
	    	Node  current = pre.next ;
	    	Node next = current.next ;
	    	
	    	pre.next = next ;
	    	n-- ;
	    	return current.item  ;
	    }
	    
	    
	    
	    // 返回线性表 首次出现的元素的索引
	    public int indexOf(String v) {
	    	return 0 ;
	    }
	
	public static void main(String[] args) {
		Node node1 = new Node("a",null) ;
		Node node2 = new Node("b",null) ;
		Node node3 = new Node("c",null) ;
		
		node1.next = node2;
		node2.next = node3;
		
	}

}


class Test3{
	public static void main(String [] args) {
		LinkList list = new LinkList() ;
		list.insert("数据结构");
		System.out.println(list.get(0));
		list.insert("计算机组成原理");
		System.out.println(list.get(1));
		list.insert(0,"计算机网络") ;     // 带序号插入
		System.out.println(list.get(0)+list.get(1));
		System.out.println(list.remove(1));
		System.out.println(list.get(1));
		System.out.println(list.length());
		list.clear(); 
		System.out.println(list.length());
		System.out.println(list.isEmpty());
	}
}

双向链表

定义

  • 双向链表也叫双向表，是链表的一种，它由多个结点組成，毎个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的欻据域不存诸数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。

图解

在这里插入图片描述

API 设计

节点 API

在这里插入图片描述

双向链表 API

在这里插入图片描述

代码

整体代码

package list;


/**
 * @author LZH.create
 *  @Date 2021.3.19
 *    劝君专注案前事
 */
public class TowWayLinkList {
	
	// 首结点
	private  Node first ;
	private  Node last ; 
	// 链表长度
	private int n ;
	

	// 对象  结构体
	private  static class Node {

		public String item ;
		public Node next ;
		public Node pre ;
		
	
		//  右键 source  构造方法快捷键
		public Node(String item,Node pre , Node next) {
			super();
			this.item = item;
			this.pre = pre;
			this.next = next;
		}
	
		
	}
	  public TowWayLinkList() {
		  last = null ;
		  first = new Node(null,null,null) ;
		  n = 0 ;
	  }
	
	   public void clear() {
		   last = null ;
		   first.item = null ;
		   first.next = null ;
		   first.pre = null ;
		   n = 0 ;
	    	
	    } 
	    
	    
	    // 判空 
	    public boolean isEmpty() {
	    	return n== 0 ;
	    }
	    
	    public int length () {
	    	return   0 ;
	    }

	    
	    public String get(int index) {
	    	
	         if(index < 0  || index >= n) {
	        	 System.err.println("下标不合法") ;
	        	 return null;
	         }
	    	
		    // 获取第一个结点
	    	Node item = first.next  ;
	    	for (int i = 0 ; i < index ; i++) {
	    		item = item.next ;
	    	}  
	    	return item.item ;
	    }


    	
    	
	    
	    // 在线性表第 i  个元素之前插入  v    尾插法
	    
	    public void insert( String v) {
	    	
	    	// 注意此链表有头节点
	    	if (last == null) {
	    		last = new Node (v,first,null) ;
	    		first.next = last ;
	    	} else {
	    		Node oldLast = last ;
	    		Node node = new Node (v,oldLast,null) ;
	    		oldLast.next = node ;
	    		last = node ;
	    	}
	    	
	          n++ ;
	     }
	    
	    
	    public  void  resize(int newSize) {
	    	
	    }
	    
	    
	    // 指定位置插入
	    public void insert(int index ,String v) {
	    	if(index < 0 || index >= n) {
	    		System.err.println("下标位置不合法") ;
	    		return  ;
	    	} 
	    	
	    	// 获取头节点
	    	
	    	Node pre = first ;
	    	for (int i = 0 ; i < index ; i++) {
	    		pre = pre.next ;
	    	}
	    	
	    	Node next = pre.next ;
	    	Node newNode = new Node(v,pre,next) ;
	    	
	    	pre.next = newNode ;
	    	next.pre = newNode ;
	    	
	    	n++ ;
	    }
	    
	    
	    public String remove( int index) {
	    	if(index < 0 || index >= n) {
	    		System.err.println("下标位置不合法") ;
	    		return null ;
	    	}  
	     
	    	Node pre = first  ;
	    	// 寻找  index  之前的元素
	    	for (int i = 0 ; i < index ; i++) {
	    		pre = pre.next ;
	    	}
	    	
	    	
	    	// 获取 当前结点的位置
            // current 为当前节点的位置    	    	
	    	Node  current = pre.next ;
	    	Node next = current.next ;
	    	
	    	pre.next = next ;
	    	next.pre = pre ;
	    	n-- ;
	    	return current.item  ;
	    }
	    
	    
	    
	    // 返回线性表 首次出现的元素的索引
	    public int indexOf(String v) {
	    	return 0 ;
	    }
	    
	    
	    // 获取第一个与最后一个元素
	    
	    public String getFirst() {
	    	if (isEmpty()) {
	    		return null ;
	    	}
	    	return first.next.item ;
	    } 
	    
	    
	    public String getLast() {
	    	
	     	if (isEmpty()) {
	    		return null ;
	    	}
	    	return last.item ;
	    }
	
	public static void main(String[] args) {
	
	}

}


class Test4{
	public static void main(String [] args) {
		TowWayLinkList list = new TowWayLinkList() ;
		list.insert("数据结构");
		System.out.println(list.get(0));
		list.insert("计算机组成原理");
		System.out.println(list.get(1));
		list.insert(0,"计算机网络") ;     // 带序号插入
		System.out.println(list.get(0)+list.get(1));
		System.out.println(list.remove(1));
		System.out.println(list.get(1));
		System.out.println(list.length());
		list.clear(); 
		System.out.println(list.length());
		System.out.println(list.isEmpty());
	}
}
局部代码分析

注意： 思考与普通链表的区别（尾插法）

  public void insert(String v) {
	    	
	    	Node  node = head ;
	    	
	    	while(node.next != null) {
	    		node = node.next ;
	    	}
	    
	    	Node newNode = new Node(v,null) ;
	    	node.next = newNode ;
	    	n ++ ;
	    	
	    }

使用 while 语句 判断尾节点

	    public void insert( String v) {
	    	
	    	// 注意此链表有头节点
	    	if (last == null) {
	    		last = new Node (v,first,null) ;
	    		first.next = last ;
	    	} else {
	    		Node oldLast = last ;
	    		Node node = new Node (v,oldLast,null) ;
	    		oldLast.next = node ;
	    		last = node ;
	    	}
	    	
	          n++ ;
	     }
QuantumYou
关注
专栏目录
数据结构：线性表（Java实现）
weixin_43563848的博客
10-27 274
线性表是最基本的数据结构，可用顺序存储和链式存储结构来表示。 首先创建一个接口，包含线性表的操作。 public interface Ilist { // 线性表置空操作 public void clear(); // 判断线性表是否为空操作 public boolean isEmpty(); // 获取线性表中元素的长度操作 public...
Java数据结构——线性表
m0_51274044的博客
11-28 1415
线性表的顺序表示和实现 线性表的顺序表示形式： 用一组地址连续的存储单元依次存储线性表中的数据元素 在接口中定义方法： package qianyu.ch02; public interface MyArrayList { //定义一些方法 //查询线性表中数据元素个数 int getSize(); //判断线性表是否为空 boolean isEmpty(); //在线性表指定索引位置处插入元素 void insert(int i,Object e); //判断线性表中是否存在元素.
Java数据结构-线性表
qq_51938362的博客
10-16 1938
Java线性表、链表
52.【Java 数据结构——线性表】
qq_69683957的博客
09-09 3389
增删改查
数据结构之线性表(Java版)
qq_52374254的博客
10-02 2400
一、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种"一对一"的逻辑关系 第一个 数据元素没有前驱，这个数据元素被称为头结点 最后一个数据元素没有后继，这个数据元素被称为尾结点 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继 如.
Java数据结构之线性表的生成与操作
shizhongruyi0606的博客
11-09 916
Java数据结构之线性表的生成与操作
Java数据结构之线性表
SDDDDDSA的博客
10-12 926
以下内容来自黑马程序员 我摘抄部分关键内容 并进行批注 部分转载于黑马程序员 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。 第一个数据元素没有前驱，这个数据元素被称为头结点； 最后一个数据元素没有后继，这个数据元素被称为尾结点； 除了第一个和最后
数据结构 线性表java_JAVA实现数据结构—线性表
weixin_39875516的博客
02-21 139
线性表文件目录List.java 文件接口package com.data.service;import com.data.util.OutOfBoundaryException;public interface List {/*** 返回线性表的大小，即元素的个数* @return*/public int getSize();/*** 如果线性表为空返回true,否则返回false*/publi...
Java数据结构-线性表的设计与实现(头歌平台，详细注释)
最新发布
qwertf123的博客
09-18 1716
Java数据结构-线性表的设计与实现
【Java数据结构】线性表
m0_51692337的博客
01-03 444
线性表我认为就是数组。。。 创建： private int[] elements;//元素 private int size;//List中当前的元素个数 public MyArrayList() { this(1);//List默认大小为1 } /** * 按指定大小capacity构造List * * @param capacity List初始化时的大小 */ public MyArrayList(in
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
数据结构(Java版)-线性表的实现与应用完整版.doc
10-01
"数据结构(Java版)-线性表的实现与应用完整版" 本文旨在通过Java实现线性表的基本操作，并应用于实际问题中。线性表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。本文将通过两个部分来介绍线性表的...
Java数据结构（线性表）详解
08-31
线性表是数据结构中基础且重要的概念，它是由n（n>=0）个相同类型元素构成的有限序列。在Java中，线性表可以有多种实现方式，但本文主要讨论的是链式存储的实现，即单链表。 单链表是一种线性表的链式存储结构，它...
通俗易懂 || n 对括号可以有多少种匹配排列方式
QuantumYou的博客
04-09 2088
文章目录题目解题思路解法一解法二 题目 【（本科组）第十一届蓝桥杯省模拟赛】 由1对括号，可以组成一种合法括号序列：()。 由2对括号，可以组成两种合法括号序列：()()、(())。 由4对括号组成的合法括号序列一共有多少种？ 解题思路 首先这是一道典型的括号匹配问题 解法一 关于括号匹配问题 —> 可以运用 卡特兰数（入栈顺序解法之一） 递推公式 h(n)=C(2n,n)/(n+1) (n=0,1,2,...) 解法二 运用 递归 右括号的数量不能超过左括号 函数的两个参数分别为
贪心算法——常见试题集 (精华)
QuantumYou的博客
04-13 1115
定义 贪心算法或贪心思想采用贪心的策略，保证每次操作都是局部最优的，从而使最后得到的结果是全局最优的。（但是不一定是正确解，但是会无限逼近） 集合覆盖问题 假设存在如下表的需要付费的广播台，以及广播台信号可以覆盖的地区。 如何选择最少 的广播台，让所有的地区都可以接收到信号 核心思路 遍历所有的广播电台, 找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系） 将这个电台加入到一个集合中(比如ArrayList), 想办法把该电台覆盖的地区在下次比较时去掉。 重复第1
Java 排序算法（冒泡、选择、插入排序 ）
QuantumYou的博客
03-14 719
冒泡排序 排序原理 1、比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置 2、对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后元素就是最大 排序图解 解法 API 设计 package Sort; import java.util.Arrays; /** * @author LZH.create * Date : 2021.3.11 * API 设计思想实现 与传统实现（方式二） * */ public class BubbleS
Java 实现 DFS BFS 算法集 (精华)
QuantumYou的博客
04-08 667
介绍 参考链接 BFS (广度优先算法) 树为一种特殊的图 ---------> 树的广度优先算法（层序遍历） 层序遍历 （实现原理） —> 借助队列实现
Java 实现 n 阶行列式的求解
QuantumYou的博客
04-15 511
文章目录题目题解代码 题目 跳转链接 题解 这位大佬题解写的非常不错 ，其他栏的蓝桥杯资料也不错 ！ ???? 参考链接 运用递归思路求其余子式 这里运用 余子式 的拉普拉斯展开 求解行列式 ???? 代码 package BaseFunction; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamRe
Java数据结构复习：线性表实现与应用
"Java基础复习笔记04数据结构-线性表" 这篇复习笔记主要涵盖了Java中的数据结构——线性表。线性表是一种基本的数据结构，它包含了一组有序的元素，每个元素都有一个唯一的索引。在Java中，线性表可以由数组或链表...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值