MyArray

import org.omg.PortableInterceptor.IORInterceptorOperations;

public class MyArray {
	//增删改查
	//CURD create retrieve update delete
	
	//create
	public static int[] fromArray(int[] srcArray,int beginIndex, int length) {
		int[] destArray = new int[length];
		for (int i = beginIndex; i < beginIndex + length; i++) {
			destArray[i - beginIndex] = srcArray[i];
		}
		return destArray;
	}
	
	public static int[] fromArray(int[] srcArray, int beginIndex) {
		return fromArray(srcArray, beginIndex, srcArray.length - beginIndex);
	}
	//通过一个数组的拷贝产生一个新的数组
	public static int[] fromArray(int[] srcArray) {
		return fromArray(srcArray, 0, srcArray.length);
	}
	
	public static int[] clone(int[] srcArray) {
		return fromArray(srcArray);
	}
	//retrieve
	/**
	 * 返回指定的位置呵长度的子数组
	 * @param srcArray
	 * @param beginIndex
	 * @param length
	 * @return
	 */
	public static int[] subArray(int[] srcArray,int beginIndex,int length) {
		return fromArray(srcArray, beginIndex, length);
	}
	
	public static int[] subArray(int[] srcArray,int beginIndex) {
		return subArray(srcArray, beginIndex, srcArray.length - beginIndex);
	}
	//[fromIndex , toIndex)
	/**
	 * 返回指定开始位置到指定结束位置的新数组
	 * @param array
	 * @param fromIndex
	 * @param toIndex
	 * @return
	 */
	public static int[] subArrayTo(int[] array,int fromIndex,int toIndex) {
		return subArray(array, fromIndex, toIndex - fromIndex);
	}
	public static int[] subArrFrom(int[] array,int fromIndex) {
		return subArray(array, fromIndex, array.length -1);
	}
	public static int[] subArrTo(int[] array,int toIndex) {
		return subArrayTo(array, 0, toIndex);
	}
	/**
	 * 遍历查找 返回-1表示未找到
	 * @param array
	 * @param target
	 * @return
	 */
	public static int Seek(int[] array,int target) {
		for (int i = 0; i < array.length; i++) {
			if (array[i] == target) {
				return i;
			}
		}
		return - 1;
	}
	/**
	 * 折半查找
	 * @param array
	 * @param target
	 * @return
	 */
	public static int halfSeek(int[] array,int target) {
		int low = 0;
		int high = array.length - 1;
		while (low <= high) {
			int mid = (low + high) / 2;
			if (array[mid] < array[target]) {
				low = mid + 1;
			}else if (array[mid] > array[target]) {
				high = mid - 1;
			}else {
				return mid;
			}
		}
		return - 1;
	}
	//Delete
	public static int[] delete(int[] srcArray, int beginIndex, int length) {
		if(length < 0) {
			beginIndex = beginIndex + length;
		}
		int[] arr = new int[srcArray.length - Math.abs(length)];
		for (int i = 0,j = 0; i < srcArray.length; i++) {
			if(i < beginIndex || i >= beginIndex + Math.abs(length)) {
				arr[j] = srcArray[i];
				j++;
			}
		}
		return arr;
	}
	public static int[] delete(int[] srcArray,int targetIndex) {
		return delete(srcArray, targetIndex, 1);
	}
	
	public static int[] deleteFrom(int[] srcArray,int fromIndex) {
		return delete(srcArray, fromIndex, srcArray.length - fromIndex);
	}
	public static int[] deleteTo(int[] srcArray,int toIndex) {
		return delete(srcArray, 0, toIndex);
	}
	
	//tools
	public static void swap(int[] array,int index1,int index2) {
		int temp = array[index1];
		array[index1] = array[index2];
		array[index2] = temp;
	}
	/**
	 * 把数组通过指定分隔符连接成字符串
	 * @param array
	 * @param separator
	 * @return
	 */
	public static  String join(int[] array,String separator) {
		String arrayString = "";
//		for (int i = 0; i < array.length; i++) {
//			if (i == array.length - 1) {
//				arrayString += array[i];
//			}else {
//				arrayString += array[i] + separator;
//			}
//		}
//		return arrayString;
		for (int i = 0; i < array.length - 1; i++) {
			arrayString += array[i] + separator;
		}
		return arrayString + array[array.length - 1];
	}
	
	public static String toString(int[] array) {
		return "[" + join(array, ",") + "]";
	}
	/**
	 * 0 disorder 1 ascending 2 descending 3 equals
	 * @param array
	 * @return
	 */
	public static int isOrder(int[] array) {
		int ascCount = 0;
		int descCount = 0;
		for (int i = 0; i < array.length; i++) {
			if (array[i] > array[i + 1]) {
				descCount++;
			}else if (array[i] < array[i + 1]) {
				ascCount++;
			}
		}
		if (descCount == 0 && ascCount ==0) {
			return 3;
		}else if (ascCount == 0) {
			return 2;
		}else if (descCount == 0) {
			return 1;
		}
		return 0;
	}
	
	//update insert replace sort reverse
	/**
	 * 把源数组指定位置和长度的元素插入到目标数组的指定位置
	 * @param destArray
	 * @param beginIndex
	 * @param srcArray
	 * @param srcBeginIndex
	 * @param length
	 * @return
	 */
	public static int[] insert(int[] destArray,int beginIndex,int[] srcArray,int srcBeginIndex,int length) {
		int[] arr = new int[destArray.length + length];
		//目标数组当前位置
		int destIndex = 0;
		//新数组当前位置
		int newIndex = 0;
		//把目标数组从0开始到指定位置的元素复制到新数组
		for (; destIndex <= beginIndex; destIndex++) {
			arr[newIndex] = destArray[destIndex];
			newIndex++;
		}
		
		for (int i = srcBeginIndex; i < srcBeginIndex + length; i++) {
			arr[newIndex] = srcArray[i];
			newIndex++;
		}
		for (; destIndex < destArray.length; destIndex++) {
			arr[newIndex] = destArray[destIndex];
			newIndex++;
		}
		return arr;
	}
	
	
	public static int[] insert(int[] destArray,int destBeginIndex,int[] srcArray) {
		return insert(destArray, destBeginIndex, srcArray, 0, srcArray.length);
	}
	
	public static int[] insert(int[] destArray,int destBeginIndex,int element) {
//		int[] srcArray = {element};
//		return insert(destArray, destBeginIndex, srcArray);
		return insert(destArray, destBeginIndex, new int[] {element});
	}
	//insertBefore 三个方法
	public static int[] insertBefore(int[] destArray,int destBeginIndex, int[] srcArray,int srcBeginIndex,int srcLength) {
		int[] newArray = new int[destArray.length + srcLength];
		int newIndex = 0;
		int destIndex = 0;
		for (; destIndex < destBeginIndex; destIndex++) {
			newArray[newIndex] = destArray[destIndex];
			newIndex++;
		}
		for (int i = srcBeginIndex + srcLength - 1; i >= srcBeginIndex; i--) {
			newArray[newIndex] = srcArray[i];
			newIndex++;
		}
		for (; destIndex >= destBeginIndex + srcLength; destIndex++) {
			newArray[newIndex] = destArray[destIndex];
			newIndex++;
		}
		return newArray;
	}
	public static int[] insertBefore(int[] destArray,int destBeginIndex,int[] srcArray) {
		return insertBefore(destArray, destBeginIndex, srcArray, 0, srcArray.length);
		}
	
	public static int[] insertBefore(int[] destArray,int destBeginIndex,int element) {
		return insertBefore(destArray, destBeginIndex, new int[] {element});
	}
	//
	public static int[] concat(int[] destArray, int[] srcArray) {
		return insert(destArray, destArray.length - 1, srcArray);
	}
	
	
	public static int[] replace(int[] destArray,int destBeginIndex,int destLength,int[] srcArray,int srcBeginIndex,int srcLength) {
		int[] arr = new int[destArray.length - destLength + srcLength];
		int newIndex = 0;
		int destIndex = 0;
		for (; destIndex < destBeginIndex; destIndex++) {
			arr[newIndex] = destArray[destIndex];
			newIndex++;
		}
		if (destLength >= srcLength) {
			while (newIndex < destIndex + destLength) {				
				for (int i = srcBeginIndex; i < srcBeginIndex + srcLength; i++) {
					arr[newIndex] = srcArray[i];
					newIndex++;
					if (newIndex == srcBeginIndex + srcLength) {
						i = srcBeginIndex;
					}
				}
			}
			
			for (destIndex = destBeginIndex + destLength;  destIndex < destArray.length; destIndex++) {
				arr[newIndex] = destArray[destIndex];
				newIndex++;
			}
			
		}
		if (destLength < srcLength) {
				for (int i = srcBeginIndex; i < srcBeginIndex + destLength; i++) {
					arr[newIndex] = srcArray[i];
					newIndex++;
				}
				for (destIndex = destBeginIndex + destLength; destIndex < destArray.length; destIndex++) {
					arr[newIndex] = destArray[destIndex];
					newIndex++;
				}
			}
		
		return arr;
//		return insert(delete(destArray, destBeginIndex, destLength), destBeginIndex - 1, srcArray, srcBeginIndex, srcLength);
		
	}
	
	public static int[] replace(int[] destArray,int destBeginIndex,int destLength,int[] srcArray) {
		return replace(destArray, destBeginIndex, destLength, srcArray, 0, srcArray.length);
	}
	
	public static int[] reverse(int[] array) {
		for (int i = 0; i < array.length / 2; i++) {
			swap(array, i, array.length - 1 - i);
		}
		return array;
	}
	public MyArray() {
		// TODO Auto-generated constructor stub
	}
	
	
	
	//break 
	/**
	 * 打乱数组（洗牌算法）
	 * @param array
	 * @return
	 */
	public static int[] breakArray(int[] array) {
		for (int i = array.length - 1; i > 0; i--) {
			int r = (int) Math.floor(Math.random() * (i + 1));
			swap(array, r, i);
		}
		return array;
	}
	
	//sort
	public static int[] bubbleSort(int[] array) {
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = 0; j < array.length - 1 - i; j++) {
				if (array[j] > array[j + 1]) {
					swap(array,j,j+1);
				}
			}
			
		}
		return array;
	}
	
	public static int[] selectionSort(int[] array) {
		for (int i = 0; i < array.length; i++) {
			int index = i;
			for (int j = i; j < array.length; j++) {
				if (array[index] > array[j]) {
					index = j;
				}
			}
			swap(array, index, i);
		}
		return array;
	}
	public static int[] insertSort(int[] array) {
		for (int i = 1; i < array.length; i++) {
			int j = i;
			int temp = array[j];
			while (j > 0 && temp < array[j - 1]) {
				array[j] = array[j - 1];
				j--;
			}
			array[j] = temp;
		}
		return array;
	}
	
	public static int maxIndex(int[] array,int beginIndex,int length) {
		int maxIndex = array[beginIndex];
		for (int i = beginIndex; i < beginIndex + length; i++) {
			if (array[i] > array[maxIndex]) {
				maxIndex = i;
			}
		}
		return maxIndex;
		
	}
	public static int minIndex(int[] array,int beginIndex,int length) {
		int minIndex = array[beginIndex];
		for (int i = beginIndex; i < beginIndex + length; i++) {
			if (array[i] < array[minIndex]) {
				minIndex = i;
			}
		}
		return minIndex;
	}
	
	public static int maxIndex(int[] array) {
		return maxIndex(array, 0, array.length);
	}
	public static int minIndex(int[] array) {
		return minIndex(array, 0, array.length);
	}
	public static int max(int[] array) {
		return array[maxIndex(array)];
	}
	public static int min(int[] array) {
		return array[minIndex(array)];
	}

	
}