import java.util.Arrays;
import java.util.Scanner;

public class jh_54_数组的插入算法 {
/*
* 有一组学员的成绩{99，85，82，63， 60}，
* 将它们按升序排列。
* 要增加一个学员的成绩，
* 将它插入成绩序列，并保持升序。
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int [] oldArray = {99,85,82,63,60};
/*
* 1：对原数组进行排序。
* 2：把原数组拷贝到新数组中，
* 3: 寻找插入的位置。
* 4:挪。
* 5:给插入的位置赋值。
* 6:迭代新数组，查看是否插入。
*/
// 1：对原数组进行排序。
Arrays.sort(oldArray);

// 2：把原数组拷贝到新数组中
int [] newArray = new int[oldArray.length+1];
for (int i = 0; i < oldArray.length; i++) {
newArray[i]= oldArray[i];
}

// 3: 寻找插入的位置。
System.out.println("请输入你要插入的数值：num");
int num = sc.nextInt();
int index = newArray.length-1;
for (int i = 0; i < newArray.length; i++) {
if(newArray[i] > num) {
index = i;
break;
}
}

// 4:挪。
if(index != newArray.length-1) {
for (int i = newArray.length-1; i>=index; i--) {
newArray[i]= newArray[i-1];
}
// 5:给插入的位置赋值。
newArray[index] = num;
}else {
//5:给插入的位置赋值。
newArray[index] = num;
}
// 6:迭代新数组，查看是否插入。
for(int i:newArray) {
System.out.print(i+", ");
}

// 将它们按升序排列。
// int [] oldArray = {99,85,82,63,60};
// bubbleSort(oldArray);
// print(oldArray);
要增加一个学员的成绩，将它插入成绩序列，并保持升序。
// int [] newArray = copyArray(oldArray);
// // 迭代新数组
// print(newArray);
int index = searchInsertIndex(newArray,155);
System.out.println(index);
//
// move(newArray, 77);
// print(newArray);

}
/*
* 写一个函数，用于，挪位置。
* 返回值类型 void
* 参数列表。int [] arr ,int num
*/
public static void move(int []arr,int num) {
int index = searchInsertIndex(arr, num) ;

if(index != arr.length-1) {
for (int i = arr.length -1; i >= index ; i--) {
arr[i]= arr[i-1];
}
arr[index] = num;
}else {
arr[index] = num;
}
}

/*
* 遍历数组，
* 作比较。
* 如果列表元素值，比你插入的数大就找到插入位置了。
*
* 写一个函数，用于查找insert 的位置 index。
* 1：返回值类型。int
* 2:参数列表。int [] arr ,int insert
*/
public static int searchInsertIndex(int [] arr,int num) {
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if(arr[i]>num) {
return i;
}
}
return arr.length-1;
}

/**
* 写一个函数，用于拷贝老数组到新数组中。返回一个新数组。
* 返回值类型 int []
* 参数列表。 int [] arr;
* 声明一个新数组，长度为原数组长度加1
* 迭代原数组，取出每一个元素，依次存储到新数组中。
* @param arr
*/
public static int [] copyArray(int [] oldArray ) {
// 声明一个新数组，长度为原数组长度加1
int [] newArray = new int[oldArray.length+1];
// 迭代原数组，取出每一个元素，
for (int i = 0; i < oldArray.length; i++) {
// 依次存储到新数组中。
newArray[i] = oldArray[i];
}
return newArray;
}
/*
* 冒泡排序
*/
public static void bubbleSort(int [] arr) {
/*
* Bubble Sort
*
* 列表中相邻的两个元素。
* arr[i]--arr[i+1]
*/
for (int j = 0; j < arr.length-1; j++) {
for (int i = 0; i < arr.length -j-1; i++) {
if(arr[i]>arr[i+1]) {
int temp;
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
}
/*
* 遍历迭代。
* 1：返回值类型。void
* 2:参数列表。int [] arr
*/
public static void print(int [] arr) {
for (int i : arr) {
System.out.print(i+", ");
}
System.out.println();
}
}