数组的排序，反转，折半查找，插入

数组的排序，反转，折半查找，插入

分类： J2SE 2011-12-31 01:37  1544人阅读  评论(1)  收藏  举报

pivot 算法 search insert string 面试

数组的使用中要注意：
 1.下标越界问题;
 2.操作数组时候，先要分析，有个整体的思路。

选择排序，冒泡排序，快速排序面试会考到，其中快速排序代码复杂些。下面着重分析下快速排序，（引用了部分百度的内容）

　　一趟快速排序的算法是：

　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；

　　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；

　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换；

　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换；

　　5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。)

　　例如：待排序的数组A的值分别是：（初始关键数据：X=49） 注意关键X永远不变，永远是和X进行比较，无论在什么位子，最后的目的就是把X放在中间，小的放前面大的放后面。

　　A[0] A[1] A[2] A[3] A[4] A[5] A[6]：

　　49 38 65 97 76 13 27

　　进行第一次交换后：27 38 65 97 76 13 49

　　( 按照算法的第三步从后面开始找)

　　进行第二次交换后：27 38 49 97 76 13 65

　　( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 )

　　进行第三次交换后：27 38 13 97 76 49 65

　　( 按照算法的第五步将又一次执行算法的第三步从后开始找

　　进行第四次交换后：27 38 13 49 76 97 65

　　( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：I=4,J=6 )

　　此时再执行第三步的时候就发现I=J，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于49的数全部在49的后面，所有小于49的数全部在49的前面

画个图分析：


代码：

[java]  view plain copy

1. public class MySort  
2. {  
3.   
4.     /** 
5.      * 数组选择排序，冒泡排序，快速排序，反转，折半查找，插入 
6.      * @author acer 
7.      */  
8.     public static void main(String[] args)  
9.     {  
10.         int arr[]={-7,98,22,13,-9,18};  
11.         //selectSort(arr);  
12.         //show(arr);  
13.           
14.         //bubbleSort(arr);  
15.         //show(arr);  
16.           
17.         //quickSort(arr, 0, arr.length-1);  
18.         //show(arr);  
19.           
20.         //reverseArray(arr);  
21.         //show(arr);  
22.           
23.         //quickSort(arr, 0, arr.length-1);//排序，保证数组有序  
24.         //show(arr);  
25.         //int index=search(arr, 10);  
26.         //System.out.println(index);  
27.           
28.           
29.         quickSort(arr, 0, arr.length-1);//排序，保证数组有序  
30.         show(insert(arr, 12));  
31.   
32.     }  
33.       
34.     /*选择排序： 
35.      每趟比较选择一个元素与其他元素逐个比较， 
36.      每趟得到一个最值排在前面，从左到右增大前面的有序序列*/  
37.     public static void selectSort(int arr[])  
38.     {  
39.         for (int i = 0; i < arr.length-1; i++)  
40.         {  
41.             for (int j = i+1; j < arr.length; j++)  
42.             {  
43.                 if(arr[i]>arr[j])  
44.                 {  
45.                     swap(arr, i, j);//交换位置  
46.                 }  
47.             }  
48.         }  
49.   
50.     }  
51.       
52.     //把交换两个元素位置的代码抽取出来  
53.     public static void swap(int arr[],int a,int b)  
54.     {  
55.         int temp=0;  
56.         temp=arr[a];  
57.         arr[a]=arr[b];  
58.         arr[b]=temp;  
59.     }  
60.       
61.     //内循环中每趟将得到一个最值排到后面  
62.     public static void bubbleSort(int arr[])  
63.     {  
64.         for (int i = 0; i < arr.length-1; i++)  
65.         {     
66.             //-1 是为了防止数组下标越界，-i是为了减少比较次数  
67.             for (int j = 0; j < arr.length-1-i; j++)  
68.             {  
69.                 if(arr[j]>arr[j+1])  
70.                 {  
71.                     swap(arr, j, j+1);//交换位置  
72.                 }  
73.             }  
74.         }  
75.           
76.     }  
77.       
78.     //快速排序效率比较高  
79.     public static void quickSort(int arr[],int left,int right)  
80.     {  
81.         if(left>=right)  
82.         {  
83.           return;  
84.         }  
85.           
86.         int low=left,high=right;  
87.         int pivot=arr[low];//设置枢轴数  
88.           
89.         while(low<high)  
90.         {     
91.             //从右往左找，依次找到比枢轴数小的数  
92.             while(low<high&&arr[high]>=pivot)  
93.             {  
94.                 high--;  
95.             }  
96.               
97.             swap(arr, low, high);  
98.             //从左往右找，依次找到比枢轴数大的数  
99.             while(low<high&&arr[low]<=pivot)  
100.             {  
101.                 low++;  
102.             }  
103.               
104.             swap(arr, low, high);  
105.         }  
106.           
107.         //递归枢轴数左右两边  
108.         quickSort(arr, left, low-1);  
109.         quickSort(arr, high+1, right);  
110.     }  
111.       
112.     //反转数组  
113.     public static void reverseArray(int arr[])  
114.     {  
115.         for(int start=0,end=arr.length-1;start<end;start++,end--)  
116.         {  
117.             swap(arr, start, end);  
118.         }  
119.     }  
120.       
121.     //折半查找，***首先要保证查找的数组是有序的***  
122.       
123.     public static int search(int arr[],int key)  
124.     {  
125.         int min=0,max=arr.length-1,mid=0;  
126.           
127.         while(min<=max)  
128.         {  
129.             mid=min+max>>1;//除以2  
130.             if(arr[mid]>key)  
131.             {  
132.                 max=mid-1;  
133.             }  
134.             else if(arr[mid]<key)  
135.             {  
136.                 min=mid+1;  
137.             }  
138.             else  
139.                 return mid;//返回要查找元素的下标  
140.         }  
141.           
142.         return min;//数组中查找不到  
143.     }  
144.       
145.     /*在有序的数组里插入一个数，插入后数组仍然有序 
146.      * 1.创建一个新数组比原数组的长度大1； 
147.      * 2.遍历原数组，将原数组的值存入新数组中； 
148.      * 3.通过折半查找找到要插入的位置； 
149.      * 4.将新数组中从插入位置开始的数据都往后挪一位； 
150.      * 5.将要插入的值放入正确的位置。 
151.      * */  
152.       
153.       
154.     public static int[] insert(int arr[],int key)  
155.     {  
156.         int newArr[]=new int[arr.length+1];//创建新数组  
157.         for (int i = 0; i < arr.length; i++)  
158.         {  
159.             newArr[i]=arr[i];//拷贝原数组值  
160.         }  
161.           
162.         int index=search(arr, key);//找到要插入的位置  
163.           
164.         for (int i =newArr.length-1; i>index; i--)  
165.         {  
166.             newArr[i]=newArr[i-1];//数据向右边挪动一个位置  
167.         }  
168.   
169.         newArr[index]=key;//要插入的数放到正确位置  
170.         return newArr;  
171.     }  
172.     //打印数组  
173.     public  static void show(int arr[])  
174.     {  
175.         for (int i = 0; i < arr.length; i++)  
176.         {  
177.             System.out.print(arr[i]+" ");  
178.         }  
179.         System.out.println();  
180.     }  
181.   
182. }