Java数据结构--线性表

本文提供了一个Java程序示例,展示了如何实现简单的顺序表操作,包括初始化、添加、删除结点等基本功能,并通过具体代码说明了这些操作的具体实现方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

import java.util.Scanner;


class DATA
{
    String key;                 //结点的关键字 
    String name;
    int age;
} 

class SLType                //定义顺序表结构
{   
    static final int MAXLEN=100;
    DATA[] ListData=new DATA[MAXLEN+1]; //保存顺序表的结构数组 
    int ListLen;                    //顺序表已存结点的数量 

    void SLInit(SLType SL)          //初始化顺序表
    {
        SL.ListLen=0;               //初始化为空表
    }

    int SLLength(SLType SL)         
    {
        return (SL.ListLen);            //返回顺序表的元素数量
    }

    int SLInsert(SLType SL,int n,DATA data)
    {
        int i;
        if(SL.ListLen>=MAXLEN)      //顺序表结点数量已超过最大数量 
        {
            System.out.print("顺序表已满,不能插入结点!\n");
            return 0;               //返回0表示插入不成功 
        }
        if(n<1 || n>SL.ListLen-1)   //插入结点序号不正确
        {
            System.out.print("插入元素序号错误,不能插入元素!\n");
            return 0;               //返回0,表示插入不成功 
        } 
        for(i=SL.ListLen;i>=n;i--)      //将顺序表中的数据向后移动 
        {
            SL.ListData[i+1]=SL.ListData[i]; 
        }
        SL.ListData[n]=data;            //插入结点 
        SL.ListLen++;               //顺序表结点数量增加1 
        return 1;                   //成功插入,返回1
    }

    int SLAdd(SLType SL,DATA data)  //增加元素到顺序表尾部
    {
        if(SL.ListLen>=MAXLEN)      //顺序表已满 
        {
            System.out.print("顺序表已满,不能再添加结点了!\n");
            return 0;    
        }
        SL.ListData[++SL.ListLen]=data;
        return 1;
    }

    int SLDelete(SLType SL,int n)   //删除顺序表中的数据元素 
    {
        int i;
        if(n<1 || n>SL.ListLen+1)   //删除结点序号不正确
        {
            System.out.print("删除结点序号错误,不能删除结点!\n");
            return 0;               //删除不成功,返回0
        } 
        for(i=n;i<SL.ListLen;i++)   //将顺序表中的数据向前移动 
        {
            SL.ListData[i]=SL.ListData[i+1]; 
        }
        SL.ListLen--;                   //顺序表元素数量减1 
        return 1;                       //成功删除,返回1
    }

    DATA SLFindByNum(SLType SL,int n)  //根据序号返回数据元素
    {
        if(n<1 || n>SL.ListLen+1)       //元素序号不正确
        {
            System.out.print("结点序号错误,不能返回结点!\n");
            return null;                //不成功,则返回0
        } 
        return SL.ListData[n];
    }

    int SLFindByCont(SLType SL,String key)          //按关键字查询结点 
    {
        int i;
        for(i=1;i<=SL.ListLen;i++)
        {
            if(SL.ListData[i].key.compareTo(key)==0)    //如果找到所需结点 
            {
                return i;                           //返回结点序号 
            }
        }
        return 0;                               //搜索整个表后仍没有找到,则返回0 
    }

    int SLAll(SLType SL)                        //显示顺序表中的所有结点 
    {
        int i;
        for(i=1;i<=SL.ListLen;i++)
        {
            System.out.printf("(%s,%s,%d)\n",SL.ListData[i].key,SL.ListData[i].name,SL.ListData[i].age);
        }
        return 0;
    }
}

public class P2_1 {
    public static void main(String[] args) {
        int i;
        SLType SL=new SLType();                 //定义顺序表变量 
//      DATA data=new DATA();                   //定义结点保存数据类型变量
        DATA pdata;             //定义结点保存指针变量 
        String key;                 //保存关键字

        System.out.print("顺序表操作演示!\n"); 

        SL.SLInit(SL);                  //初始化顺序表 
        System.out.print("初始化顺序表完成!\n");

        Scanner input=new Scanner(System.in);

        do 
        {                           //循环添加结点数据 
            System.out.print("输入添加的结点(学号 姓名 年龄):"); 
            DATA data=new DATA();  
            data.key=input.next();
            data.name=input.next();
            data.age=input.nextInt();

            if(data.age!=0)               //若年龄不为0 
            {
                if(SL.SLAdd(SL,data)==0)   //若添加结点失败 
                {
                    break;            //退出死循环 
                }
            }
           else                 //若年龄为0 
           {
                break;                  //退出死循环
           }
        }while(true);
        System.out.print("\n顺序表中的结点顺序为:\n");
        SL.SLAll(SL);                  //显示所有结点数据 


        System.out.print("\n要取出结点的序号:");
        i=input.nextInt();               //输入结占点序号    
        pdata=SL.SLFindByNum(SL,i);  //按序号查找结点 
        if(pdata!=null)                 //若返回的结点指针不为NULL
        { 
            System.out.printf("第%d个结点为:(%s,%s,%d)\n",i,pdata.key,pdata.name,pdata.age);
        }


        System.out.print("\n要查找结点的关键字:");
        key=input.next();           //输入关键字     
        i=SL.SLFindByCont(SL,key);     //按关键字查找 ,返回结点序号 
        pdata=SL.SLFindByNum(SL,i);   //按序号查询,返回结点指针 
        if(pdata!=null)                     //若结点指针不为NULL 
        {
            System.out.printf("第%d个结点为:(%s,%s,%d)\n",i,pdata.key,pdata.name,pdata.age);  
        }


    }

}
### Java 线性表数据结构设计与实现 #### 一、线性表概述 线性表是一种基本的数据结构,其特点是元素之间存在一对一的关系。在线性表中,除了第一个和最后一个元素外,其他每个元素都有唯一的一个前驱和后继。 #### 二、顺序表实现 顺序表是线性表的一种存储方式,在内存中占用连续的空间来保存各个节点的信息。下面是一个简单的顺序表示例: ```java public class ArrayLinearList { private Object[] elements; private int size; public ArrayLinearList() { this.elements = new Object[10]; this.size = 0; } // 添加元素到列表末尾 public boolean add(Object element) { ensureCapacity(size + 1); elements[size++] = element; return true; } // 获取指定位置上的元素 public Object get(int index) { checkIndex(index, false); return elements[index]; } // 移除并返回指定索引处的元素 public Object remove(int index){ rangeCheck(index); Object oldValue = elements[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elements, index+1, elements, index, numMoved); elements[--size] = null; // Let gc do its work return oldValue; } // 扩展数组容量以容纳更多元素 private void ensureCapacity(int minCapacity) { if(minCapacity >= elements.length){ @SuppressWarnings("unchecked") Object[] oldElements = elements; elements = new Object[Math.max(2 * elements.length,minCapacity)]; System.arraycopy(oldElements, 0, elements, 0,oldElements.length ); } } // 检查给定索引是否有效 private void checkIndex(int index,boolean isAddOperation){ if(isAddOperation &&index>size || !isAddOperation&&index>=size||index<0){ throw new IndexOutOfBoundsException(); } } } ``` 此代码展示了如何创建一个基于数组的顺序表类 `ArrayLinearList`[^1]。 #### 三、链表实现 链表也是一种常见的线性表实现形式,它由一系列结点组成,这些结点不必在物理上相邻存放在一起;而是通过指针链接起来形成逻辑上的序列关系。以下是单向链表的具体实现: ```java class Node<T>{ T data; Node next; public Node(T data){ this.data=data; this.next=null; } } public class SinglyLinkedList<T> { private Node head; private int length; public SinglyLinkedList(){ this.head=null; this.length=0; } // 向链表头部插入新节点 public void insertAtBeginning(T newData){ Node newNode=new Node(newData); newNode.next=head; head=newNode; length++; } // 删除头节点 public T deleteFromBeginning(){ if(head==null)return null; T temp=(T)(head.data); head=head.next; length--; return temp; } // 显示整个链表的内容 public String toString(){ StringBuilder sb=new StringBuilder("["); Node current=head; while(current!=null){ sb.append(current.data.toString()); if(current.next != null)sb.append(", "); current=current.next; } sb.append("]"); return sb.toString(); } } ``` 这段代码定义了一个泛型化的单向链表类 `SinglyLinkedList`, 并实现了几个常用的操作函数[^2]. 对于双向链表,则是在上述基础上增加了对前后两个方向的支持,即每个节点不仅有指向下一个节点的引用(`next`)还有指向前一个节点的引用(`prev`). 这样可以更方便地遍历链表以及执行某些特定操作. 最后需要注意的是,无论是哪种类型的线性表,在实际应用过程中都需要考虑边界条件处理(比如越界访问)、异常情况下的健壮性和性能优化等问题.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值