【数据结构】——线性表 (顺序存储和基于Java的运算实现)

int listSize = 100;

//类型未知，设定为Object，数组data存放表结点

Object[] data = new Object[listSize];

//线性表的当前表长：实际存储元素的个数

int count = 0;

//置空表：表中所有元素都置为null

public void InitList() {

for (int i = 0; i < listSize; i++) {

data[i] = null;

}

count = 0;

}

//求表长：返回表中元素个数

public int ListLength() {

return count;

}

//查找：取表中第i个元素

public Object GetNode(int i) {

//判断是否索引越界

if (i < 1 || i > listSize) {

System.out.println(“position error!”);

return null;

} else {

return data[i - 1];

}

}

//查找：查找第一个值为x的元素，并返回其位置

public int LocateNode(Object x) {

int index = -1;

for (int i = 0; i < listSize; i++) {

if (data[i].equals(x)) {

index = i;

break;

}

}

if (index != -1)

index++;

return index;

}

//插入：在顺序表L中第i个位置之前插入一个新元素x

public void InsertList(int i, int x) {

//判断插入的位置是否合法

if (i < 1 || i > listSize) {

System.out.println(“position error!”);

}

//判断表的长度是否超出限制

if (count >= listSize) {

System.out.println(“overflow!”);

}

//循环插入位置后面的元素

for (int j = count - 1; j >= i - 1; j–) {

//从最后一个元素开始逐一往后移

data[j + 1] = data[j];

}

//插入新元素x

data[i - 1] = x;

//表中实际长度加1

count++;

}

//删除：删除第i个元素,并返回该元素

public Object deleteList(int i) {

//判断删除的位置是否合法

if (i < 1 || i > count) {

System.out.println(“position error!”);

System.exit(0);

}

//获取被删除元素

Object x = data[i - 1];

//从被删除元素开始，向前循环移动后面的元素

for (int j = i; j <= count; j++) {

data[j - 1] = data[j];

}

//表中实际长度减1

count–;

return x;

}

}

测试：

public class SeqListTest {

public static void main(String[] args) {

SeqList sl = new SeqList();

//置空表

sl.InitList();

System.out.println(sl.data[0] + " " + sl.data[99]);

System.out.println(“length：” + sl.data.length);

System.out.println(“count：”+sl.count);

System.out.println();

//插入元素

sl.InsertList(1, 2);

sl.InsertList(2, 4);

sl.InsertList(3, 6);

sl.InsertList(4, 8);

//遍历表中元素

System.out.print(“表中元素有：”);

for (int i = 0; i < sl.count; i++) {

System.out.print(sl.data[i] + " ");

}

System.out.println();

//求表长

int count = sl.ListLength();

System.out.println(“元素个数：” + count);

System.out.println();

//查找（按位置）

Object o = sl.GetNode(4);

System.out.println(“第4个元素：” + o);

System.out.println();

//查找（按值）

Object o1 = sl.LocateNode(6);

System.out.println(“值为6的下标：” + o1);

System.out.println();

//删除

Object o2 = sl.deleteList(3);

System.out.println(“删除的元素为：” + o2);

System.out.print(“表中元素：”);

for (int i = 0; i < sl.count; i++) {

System.out.print(sl.data[i] + " ");

}

System.out.println();

//求表长

int count1 = sl.ListLength();

System.out.println(“元素个数：” + count1);

}

}

运行结果：

其他运算

---

线性表逆置

**说明：**线性表为 (a1,a2,…,a(n))，逆置之后为 (a(n),a(n-1),…,a1)，以顺序表存储方式存储。

**基本思想：**以表长的一半控制循环次数，将表中最后一个元素同顺数第一个数交换，将倒数第二个元素同顺数第二个元素交换，以此类推，直至交换完为止。

代码实现：

public class SeqListTest {

public static void main(String[] args) {

    SeqList sl = new SeqList();

    //置空表

    sl.InitList();

    //插入元素

    sl.InsertList(1, 2);

    sl.InsertList(2, 4);

    sl.InsertList(3, 6);

    sl.InsertList(4, 8);

    sl.InsertList(5, 10);

    sl.InsertList(6, 12);

    //遍历初始元素

    System.out.println("初始元素：");

    for (int i = 0; i < sl.count; i++) {

        System.out.print(sl.data[i] + " ");

    }

    System.out.println();

    System.out.println();

    //逆置

    Converts(sl);

    //遍历逆置后的元素

    System.out.println("逆置后的元素：");

    for (int i = 0; i < sl.count; i++) {

        System.out.print(sl.data[i] + " ");

    }

}

//线性表逆置

public static Object[] Converts(SeqList seqList) {

    Object x;

    //获取表长的一半

    int k = seqList.count / 2;

    for (int i = 0; i < k; i++) {

        //获取前面元素的值，赋值给x

        x = seqList.data[i];

        //将后面对应的值赋值给前边的元素

        seqList.data[i] = seqList.data[seqList.count - i - 1];

        //将x的值赋值给后边的元素

        seqList.data[seqList.count - i - 1] = x;

    }

    return seqList.data;

}

}

运行结果：

温馨提示：

线性表逆置该方法里for语句里执行的三条基本语句是交换两个数值的常用语句，这个点可以记死，固定写法，非常好用。

顺序表找最大最小值

**说明：**找出最大值和最小值的元素及其所在位置。

代码实现：

public class SeqListTest {

public static void main(String[] args) {

    SeqList sl = new SeqList();

    //置空表

    sl.InitList();

    //插入元素

    sl.InsertList(1, 7);

    sl.InsertList(2, 4);

    sl.InsertList(3, 12);

    sl.InsertList(4, 24);

    sl.InsertList(5, 18);

    sl.InsertList(6, 6);

    //遍历初始元素

    System.out.println("初始元素：");

    for (int i = 0; i < sl.count; i++) {

        System.out.print(sl.data[i] + " ");

    }

    System.out.println();

    System.out.println();

    //获取最大值和最小值及其索引

    int[] ints = MaxAndMin(sl);

    System.out.println("最大值索引:" + ints[0] + "  最大值：" + ints[1]);

    System.out.println("最小值索引:" + ints[2] + "  最小值：" + ints[3]);

}

//找出最大值和最小值，及其下标

public static int[] MaxAndMin(SeqList seqList) {

    //定义一个数组，存放最大值、最小值及其索引

    int[] index = new int[4];

    //设置最大值和最小值的索引值

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。

《Java高级面试》

《Java高级架构知识》

《算法知识》

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-VQzYGqQF-1712882634495)]

最后

分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。

《Java高级面试》

[外链图片转存中…(img-LoOAR2Nm-1712882634495)]

《Java高级架构知识》

[外链图片转存中…(img-OL5UEoGh-1712882634495)]

《算法知识》

[外链图片转存中…(img-NaTYGRc9-1712882634495)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-5xJRcPrh-1712882634496)]