Java面试题多思路解析--有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中

题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

思路分析：将一个数字插入按要求插入到一个数组中，怎样找到这个数字的的位置是关键。

针对这一题目，我整理了三种解决方案，以下是源代码：

[java] view plain copy

1. import java.util.Scanner;  
2.   
3. public class InsertNumber {  
4.     public static void main(String[] args) {  
5.         int[] arr = { 10, 20, 30, 40, 50};  
6.         int[] arrchange = new int[arr.length + 1];  
7.   
8.         System.out.print("before change:  ");  
9.         for (int i = 0; i < arr.length; i++) {  
10.             System.out.print("  " + arr[i]);  
11.         }  
12.         System.out.println();  
13.   
14.         System.out.println("Input a number:  ");  
15.         Scanner scanner = new Scanner(System.in);  
16.         int number = scanner.nextInt();  
17.   
18.         // 冒泡排序的思路  
19.         arrchange = insort1(arr, number);  
20.         System.out.print("changed:  ");  
21.         for (int i = 0; i < arrchange.length; i++) {  
22.             System.out.print("  " + arrchange[i]);  
23.         }  
24.   
25.         // 插入排序的思路  
26. //      arrchange = insort2(arr, number);  
27. //      System.out.print("changed:  ");  
28. //      for (int i = 0; i < arrchange.length; i++) {  
29. //          System.out.print("  " + arrchange[i]);  
30. //      }  
31.   
32.         // 二分法的思路  
33. //      for (int i = 0; i < arr.length; i++) {  
34. //          arrchange[i] = arr[i];  
35. //      }  
36. //        
37. //      int location = insort3(arrchange, number);  
38. //  
39. //      for (int i = arrchange.length - 1; i > location; i--) {  
40. //          arrchange[i] = arrchange[i - 1];  
41. //      }  
42. //  
43. //      arrchange[location] = number;  
44. //  
45. //      System.out.print("changed:  ");  
46. //      for (int i = 0; i < arrchange.length; i++) {  
47. //          System.out.print("  " + arrchange[i]);  
48. //      }  
49.   
50.     }  
51.   
52.     public static int[] insort1(int[] arr, int number) {  
53.         int[] arrchange = new int[arr.length + 1];  
54.           
55.         //将源数组复制到新的数组里，新数组最后一个元素为需要插入的数字  
56.         for (int i = 0; i < arr.length; i++) {  
57.             arrchange[i] = arr[i];  
58.         }  
59.         arrchange[arr.length] = number;  
60.           
61.         //类似进行冒泡排序的最后一轮  
62.         for (int i = arr.length; i > 0;i--) {  
63.             if (arrchange[i] < arrchange[i - 1]) {  
64.                 int temp = arrchange[i];  
65.                 arrchange[i] = arrchange[i - 1];  
66.                 arrchange[i - 1] = temp;  
67.             }  
68.   
69.         }  
70.         return arrchange;  
71.     }  
72.   
73.     public static int[] insort2(int[] arr, int number) {  
74.         int[] arrchange = new int[arr.length + 1];  
75.   
76.         for (int i = 0; i < arr.length; i++) {  
77.             arrchange[i] = arr[i];  
78.         }  
79.   
80.         int i, j;  
81.   
82.         for (i = 0; i < arrchange.length; i++) {  
83.             if (arrchange[i] > number) { // 找到插入位置  
84.                 for (j = arrchange.length - 1; j > i; j--) {  
85.                     arrchange[j] = arrchange[j - 1]; // 后边元素依次向后移动一位  
86.                 }  
87.                 arrchange[i] = number; // 插入  
88.                 break;  
89.             }  
90.         }  
91.   
92.         if (arrchange.length == i) { // 若待插之数大于所有数字，直接插到最后  
93.             arrchange[i - 1] = number;  
94.         }  
95.   
96.         return arrchange;  
97.     }  
98.   
99.     public static int insort3(int[] arrchange, int number) {  
100.         int low = 0;  
101.         int high = arrchange.length - 1;  
102.         int mid = (low + high) / 2;  
103.   
104.         if (number > arrchange[high - 1]) {  //判断是否大于原数组最后一个元素  
105.             return high;  
106.         } else if (number < arrchange[0]) {  //判断是否小于原数组的第一个元素  
107.             return 0;  
108.         } else {  
109.             while (low != high) {  
110.                 if(number == arrchange[mid]) {   //判断是否等于查找中间的元素  
111.                     break;  
112.                 }else if(1 == high-low) {      
113.                     break;  
114.                 }else if(number < arrchange[mid]) {    
115.                     high = mid;  
116.                     mid = (low + high) / 2;  
117.                 }else {  
118.                     low = mid;  
119.                     mid = (low + high) / 2;  
120.                 }  
121.           
122.             }  
123.   
124.             return mid+1;  
125.         }  
126.   
127.     }  
128.   
129. }  

下面分别对这三种思路进行分析：

一、冒泡排序的思路

因为已知数组是排好序的，这和冒泡排序进行最后轮排序是一样的。所以第一步，将已知数组和需要插入的数字放到一个新的数组里，且把需要插入的数字放到新的数组的 最后一位。

[java] view plain copy

1. <span style="white-space:pre">    </span>//将源数组复制到新的数组里，新数组最后一个元素为需要插入的数字  
2.         for (int i = 0; i < arr.length; i++) {  
3.             arrchange[i] = arr[i];  
4.         }  
5.         arrchange[arr.length] = number;  

然后进行冒泡排序，将最后一个数字放到合适的位置。

[java] view plain copy

1. <span style="white-space:pre">    </span>//类似进行冒泡排序的最后一轮  
2.         for (int i = arr.length; i > 0;i--) {  
3.             if (arrchange[i] < arrchange[i - 1]) {  
4.                 int temp = arrchange[i];  
5.                 arrchange[i] = arrchange[i - 1];  
6.                 arrchange[i - 1] = temp;  
7.             }  
8.   
9.         }  

二、插入排序的思路

这种思路，较为容易理解。拿着需要插入的数字，和原数组的每一个数字进行比较，满足大小条件，即可确定位置，然后插入数字。

需要注意的，最后如果被插入的数字大于原数组的所有的元素，那就把数字放到最后一位。

三、二分法的思路。

1、找出中间的那个值，判断插入值是否等于中值；

2、若等于，查找结束；若不等，如果二分查找的区间长度为1，则查找结束；

3、否则根据大小关系，继续按照1、2进行查找。

【关于返回值为什么是 mid+1 ，而不是mid 】

举个例字说明一下：

数组a[4] = {2, 4, 7, 9}   a[0]=2， a[1]=4， a[2]=7， a[3]=9。

新数组b[5]={2, 4, 7, 9, 0}

若插入值为5，   返回值应为2

第一轮：low=0， high=4， mid=2， a[mid]=7 > 5

第二轮：low=0， high=2， mid=1， a[1]=4 < 5

第三轮：low=1， high=2， mid=1， 满足查找完成条件，退出

此时mid = 1， 故返回值为mid+1。

原文链接：http://blog.csdn.net/ygoodmanm/article/details/50804809点击打开链接