Java数据结构数组

数组

自定义数组类MyOrderArray实现数组的增删改查

public class MyOrderArray {
private long [] arr;  

private int elements; //表示数组的有效数据的个数


public MyOrderArray(){
    arr=new long[50];
    //设置长度为50
}
public MyOrderArray(int maxSize){
    arr=new long[maxSize];
}

### 1.增 ：按照数据的大小，顺序增加

 public void insert(long value){
   int i;
   for(i=0;i<elements;i++){
       if(arr[i]>value){
           break;   //如果arr[i]>value，将arr[i]替换为value，其他数据后移
       }
   }
   for(int j=elements;j>i;j--){     //后移
       arr[j]=arr[j-1];
   }
   arr[i]=value;
   elements++;
}

解析：
- 第一次增加 5， i=0,elements=0,所以for循环并不会执行
- 第二次增加 4， i=0,elements=1,arr[0]>value,此时i=0；break；第二个for循环，elements=1,1>0,将arr[1]设置为5，再将arr[0]设置为4，实现按数据大小顺序添加

其实在代码中可以看出，当第一个for循环执行完，如果没有跳出循环，也就是数组中不存在数大于新增加的值，i的值将等于elements的值，不会执行第二个for循环，所以能实现数据的按大小顺序添加

2.删 :将对应下标的值删除，下标以后的值都要前移，数组的长度减一

 public void delete(int index){
    if(index>=elements||index<0){   //如果索引的大小超过数组的有效数据的个数
        throw new ArrayIndexOutOfBoundsException();
    }else{
        for(int i=index;i<elements;i++){
            arr[i]=arr[i+1];   //for循环覆盖前一个数据
        }
        elements--;
    }
}

解析：
- 删除先对下标进行判断，如果下标的值大于等于数组已存在数据的个数，也就是elements，将抛出异常
- 删除，用for循环给数组重新赋值，将对应删除下标以后的值前移，数组的有效数据的值建议，下次添加的时候，不会出错。

3.查

线性查找

public int search(long value){
    int i;
    for(i=0;i<elements;i++){
        if(arr[i]==value){   //判断arr里是否存在数据
            break;
        }
    }
    if(i==elements){    //如果不存在
        return -1;
    }else{
        return i;
    }
}

线性查找，从开始一直查到最后，直到查出

二分法查找

 public int binarySearch(long value){
    int middle=0;   //中间数的下标
    int low=0;      //最左边
    int pow=elements;   //最右边的数
    while(true){            //死循环
        middle=(pow+low)/2;      //中间数的下标
        if(arr[middle]==value){
            return middle;
        }else if(low>pow){    //查找不到的情况
            return -1;
        }else{
            if(arr[middle]>value){   //中间数大于要查找的数向左查找
                pow=middle-1;
            }else{                  //中间数小于要查找的数向右查找
                low=middle+1;
            }
        }
    }
}

源码：

package com.alg.linear;

public class MyOrderArray {
private long [] arr;  //数组

private int elements; //表示数组的有效数据的个数

public MyOrderArray(){
    arr=new long[50];
    //设置长度为50
}
public MyOrderArray(int maxSize){
    arr=new long[maxSize];
}
/**
 * 添加数据  --顺序添加
 */
public void insert(long value){
   int i;
   for(i=0;i<elements;i++){
       if(arr[i]>value){
           break;   //如果arr[i]>value，将arr[i]替换为value，其他数据后移
       }
   }
   for(int j=elements;j>i;j--){     //后移
       arr[j]=arr[j-1];
   }
   arr[i]=value;
   elements++;
}
/**
 * 显示数据
 */
public void disPlay(){
    System.out.print("[");
    for(int i=0;i<elements;i++){
        System.out.print(arr[i]+" ");
    }
    System.out.println("]");
    System.out.println(elements);
    System.out.println(arr.length);
}
/**
 * 根据数据查找索引
 */
public int search(long value){
    int i;
    for(i=0;i<elements;i++){
        if(arr[i]==value){   //判断arr里是否存在数据
            break;
        }
    }
    if(i==elements){    //如果不存在
        return -1;
    }else{
        return i;
    }
}
/**
 * 根据索引查找数据
 */
public long get(int index){
    if(index>=elements||index<0){   //如果索引的大小超过数组的长度或者小于0
        throw new ArrayIndexOutOfBoundsException();
    }else{
        return arr[index];       //返回查询结果
    }
}
/**
 * 删除数据  -- 删除数据要把index后一个数据覆盖到index以此类推，并将数组长度减一
 */
public void delete(int index){
    if(index>=elements||index<0){   //如果索引的大小超过数组的长度或者小于0
        throw new ArrayIndexOutOfBoundsException();
    }else{
        for(int i=index;i<elements;i++){
            arr[i]=arr[i+1];   //for循环覆盖前一个数据
        }
        elements--;
    }
}
/**
 * 更新数据
 */
public void change(int index,long value){
    if(index>=elements||index<0){
        throw new ArrayIndexOutOfBoundsException();
    }else{
        arr[index]=value;
    }
}
/**
 * 二分法查找value值对应的下标
 */
public int binarySearch(long value){
    int middle=0;   //中间数
    int low=0;      //最左边
    int pow=elements;   //最右边的数
    while(true){            //死循环
        middle=(pow+low)/2;      //中间数为左边+右边的平均值
        if(arr[middle]==value){
            return middle;
        }else if(low>pow){    //查找不到的情况
            return -1;
        }else{
            if(arr[middle]>value){   //中间数大于要查找的数向左查找
                pow=middle-1;
            }else{                  //中间数小于要查找的数
                low=middle+1;
            }
        }
    }
}
}

测试类：

public class TestMyArray {
public static void main(String[] args) {
   MyOrderArray myOrderArray=new MyOrderArray();
   myOrderArray.insert(0);
   myOrderArray.insert(5);
   myOrderArray.insert(10);
   myOrderArray.insert(9);
    System.out.println(myOrderArray.binarySearch(5));

}
}