数组

package data.struct.algorithm;

import java.util.Arrays;

public class ArraysDemo {

//    private static final int UNSORTARRAYSIZE = 10;

    /**
     * @param args
     */
    /*
     * 数据结构之数组的运用，无非是增删查操作，就有序数组和无序数组进行这三种操作
     */
    public static void main(String[] args) {

        // 无序数组,假定数组中元素互不相同
        int arr[] = new int[] { 10, 5, 7, 9, 42, 35, 46, 74, 3, 52, 252 };
        displayArr(arr);
        // 有序数组，假定数组中元素互不相同
        int arrSort[] = new int[] { 98, 65, 34, 25, 19, 16, 8, 4, 2, 1 };
        displaySortArr(arrSort);
        int key = 42;// 有序、无序数组查找是否存在42这个元素
        unSortSearchKey(arr, key);// 无序查找
        int position = sortSearchKey(arrSort, key);// 有序查找
        System.out.println(key + "在有序数组中索引为" + position + "个位置");
        //有序数组arrSort中插入一个指定大小的元素
        int key_insert=56;
        
        int arr_copySort[]=insertKey(arrSort,key_insert);//有序数组插入元素,用一个数组接收返回的数组
        displaySortArr(arr_copySort);
        insertKey_2(arr,key_insert);//无序数组插入元素
        int delSortIndexKey=5;
        int delUnSortIndexKey=4;
        delete_1(arrSort,delSortIndexKey);
        delete_2(arr,delUnSortIndexKey);
        
    }
    //无序数组删除元素
    public  static void delete_2(int[] arr, int delUnSortIndexKey) {
        
}
    //有序数组删除元素
    public  static void delete_1(int arr[],int delSortIndexKey) {
        if(delSortIndexKey>=arr.length){
            return;
        }
        for(int i=delSortIndexKey;i<arr.length-1;i++){
            arr[i]=arr[i+1];
        }
        arr[arr.length-1]=0;
        displaySortArr(arr);
}
    //无序数组中插入元素(数组扩容,插入到数组的最后即可)
    public static void insertKey_2(int[] arr, int key_insert) {
        Arrays.copyOf(arr, arr.length+1);
        arr[arr.length-1]=key_insert;
        displayArr(arr);
    }

    public  static void displaySortArr(int[] arrSort) {
        for(int x=0;x<arrSort.length;x++){
            System.out.print(arrSort[x]+" ");
        }
        System.out.println();
    }
    //打印输出数组中的元素
    public  static void displayArr(int[] arr) {
        for(int x=0;x<arr.length;x++){
            System.out.print(arr[x]+" ");
        }
        System.out.println();
    }
    //向有序数组中插入元素,并返回插入元素后的数组
    public static int[] insertKey(int[] arrSort, int key_insert) {
//        int left=0;
//        int right=arrSort.length-1;
//        int half=(left+right)/2;
        int position=sortSearchKey(arrSort, key_insert);
        if(position>=0){
            arrSort=Arrays.copyOf(arrSort, arrSort.length+1);
            for(int x=arrSort.length-1;x>position;x--){
                arrSort[x]=arrSort[x-1];
            }
            arrSort[position]=key_insert;
//            displayArr(arrSort);
        }
        else{
            arrSort=Arrays.copyOf(arrSort, arrSort.length+1);
            for(int x=arrSort.length-1;x>=-(position+1);x--){
                arrSort[x]=arrSort[x-1];
            }
            arrSort[-(position+1)]=key_insert;
//            displaySortArr(arrSort);
        }
        return arrSort;
    }

    // 有序数组查找特定元素，可以采用线性查找或者是二分查找(BinarySearch),这里我们使用二分查找
    //数组为升序排列或降序排列，使用二分查找代码代码有些不同，坑爹呀
    public static int sortSearchKey(int[] arrSort, int key) {
        
        int max,min,mid;  
          min = 0;  
          max = arrSort.length-1;  
          while(min<=max)  
          {  
           mid = (max+min)>>1;  
           if(key>arrSort[mid])  
              max = mid - 1; 
           else if(key<arrSort[mid])  
            min = mid + 1; 
           else  
            return mid;  
          }  
          return -min-1; 
    }

    // 无序数组查找特定元素,线性查找
    public static void unSortSearchKey(int arr[], int key) {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==key){
                System.out.println(key+"在无序数组中索引为的"+i+"个位置");
            }
            else {
                continue;
            }
            if(i==arr.length){
                System.out.println(key+"不存在与无序数组中");
            }
        }

    }

}