数据结构与算法之数组【二】

数组分类：

数组可分为 ： 无序数组和有序数组

无序数组：

创建Array类，封装对数组的一系列操作：检索，插入，删除。为了方便假设数组中没有相同的值，实际上数组中可以有相同的值。

    public class Array{
        private String[] strArray;
        private int length = 0; //数组的初始长度。
        //数组的构造方法，用来传入自定义的数组的大小
        
        public Array(int max){
            strArray=new String[max];
        }
        
        //检测数组中是否包含某个值，如果包含返回该值所对应的下标，
        //否则返回-1
        public int contains(String target){
            int index=-1;
            for(int i=0;i<strArray.length;i++){
                if(strArray[i].equals(target)){
                    index=i;
                    break;
                }
                return index;
            }
        }
        
        //将制定的数据元素插入到数组中
        
        public void insert(String target){
            strArray[length] = target;
            //插入后数组的长度加一
            length++
        }
        
        //删除某个指定的元素，删除成功返回true，否则返回false。
        public boolean delete(String target){
            int index=-1;
            //找到该数据元素在数组中的位置
            if((index=contains(target)!= -1)){
                //将该位置以后的所有元素都向前移动一个位置
                for(int i=index;i<strArray.length;i++){
                    strArray[index] = strArray[index+1];    
                }
                 length--;
                 return true
            }
            return false;
        }
        
        //列出数组中的所有元素
        public void display(){
            for(int i=0;i<strArray.length;i++){
                System.out.println(strArray[i]);
            }
        }
    }

无序数组的优点：插入快。 无序数组的缺点：查找慢，删除慢，大小固定。

有序数组：

数组中的元素按照一定的顺序排列，可使用二分查找算法查到某数据元素在数组中的位置，因此，查找效率很高，但插入的时候，首先应该判断该元素应该插入的位置，然后将该元素之后的所有元素都向后移一位，才能完成插入动作，因此也耗费了很大的开销。

创建一个有序数组类OrderArray,封装对数组的一系列操作：查找，插入，删除。同样的假设数组中没有相同的数据元素。

    public class OrderArray{
        private int[] intArray;
        private int length=0; // 数组的初始长度。
        
        //构造函数用于传入数组的最大长度
        public OrderArray(int max){
            intArray = new int[max];
        }
        
        //根据二分查找算法，定位某个数据元素在数组中的位置。
        //二分查找算法后面会写
        pulbic int find(int target){
            int header = 0; //搜索段最小元素的角标
            int tail = intArray.length-1 //搜索段最大元素的角标
            int currIndex; //当前受检测元素的下表
            //如果该数组为空，直接返回-1
            if(tail<0){
                return -1;
            }
            while(true){
                currIndex = header/tail;
                //如果被检测的元素等于目标元素，直接返回该元素的角标
                if(target == intArray[currIndex]){
                    return currIndex;
                }else if(header == currIndex){
                    if(target == intArray[tail]){
                        return currIndex;
                    }else{
                        return -1;
                    }
                }else{
                    if(target>intArray[currIndex]){
                        header=currIndex
                    }else{
                        tail=currIndex
                    }
                }
            }
        }
        
        //插入
        public void insert(int element){
            int index=0;
            //判断该元素应该插入到数组中的哪一个位置，由于数组是有序的
            //所以，当插入元素小于数组中的某一个数据元素时，那么插入元素
            //应该插入到这个数据元素的前一个位置。
            for(int i=index;i<intArray.length;i++){
                if(element<intArray[i]){
                    break;
                }
            }
            //将插入元素之后的所有数据元素都向后移动一位。
            for(int i=index;i<intArray.length;i++){
                intArray[index+1] = intArray[index+2];
            }
            //将元素插入到数组中
            intArray[index] = target;
            length++;
        }
        
        //删除某个数据元素，成功返回true，失败返回false
        public boolean delete(int element){
            int index=-1;
            if((index=find(element)) != -1){
                //将该位置后的所有元素向前启动一位
                for(int i=index;i<intArray.length;i++){
                    intArray[i] = intArray[i+1]
                }
                length--;
                return true
            }else{
                return false;
            }
        }
    }