javaseqlist的简单介绍
本篇文章给大家谈谈javaseqlist，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java编程中SeqList list=new SeqList(number);需要符号？什么意思？
- 2、麻烦问一下 如何在java中用代码实现arraylist类的功能？？
- 3、用java编写一个数据结构的题！
- 4、JAVA如何添加判断线性表为0否则输出线性表长度
- 5、java怎么定义链表组?
java编程中SeqList list=new SeqList(number);需要符号？什么意思？
不知道SeqList 这个是你定义的类吗？ list.append？什么方法。 改成下面的就行了
import java.util.ArrayList;
import java.util.List;
public class Josephus {
public Josephus(int number, int start, int distance) {
ListString list = new ArrayListString(number);
for (int i = 0; i number; i++)
list.add((char) ('A' + i) + "");
System.out
.print("约瑟夫环(" + number + "," + start + "," + distance + "),");
System.out.print(list.toString());
int i = start;
while (list.size() 1) {
i = (i + distance - 1) % list.size();
System.out.print("删除" + list.remove(i).toString() + ",");
System.out.print(list.toString());
}
System.out.print("被赦免者是" + list.get(0).toString());
}
public static void main(String args[]) {
new Josephus(5, 0, 2);
}
}
麻烦问一下 如何在java中用代码实现arraylist类的功能？？
package com.nishizhen.list;
public interface List {
public void insert(int i,Object obj)throws Exception;
public void delete(int i)throws Exception;
public Object getData(int i)throws Exception;
public int size();
public boolean isEmpty();
}
顺序表：
顺序表插入一个元素需要移动元素的平均次数为n/2次，删除一个元素需要移动元素次数为(n-1)/2，所以顺序表的时间复杂度为O（n）。
顺序表的实现如下
package com.nishizhen.list;
public class SeqList implements List{
final int defaultSize = 10;
int maxSize;//顺序表的最大长度
int size;//线性表当前长度
Object[] listArray;//存储线性表元素的数组
public SeqList(int size){
initiate(size);
}
public SeqList(){
initiate(defaultSize);
}
public void initiate(int sz){
maxSize = sz;
size = 0;
listArray = new Object[sz];
}
public void insert(int i,Object obj)throws Exception{
if(size == maxSize){
throw new Exception("顺序表已满，不能再插入元素。");
}
if(i0 || imaxSize){
throw new Exception("参数有误。");
}
else{
for(int j=size;j=i;j--){
listArray[j] = listArray[j-1];
}
listArray[i] = obj;
size++;
}
}
public void delete(int i)throws Exception{
if(size == 0){
throw new Exception("顺序表为空，无法进行删除元素操作。");
}
if(i0 || i=size){
throw new Exception("参数出错。");//数组下标不能小于0或者大于size，因为size及其以后的元素为空。
}
else{
for(int j=size-1;j=i;j--){
listArray[j-1] = listArray[j];
}
listArray[listArray.length-1] = "";
size--;
}
}
public Object getData(int i)throws Exception{
if(size == 0){
throw new Exception("顺序表为空，无法返回元素。");
}
if(10 || i=size){
throw new Exception("参数出错。");//数组下标不能小于0或者大于size，因为size及其以后的元素为空。
}
else{
return listArray[i];
}
}
public int size(){
return listArray.length;
}
public boolean isEmpty(){
boolean flag = false;
if(listArray.length==0){
flag = true;
}
return flag;
}
}
单链表：
指针是指一个数据元素逻辑意义上的存储位置，链式存储机构是基于指针实现的，每一个节点由一个数据元素和一个指针构成。链式存储结构是用指针把相互关联的元素链接起来。
在单链表中，每个节点只有一个直接只想后继元素的指针，而双向链表中每个节点有两个指针，一个只想后继节点一个只想前驱节点。
单链表的实现
节点类：
package com.nishizhen.list;
public class Node {
Object element;
Node next;
Node(Node nextval){
next = nextval;
}
Node(Object obj,Node nextval){
element = obj;
next = nextval;
}
public Node getNext(){
return next;
}
public void setNext(Node nextval){
next = nextval;
}
public Object getElement(){
return element;
}
public void setElement(Object obj){
element = obj;
}
public String toString(){
return element.toString();
}
}
单链表类：
package com.nishizhen.list;
public class LinList implements List{
Node head;//头指针
Node current;//当前操作的节点位置
int size;//数据元素个数
LinList(){
head = current = new Node(null);
size = 0;
}
public void index(int i) throws Exception{
if(i-1 || isize-1){
throw new Exception("参数出错");
}
if(i==-1){
return;
}
current = head.next;
int j = 0;
while((current !=null)ji){
current = current.next;
j++;
}
}
public void insert(int i,Object obj)throws Exception{
if(10 || i=size){
throw new Exception("参数错误");
}
index(i-1);
current.setNext(new Node(obj,current.next));
size++;
}
public void delete(int i)throws Exception{
if(size==0){
throw new Exception("链表已空");
}
if(10 || i=size){
throw new Exception("参数错误");
}
index(i-1);
Object obj = current.next.getElement();
current.setNext(current.next.next);
用java编写一个数据结构的题！
线性表跟是不是数组没关系啊。。。栈和队列都是线性表吧。。不太懂你的意思。。
public class SeqList {
public static void main(String[] args) {
int[] a = new int[]{1,2,3,4,5,6,7};
int[] b = new int[]{3,5,8,9};
int[] c = new int[a.length + b.length];
new SeqList().seqListMerge(a, b, c);
}
public void seqListMerge(int[] a, int[] b, int[] c){
//i为数组a的计数器
int i = 0;
//j为数组b的计数器
int j = 0;
//k为数组c的计数器
int k = 0;
//判断两个数组长度，当一个先用完的时候推出循环
while(i a.length j b.length){
if(a[i] b[j]){
c[k] = b[j];
k++;
j++;
}else{
c[k] = a[i];
k++;
i++;
}
}
//如果a数组先到结尾，那么把b数组的剩下的值拼到c里
if( i == a.length){
while(j b.length){
c[k] = b[j];
k++;
j++;
}
}
//如果b数组先到结尾，那么把a数组的剩下的值拼到c里
if(j == b.length){
while(i a.length){
c[k] = a[i];
k++;
i++;
}
}
for(int p : c){
System.out.println(p);
}
}
}
JAVA如何添加判断线性表为0否则输出线性表长度
package ba;
//线性表抽象数据类型的java接口定义
interface List
{
public boolean isEmpty(); //接口方法1：判断线性表是否为空
public void insert(int i ,int element) throws Exception; //接口方法2：在线性表的指定位置插入数据元素
public int remove(int i) throws Exception; //接口方法3：删除线性表中指定位置的数据元素
public int getData(int i) throws Exception; //接口方法4：获取线性表中指定位置的数据元素
public int length(); //接口方法5：获取线性表的长度（数据元素的个数）
}
//顺序表类SeqList，实现线性表接口
class SeqList implements List
{
//在实现接口的类中定义成员变量
private int[] listArray; //定义数组：listArray，用于保存线性表中的数据元素
final int defaultSize=10; //定义常量：defaultSize，用于指定线性表的默认长度
private int size; //定义变量：size，用于描述线性表中的数据元素的个数（线性表的长度）
private int maxSize; //定义变量：maxSize，用于描述线性表中最大数据元素的个数（线性表的最大长度）
//在实现接口的类中定义成员方法
//构造方法
//定义函数：initiate()
public void initiate(int sz)
{
maxSize=sz;
size=0;
listArray=new int[sz]; //创建一个整型数组！！！
}
public SeqList() //不带参数的构造方法
{
initiate(defaultSize);
}
public SeqList(int capacity) //带一个参数的构造方法
{
initiate(capacity);
}
//成员方法：清空线性表
public void clear()
{
this.size=0;
}
//实现 接口中定义的方法
public boolean isEmpty() //接口方法1：判断线性表是否为空
{
return this.size==0; //说明：==：是逻辑判断是否相等，如果相等返回值布尔值：真 true（1）,否则返回假 false 0
}
public void insert(int index ,int element) throws Exception //接口方法2：在线性表的指定位置插入数据元素
//加载异常事务处理方法
{
if(size==maxSize)
{
throw new Exception("顺序表已满，无法插入！"); //如果程序中需要将存在的异常事件抛出，则必须事先加载异常处理的方法
//抛出异常
}
if(index0 || indexsize)
{
throw new Exception("参数错误！");
}
for(int j=size;jindex;j--)
{
listArray[j]=listArray[j-1];
}
listArray[index]=element;
size++;
}
public int remove(int i) throws Exception //接口方法3：删除线性表中指定位置的数据元素
{
if(size==0)
{
throw new Exception("顺序表已空，无法删除！");
}
if(i0 || isize-1)
{
throw new Exception("参数错误！");
}
int it =listArray[i];
for(int j=i;jsize-1;j++)
{
listArray[j]=listArray[j+1];
}
size--;
return it; //将删除数据元素后新的数组??
}
//获取线性表中指定位置的数据元素
public int getData(int i) throws Exception //接口方法4：获取线性表中指定位置的数据元素
{
return listArray[i];
}
//求线性表的长度
public int length() //接口方法5：获取线性表的长度（数据元素的个数）
{
return size;
}
}
public class test { //定义public类：（1）在创建项目时指定的类
public static void main(String args[]) //（2）main方法应当在public类中
{
SeqList seqList = new SeqList(100);
//定义类的对象。在定义类的对象时，通过调用构造方法对类的成员变量进行赋值
//如果一个类中存在多个构造方法时，称为构造方法重载。
//调用构造方法时，由系统根据所调用的构造方法的参数个数和数据类型自动调用与之相匹配的构造方法
int n=10;
try //try语句中的内容是指：需要对程序运行的异常事件进行捕获
{
for(int i=0;i=n;i++)
{
seqList.insert(i,(i+1)); //通过类的对象调用类的成员方法
}
seqList.remove(4);
for(int i=0;in;i++)
{
System.out.println(seqList.getData(i)+" ");
}
//请在此添加判断线性表是否为空，如果为空，则提示用户线性表为空，否则输出线性表的长度
}
catch(Exception e) //catch语句的作用是：将try语句中捕获的异常内容抛出
{
System.out.println(e.getMessage());
}
}
}
如何在这程序中添加
java怎么定义链表组?
可以，给你个实例——
import java.util.ArrayList;
import java.util.List;
public class Two {
public static void main(String[] args) {
List[] list = new List[3];
for (int i=0; ilist.length; i++) {
list[i] = new ArrayList();
}
list[1].add("sss");
System.out.println(list[1].get(0));
}
}
关于javaseqlist和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。