java实现顺序表、链表、栈 (x)->{持续更新}
1.java实现节点
/**
* 节点
* @luminous-xin
* @param <T>
*/
public class Node<T> {
T data;
Node<T> next;
public Node(Node<T> n){
next = n;
}
public Node(T obj,Node<T> n){
data = obj;
next = n;
}
public T getData(){
return data;
}
public Node<T> getNext(){
return next;
}
}
2.java实现链表
/**
* 链表
* @author luminous-xin
* @param <T>
*/
public class ListLink<T> {
//头指针
private Node<T> head;
//单链表的长度
private int length; //构造一个空的链表
public ListLink() {
length = 0;
head = new Node<T>(null);
} //获取链表头节点的位置
public Node<T> getHead() {
return head;
} //在链表中插入一个元素
public boolean add(T obj, int pos) {
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return false;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
p.next = new Node<T>(obj, q);
length++;
return true; } //删除链表中某各元素
public T remove(int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return null;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return null;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
p.next = q.next;
length--;
return q.data;
} //获取链表中一个元素的值
public T value(int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return null;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return null;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
return q.data;
} //在链表中查找一个元素，返回该元素下标的索引
public int find(T obj) {
if (isEnpty()) {
System.out.println("链表为空表");
return -1;
}
int num = 1; Node<T> p = head, q = head.next;
while (q!= null) {
if (obj.equals(q.data)) {
return num;
}
p = q;
q = q.next;
num++;
}
return -1;
/* Node<T> p = head.next;
while (p != null) {
if (p.data.equals(obj) == false) {
p = p.next;
num++;
} else break; }
if (p == null) {
return -1;
}
return num;*/
} //更新链表中某各元素
public boolean modify(T obj, int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return false;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return false;
}
int num = 1;
Node<T> q = head.next;
while (num < pos) {
q = q.next;
num++;
}
q.data = obj;
return true;
} //判空
public boolean isEnpty() {
return length == 0;
} //求链表中数据元素的个数
public int size() {
return length;
} //一次访问链表中每个元素并输出
public void nextOrder() {
Node<T> q = head.next;
while (q != null) {
System.out.println(q.data);
q = q.next;
}
} //销毁一个已经存在的链表
public void clear() {
length = 0;
head.next = null;
} public static void main(String[] args) {
ListLink<Integer> l = new ListLink<>();
int i;
int a[] = {23, 56, 12, 49, 35};
for (i = 0; i < a.length; i++) {
l.add(a[i], i + 1);
}
System.out.println("单链表中的数据元素为：");
l.nextOrder();
System.out.println(l.find(5)); }
3.java实现顺序表
/**
* 顺序表
* @author luminous-xin
* @param <T>
*/
public class SequenceList<T> {
final int maxSize = 10; //顺序表中一维数组的长度
private T[] listArray; //存储元素的数组对象
private int length; //保存顺序表的当前长度
public SequenceList(){ //构造一个空的线性表
length = 0;
listArray = (T[])new Object[maxSize];
}
public SequenceList(int n){
if(n <= 0){
System.out.println("error");
System.exit(1);
}
length = 0;
listArray = (T[])new Object[n];
}
public boolean add(T obj , int pos){ //在线性表中插入一个新元素
if(pos < 1 || pos > length + 1){ //检验插入位置的有效性
System.out.println("pos不合法");
return false;
}
if(length == listArray.length){ //扩容
T[] p = (T[])new Object[length*2];
for (int i = 0; i < length; i++) {
listArray = p;
}
}
for (int i = length; i > pos; i--) { //插入
listArray[i] = listArray[i-1];
}
listArray[pos-1] = obj;
length++;
return true;
}
public T remove(int pos){ //在线性表中删除一个元素
if(isEmpty()){
System.out.println("顺序表为空，无法执行删除操作");
return null;
}else{
if(pos<1 || pos >length){
System.out.println("pos不合法");
return null;
} T x = listArray[pos-1]; //备份被删除的元素，将其作为返回值返回
for (int i = pos ; i <= length; i++) {
listArray[i-1] = listArray[i];
}
length++;
return x;
}
} public int find(T obj){ //在线性表中查找一个元素
if(isEmpty()){
System.out.println("顺序表为空");
return -1;
}else{
for(int i = 0 ; i <length ; i++){
if(listArray[i].equals(obj)){
return i + 1; //返回该元素的位置
}
}
return -1;
}
}
public T value(int pos){ //获取线性表中的一个元素
if(isEmpty()){
System.out.println("顺序表为空");
}else{
if(pos < 1 || pos > length +1){
System.out.println("pos值不合法");
}
}
return listArray[pos - 1];
}
public boolean modify(T obj,int pos){ //更新线性表中的某各元素
if(isEmpty()){
System.out.println("顺序表为空");
return false;
}else{
if(pos < 1 || pos > length ){
System.out.println("pos值不合法");
return false;
}
}
listArray[pos-1] = obj;
return true;
}
public boolean isEmpty(){ //判空
return length == 0;
}
public int size(){ //求线性表中数据元素的个数
return length;
}
public void nextOrder(){ //一次访问栈中的每个元素并输出
for(int i = 0 ; i< length; i++ ){
System.out.println(listArray[i]);
}
}
public void clear(){ //销毁一个已经存在的线性表
length = 0;
} }
4.链表的应用，合并两个有序链表
public class Chap2_2 {
public static <T extends Comparable> void MergeList_L(ListLink<T> la, ListLink<T> lb ,ListLink<T> lc){
Node<T> pa,pb,pc;
pa = la.getHead().next;
pb = lb.getHead().next;
pc = lc.getHead();
while(pa != null && pb != null){
if(pa.data.compareTo(pb.data)<0){
pc.next = pa;
pc = pa ;
pa = pa.next;
}else{
pc.next = pb;
pc = pb;
pb = pb.next;
}
while (pa != null){
pc.next = pa;
pc = pc.next;
pa = pa.next;
}
while (pb != null){
pc.next = pb;
pc = pb;
pb = pb.next;
}
la.clear();
lb.clear();
}
}
public static void main(String[] args) {
int i,j,k = 0;
int[] b = {12,23,35,49,56};
int[] a = {10,15,20};
ListLink<Integer> la = new ListLink<>();
ListLink<Integer> lb = new ListLink<>();
ListLink<Integer> lc = new ListLink<>();
for ( i = 0; i < a.length; i++) {
la.add(a[i],i+1);
}
System.out.println("单链表a中的元素为：");
la.nextOrder();
for (j = 0; j < b.length; j++) {
lb.add(b[j],j+1);
}
System.out.println("单链表b中的数据元素为：");
lb.nextOrder();
MergeList_L(la,lb,lc);
System.out.println("单链表c中的元素为：");
lc.nextOrder();
}
}
5.java实现顺序栈
/**
* 顺序栈
* @author luminous-xin
* @param <T>
*/
public class SequenceStack<T> {
final int maxSize = 10;
private T[] stackArray;
private int top;
//各方法的具体实现后有详细描述
public SequenceStack(){
top = -1;
stackArray = (T[])new Object[maxSize];
}
public SequenceStack(int n){
if(n<=0){
System.out.println("数组长度要大于零，否则退出程序运行！");
System.exit(1);
}
top = -1;
stackArray = (T[])new Object[n];
}
//在栈顶位置插入一个新元素
public void push(T obj){
if(top == stackArray.length-1){
T[] p = (T[])new Object[top*2+2];
for (int i = 0; i <= top; i++){
p[i] = stackArray[i];
}
stackArray = p;
} top++;
stackArray[top] = obj;
}
//删除栈顶元素
public T pop(){
if(top == -1) {
System.out.println("数据栈已空，无法删除元素");
return null;
}
top--;
return stackArray[top+1];
}
//取栈顶数据元素
public T getHead(){
if (top == -1){
System.out.println("数据栈已空，无法删除元素");
return null;
}
return stackArray[top];
}
//判断当前栈是否为空
public boolean isEmpty(){
return top == -1;
}
//求出栈中元素的个数
public int size(){
return top +1;
}
//依次访问栈中元素并输出
public void nextOrder(){
for(int i = top ; i >= 0;i--){
System.out.println(stackArray[i]);
}
}
//销毁一个已经存在的栈
public void clear(){
top = -1;
}
}
6.java实现链栈
/**
* 链栈
* @luminous-xin
* @param <T>
*/
public class LinkStack<T> {
private Node<T> top; //栈顶指针
private int length; //存储栈的长度
public LinkStack(){ //构造一个空的栈
length = 0;
top = null;
}
public void push(T obj){ //入栈
top = new Node<T>(obj,top);
length++;
}
public T pop(){ //出栈
if(top == null){
System.out.println("栈已空，无法删除");
return null;
}
T x = top.data;
top = top.next;
length--;
return x;
}
public T getHead(){ //取栈顶元素
if(top == null){
System.out.println("栈已空，无法删除");
return null;
}
return top.data;
}
public int size(){ //求出栈中元素的个数
return length;
}
public boolean isEmpty(){ //判断栈是否为空
if (top ==null){
return true;
}
return false;
}
public void nextOrder(){ //便利栈
Node<T> p = top;
while (p != null){
System.out.println(p.data);
p = p.next;
}
} public void clear(){ //销毁一个栈
top = null;
}
}
7.java实现顺序链表
import org.omg.CORBA.Object; /**
* 循环队列
* @author luminous
* @param <T>
*/
public class SequenceQueue<T> {
final int maxSize = 10;
private T queueArray[];
private int front, rear; public SequenceQueue() {
rear = front = 0;
queueArray = (T[]) new Object[maxSize];
} public void enQueue(T obj) { //入队
if ((rear + 1) % queueArray.length == front) {
T[] p = (T[]) new Object[queueArray.length * 2];
if (rear == ((T[]) queueArray).length) {
for (int i = 0; i <= rear; i++) {
p[i] = queueArray[i];
}
} else {
int i,j = 1;
for (i = front + 1; i<queueArray.length;i++,j++)
p[j] = queueArray[i];
for (i = 0;i<= rear ; i++,j++)
p[j] = queueArray[i];
front = 0;
rear = queueArray.length-1;
}
queueArray = p;
}
rear = (rear+1)%queueArray.length;
queueArray[rear] = obj;
}
public T DeQueue(){ //出队
if(isEmpty()){
System.out.println("队列已空，无法出队！");
return null;
}
front = (front +1)%queueArray.length;
return queueArray[front]; }
public T getTop(){ //取出头元素
if(isEmpty()){
System.out.println("队列已空，无法读取元素！");
return null;
}
return queueArray[(front+1)%queueArray.length] ;
}
public boolean isEmpty(){ //队列的非空队列
return front==rear;
}
public int size(){ //求队列长度
return (rear - front +queueArray.length)%queueArray.length;
}
public void nextOrder(){ //遍历队列
int i,j = front ;
for (i = 1; i < size(); i++) {
j = (j+1)%queueArray.length;
System.out.println(queueArray[j]); }
}
public void clear(){ //清空队列
front = rear =0;
}
}
java实现顺序表、链表、栈 (x)->{持续更新}的更多相关文章
- 线性表 及Java实现 顺序表、链表、栈、队列
数据结构与算法是程序设计的两大基础,大型的IT企业面试时也会出数据结构和算法的题目, 它可以说明你是否有良好的逻辑思维,如果你具备良好的逻辑思维,即使技术存在某些缺陷,面试公司也会认为你很有培养价值, ...
- Java实现顺序表
利用顺序存储结构表示的顺序表称为顺序表. 它用一组连续的地址存储单元一次存放线性表中的数据元素. 顺序表的实现是数据结构中最简单的一种. 由于代码中已经有详细注释,代码外不再阐述. 下次再陈上关于顺序 ...
- C# 数据结构 线性表（顺序表 链表 IList 数组）
线性表 线性表是最简单.最基本.最常用的数据结构.数据元素 1 对 1的关系,这种关系是位置关系. 特点 (1)第一个元素和最后一个元素前后是没有数据元素,线性表中剩下的元素是近邻的,前后都有元素. ...
- 数据结构——Java实现顺序表
一.分析 什么是顺序表?顺序表是指用一组地址连续的存储单元依次存储各个元素,使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表.一个标准的顺序表需要实现以下基本操作: 1.初始化顺序表 ...
- 学生信息管理系统-顺序表&&链表（数据结构第一次作业）
实验目的 : 1 .掌握线性表的定义: 2 .掌握线性表的基本操作,如建立.查找.插入和删除等. 实验内容: 定义一个包含学生信息(学号,姓名,成绩)的的 顺序表和链表,使其具有如下功能: (1) 根 ...
- (java实现)顺序表-ArrayList
什么是顺序表 顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构. 在使用顺序表存储数据前,会先申请一段连续的内存空间(即数组),然后把数组依次存入 ...
- Java数据结构——顺序表
一个线性表是由n(n≥0)个数据元素所构成的有限序列. 线性表逻辑地表示为:(a0,a1,…,an-1).其中,n为线性表的长度,n=0时为空表.i为ai在线性表中的位序号. 存储结构:1.顺序存储, ...
- Java算法 -- 顺序表
顺序表结构定义:就是按照顺序存储方式存储的线性表 1.定义一个顺序表的基本数据: static final int MAXLEN = 100; Class Student{ private Strin ...
- Java日常错误及需要注意细节，持续更新......
记录日常工作中一些容易被忽视的错误及细节,持续更新...... 一.问题:HashMap<Long, String>中,用get(Integer key)取不到值 Map<Long, ...
随机推荐
- phpmyadmin上在某数据库里创建函数
改那个PHP项目加了个功能,本地MYSQL里添加了一个函数了,现在要转到服务器上,然后服务器上的MYSQL只能通过PHPMYADMIN网页操作的,在网页上SQL里输入创建函数的语句, 结果报错了:th ...
- SpringCloud 微服务中 @Async 注解自定义线程池 引发的aop 问题
背景 在 使用springCloud 的@Async注解来做异步操作时,想自定义其线程池. 引发问题 自定义完线程池后,发现代码里并没有使用自定义线程池里的线程,于是新建一个demo工程,一样的配置代 ...
- java读取IFC文件
The IFC JAVA Toolbox can read IFC STEP files and IFCZIP files from any data source that implementsja ...
- Operation之变换操作符
buffer buffer方法的作用是缓冲组合, 第一个参数是缓冲时间, 第二个参数是缓冲个数, 第三个参数是线程 该方法简单来说就是缓存Observable中发出的新元素, 当元素达到某个数量, 或 ...
- 金钱数友好显示 php版本
2019年6月28日16:35:10 此方法可扩展性较好 /* * 吧金额数字转成可视化的方便读的汉字表述 */ function amountConversion(float $amount = 0 ...
- Jenkins集成TestNG
1.Jenkins安装插件 TestNG Results Plugin 2. 添加配置 “构建后操作”->“Publish TestNG Results” 保持默认配置即可 3.查看报告 项目构 ...
- solr添加中文IK分词器,以及配置自定义词库
Solr是一个基于Lucene的Java搜索引擎服务器.Solr 提供了层面搜索.命中醒目显示并且支持多种输出格式(包括 XML/XSLT 和 JSON 格式).它易于安装和配置,而且附带了一个基于H ...
- Docker Overview
Docker 是一个用于开发.交付和运行应用的开放平台,Docker 设计用来更快的交付你的应用程序.Docker 可以将你的应用程序和基础设施层隔离,并且还可以将你的基础设施当作程序一样进行管理.D ...
- 【记录】【java】JDK8新特性Stream方式遍历集合
由于是以流方式,所以怎么操作也不改变原来的集合 1.普通遍历forEach List<String> list = new ArrayList(); list.add("a&qu ...
- Excel在数据表中悬停鼠标显示数据值
打开一个实例文档,鼠标移动到数据表中,在柱状图上中悬停鼠标,可以看到没有显示数据的值. 鼠标单击左上角的<文件>按钮. 然后单击<选项>按钮. 在弹出的excel选项对话框中单 ...