设计一个java函数，在数组的第i个下标前插入一个数据元素，并保持数组元素的连续性... 哪位大侠指点我哈.

Posted 2023-04-10

public class ArrayTest
public static void main(String[] args)
int[] array=new int[]1,2,4,5;
System.out.println("before...");
for(int i=0;i<array.length;i++)
System.out.println(array[i]);


array=insert(array,2,3);

System.out.println("after...");
for(int i=0;i<array.length;i++)
System.out.println(array[i]);



public static int[] insert(int[] array,int n,int num)
int[] newArr=new int[array.length+1];
for(int i=newArr.length-1;i>=0;i--)
newArr[i]=i>=n?array[i-1]:array[i];

newArr[n]=num;
return newArr;

参考技术A List
有空贴程序.

Java 3:顺序表的操作

顺序表常见操作有插入、删除、查找、修改。

一、插入：

1.插入有头插、尾插、任意位置插入。在插入时要注意下标的取值在顺序表长度范围内。所以最好在插入之前进行扩容操作。
2.在头插时要注意先将原数组的元素从后往前依次向后移动。因为如果从前往后开始移动的话，会造成后一个元素被前一个元素覆盖，而丢失数据且造成重复。arr[i+1]=arr[i],注意此处i的意思是要移动的元素的下标。
3.任意位置插入与头插类似，从后往前（要插入的位置元素下标）依次向后移动，再将数据插入

二.删除

1.删除有头删、尾删、任意位置删除，要注意删除前，原顺序表是否为空的异常情况。
2.头删与头插相反，是从前往后依次向前移动，即后一个元素arr[i+1]覆盖前一个元素arr[i].arr[i]=arr[i+1]
3.不论查找还是删除，在确定循环语句的初始值和条件时都要仔细思考可取范围

三.查找和修改

查找和修改要注意目标位置的下标不能越界

四.扩容

在java语言中，扩容一般扩为原来的1.5倍，是一种习惯的规范，不是死规则。
最后，附上完整代码，包括初始化、插入、删除、查找、修改、扩容、删除顺序表的相同元素。

import java.util.Arrays;
public class SeqList1
    private int[] array;
    private int size;
    //1.初始化,构造函数
    public  SeqList1()
        array=new int[11];
        size=0;
    
    //2.头插
    public void pushFront(int element)
        ensureCapacity();
        for(int i=size-1;i>=0;i--)// i代表的数据元素的下标，从后往前移动
            array[i+1]=array[i];
        
        array[0]=element;
        size++;
    
    //3.尾插
    public void pushBack(int element)
        ensureCapacity();
        array[size++]=element;
    

    //4.中间插 
    public void insert(int index,int element)
        if(index<0||index>size)
            System.out.println("下标异常，不能插入");
        
        ensureCapacity();
        for(int i=size;i>=index;i--)
            array[i+1]=array[i];
        
        array[index]=element;
        size++;
    

    //5.头删
    public void popFront()
        if(size==0)
        System.out.println("空表");
        
        for(int i=0;i<size;i++)
            array[i]=array[i+1];
        
        size--;
    

    //6.尾删
    public void popBack()
        if(size==0)
    System.out.println("空表");
        
    size--;
    //7.中间删
    public void erase(int index)
        if(index<0||index>=size)
            System.out.println("下标异常,不能删除");
        
        for(int i=index;i<size;i++)
            array[i]=array[i+1];
        
        size--;
    

    //8.查找
    public int indexOf(int element)
        for(int i=0;i<size;i++)
            if(array[i]==element)
                return i;
            
        
            return -1;
    
    //9.根据下标，获取元素
    public int get(int index)
    if(index<0||index>=size)
        System.out.println("下标异常");
    
    for(int i=0;i<size;i++)
        if(array[i]==array[index])
            return array[i];
        
    
            return -1;


    //10.给定下标，修改元素的值
    public void set(int index,int element)
        for(int i=0;i<size;i++)
            if(i==index)
                array[i]=element;
            
        
    
    //11.显示当前表中元素长度
    public int size()
        return size;
    
    //12.判断表是否为空
    public boolean isEmpty()
        return size==0;
    
    //13.查询表的容量
    public int capacity()
        return array.length;
    
    //14.打印显示表中已有元素
    public String toString()
        return Arrays.toString(
        Arrays.copyOf(array,size));
    
    //15.删除表中的一个元素
    public void remove(int element)
        int index=indexOf(element);
        if(index!=-1)
            erase(index);
        
    
    //16.删除表中相同元素
    public void removeAll(int element)
        int j=0;
        for(int i=0;i<size;i++)
            if(array[i]!=element)
                array[j++]=array[i];
            
        
        size=j;
    
    //17.扩容
    private void ensureCapacity()
        if(size<array.length)
            return ;
        
        //申请空间
        int newCapacity=array.length+array.length/2;
        int[] newArray=new int[newCapacity];
       //搬家
       for(int i=0;i<array.length;i++)
           newArray[i]=array[i];
       
       //官宣
       this.array=newArray;

    public static void test1(String [] args)
        SeqList1 sq = new SeqList1();
        //[]
        System.out.println(sq.toString());
        //头插1 2 3
        sq.pushFront(1);
        sq.pushFront(2);
        sq.pushFront(3);
        System.out.println(sq.toString());
        //尾插10，20，30
        sq.pushBack(10);
        sq.pushBack(20);
        sq.pushBack(30);
        System.out.println(sq.toString());
        //1,2,3,10,20,30
        sq.insert(2,15);
        sq.insert(4,28);
        System.out.println(sq.toString());
        //当前容量
        System.out.println(sq.capacity());
        //尾插

        sq.pushBack(10);
        sq.pushBack(2000);
        sq.pushBack(3000);
        // sq.pushBack(4000);
        sq.pushBack(5000);
        sq.pushBack(6000);
        System.out.println("当前容量为"+ sq.capacity());
        //头删
        sq.popFront();
        //尾删
        sq.popBack();
        //中间删
        sq.erase(3);
        System.out.println(sq.toString());
    
        public static void test2(String [] args)
            SeqList1 s =new SeqList1();
        s.pushBack(1);
        s.pushBack(2);
        s.pushBack(3);
        s.pushBack(4);
        s.pushBack(1);
        s.pushBack(2);
        s.pushBack(3);
        s.pushBack(4);
        // [ 1, 2, 3, 4, 1, 2, 3, 4 ]
        System.out.println(s.toString());
        s.remove(4);
        // [ 1, 2, 3,  1, 2, 3, 4 ]
        System.out.println(s.toString());
        s.removeAll(4);
        // [ 1, 2, 3,  1, 2, 3,  ]
        System.out.println(s.toString());
        
        public static void main(String[] args)
            test1(args);
            test2(args);