java day05第五课数组的排序和查找

数组的排序和查找

插入排序

 int array6[] = { 3, 4, 2, 1, 5, 6, 9, 8, 7, 0 };
/**
 * 2 2,3,4
 */
for (int i = 1; i < array6.length; i++) {
    int j = i; //  i = 1 ; j = 1
    int temp = array6[i];
    while (j > 0 && temp < array6[j - 1]) {
     		int a = array6[j];
			array6[j] = array6[j - 1]; // array6[2] = array6[1];
			array6[j - 1] = a;
			j--;        }
    System.out.println("第" + i + "次移动后：");
    for (int i1 = 0; i1 < array6.length; i1++) {
        System.out.print("," + array6[i1]);
    }
    System.out.println();
    array6[j] = temp;
}
System.out.println("array6 直接插入排序之后：");
for (int i = 0; i < array6.length; i++) {
    System.out.println("array6[" + i + "] = " + array6[i]);
}

阶乘

/**
 * 1!  = 1 
 * 2!  = 2 x 1             = 2 x 1！ 
 * 3!  = 3 x 2 x 1         = 3 x 2! 
 * 4!  = 4 x 3 x 2 x 1     = 4 x 3! 
 * ......
 */public static int Factorial(int n) {
    // return n*(n-1)!
    if (n < 1) {
        return 0;
    }
    if (n == 1) {
        return 1;
    } else {
        return n * Factorial(n - 1);
    }
}

归并排序

 pubic static void MSort(int[] arr, int left, int right) { 
  
    int mid = (left + right) / 2;
    if (left < right) {
        // 递归拆分左边
        MSort(arr, left, mid);  
        // 递归拆分右边
        MSort(arr, mid + 1, right); 
        // 将拆分的有序数组排序
        Merge(arr, left, mid, right);
    }
}

public static void Merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int low1 = left; // 左边数组的起始位置
    int low2 = mid + 1; // 右边数组的起始位置
    int index = 0;
    // 比较拆分的两个子数组，依次取最小值，放入新数组
    while (low1 <= mid && low2 <= right) {
        if (arr[low1] <= arr[low2]) {
            temp[index++] = arr[low1++];
        } else {
            temp[index++] = arr[low2++];
        }
    }
    // 把左边剩余的装进新数组
    while (low1 <= mid) {
        temp[index++] = arr[low1++];
    }
    // 把右边剩余的装进新数组
    while (low2 <= right) {
        temp[index++] = arr[low2++];
    }
    //把新数组里面的有序元素数，装进原数组
    for (int i = 0; i < temp.length; i++) {
        arr[i + left] = temp[i];
    }
}

数组的查找

1、方法1

public int getindex(int[] arr,int a){
	for(int i = 0;i < arr.length;i++){
		if(arr[i] == a){
			return i;
		}
	}
	return -1;//数组的下标从0开始，－1代表没有找到，不存在此元素
}

2、方法2（折半查找）

折半查找可以提高效率，但是必须要保证我们的数组是有序的。
//2.1实现方式1:
public int halfsearch1(int[] arr,int a){
	int min,max,mid;
	min = 0;
	max = arr.length - 1;
	mid = (min+max)/2;
	
	while(arr[mid] != a){
		if(a > arr[mid]){
			min = mid + 1;
			
		}else{
			max = mid - 1;
		}
		if(min > max){
			return -1;
		}
		mid = (max+min)/2;
	}
	return mid;
}

//2.2实现方式2:
public int halfsearch2(int[] arr,int a){
	int  min = 0,max = arr.length-1,mid;
	
	while(min <= max){
		
		mid = (max + min)/2;
		if(a > arr[mid]){
			min = mid + 1;
			
		}else if(a < arr[mid]){
			max = mid - 1;
		}else{
			return mid; 
		}
	}
	return -1;

}

问题：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。