java算法方面.docx
- 文档编号:27575568
- 上传时间:2023-07-03
- 格式:DOCX
- 页数:13
- 大小:21.84KB
java算法方面.docx
《java算法方面.docx》由会员分享,可在线阅读,更多相关《java算法方面.docx(13页珍藏版)》请在冰豆网上搜索。
java算法方面
Java
快速排序
基本思想
快速排序(Quicksort)是对冒泡排序的一种改进。
由C.A.R.Hoare在1962年提出。
它的基本思想是:
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
算法过程
设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。
一趟快速排序的算法是:
1)设置两个变量I、J,排序开始的时候:
I=1,J=N;
2)以第一个数组元素作为关键数据,赋值给X,即X=A[1];
3)从J开始向前搜索,即由后开始向前搜索(J=J-1),找到第一个小于X的值,让该值与X交换;
4)从I开始向后搜索,即由前开始向后搜索(I=I+1),找到第一个大于X的值,让该值与X交换;
5)重复第3、4步,直到I=J;
例如:
待排序的数组A的值分别是:
(初始关键数据:
X=49)
A[0]、A[1]、A[2]、A[3]、A[4]、A[5]、A[6]:
49386597761327
进行第一次交换后:
27386597761349
(按照算法的第三步从后面开始找)
进行第二次交换后:
27384997761365
(按照算法的第四步从前面开始找>X的值,65>49,两者交换,此时:
I=3)
进行第三次交换后:
27381397764965
(按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后:
27381349769765
(按照算法的第四步从前面开始找大于X的值,97>49,两者交换,此时:
J=4)
此时再执行第三步的时候就发现I=J,从而结束一躺快速排序,那么经过一趟快速排序之后的结果是:
27381349769765,即所以大于49的数全部在49的后面,所以小于49的数全部在49的前面。
快速排序就是递归调用此过程——在以49为中点分割这个数据序列,分别对前面一部分和后面一部分进行类似的快速排序,从而完成全部数据序列的快速排序,最后把此数据序列变成一个有序的序列,根据这种思想对于上述数组A的快速排序的全过程如图6所示:
初始状态{49386597761327}
进行一次快速排序之后划分为{273813}49{769765}
分别对前后两部分进行快速排序{273813}经第三步和第四步交换后变成{132738}完成排序。
{769765}经第三步和第四步交换后变成{657697}完成排序。
1.
public static void QuickSort(int left, int right, int index)
2. {
3. int i, j, k;
4. int Pivot;
5. int Temp;
6.
7. i = left;
8. j = right;
9.
10. Pivot = a[left];
11. if (i < j)
12. {
13. do
14. {
15. while (a[i] < Pivot && i < right)
16. {
17. i++;
18. }
19. while (a[j] > Pivot && j > left)
20. {
21. j--;
22. }
23. if (i < j) //exchange a[i] and a[j]
24. {
25. Temp = a[i];
26. a[i] = a[j];
27. a[j] = Temp;
28.
29. }
30. } while (i < j);
31. if (i > j)
32. {
33. Temp = a[left]; // exchange a[Left] and a[j]
34. a[left] = a[j];
35. a[j] = Temp;
36. }
37. QuickSort(left, j - 1, index); // left
38. QuickSort(j + 1, right, index); // right
39.
40. }
41. }
冒泡排序的基本概念是:
依次比较相邻的两个数,将小数放在前面,大数放在后面。
即首先比较第1个和第2个数,将小数放前,大数放后。
然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。
重复以上过程,仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再大于第2个数),将小数放前,大数放后,一直比较到最小数前的一对相邻数,将小数放前,大数放后,第二趟结束,在倒数第二个数中得到一个新的最小数。
如此下去,直至最终完成排序。
由于在排序过程中总是小数往前放,大数往后放,相当于气泡往上升,所以称作冒泡排序。
用二重循环实现,外循环变量设为i,内循环变量设为j。
外循环重复9次,内循环依次重复9,8,...,1次。
每次进行比较的两个元素都是与内循环j有关的,它们可以分别用a[j]和a[j+1]标识,i的值依次为1,2,...,9,对于每一个i,j的值依次为1,2,...10-i。
1.public class BubbleSort {
2. public static void sort(int[] data) {
3. int temp;
4. for (int i = 0; i < data.length; i++) {
5. for (int j = data.length - 1; j > i; j--) {
6. if (data[i] > data[j]) {
7. temp = data[i];
8. data[i] = data[j];
9. data[j] = temp;
10. }
11. }
12. }
13. }
14.
15. public static void main(String[] args) {
16. int[] a = { 4, 2, 3, 1, 5 };
17. sort(a);
18. for (int i = 0; i < a.length; i++)
19. System.out.print(a[i] + " ");
20. }
21.}
排序
所谓排序,就是要整理文件中的记录,使之按关键字递增(或递减)次序排列起来。
当待排序记录的关键字都不相同时,排序结果是惟一的,否则排序结果不惟一。
在待排序的文件中,若存在多个关键字相同的记录,经过排序后这些具有相同关键字的记录之间的相对次序保持不变,该排序方法是稳定的;若具有相同关键字的记录之间的相对次序发生改变,则称这种排序方法是不稳定的。
要注意的是,排序算法的稳定性是针对所有输入实例而言的。
即在所有可能的输入实例中,只要有一个实例使得算法不满足稳定性要求,则该排序算法就是不稳定的。
一.插入排序
插入排序的基本思想是每步将一个待排序的记录按其排序码值的大小,插到前面已经排好的文件中的适当位置,直到全部插入完为止。
插入排序方法主要有直接插入排序和希尔排序。
①.直接插入排序(稳定)
接插入排序的过程为:
在插入第i个记录时,R1,R2,..Ri-1已经排好序,将第i个记录的排序码Ki依次和R1,R2,..,Ri-1的排序码逐个进行比较,找到适当的位置。
使用直接插入排序,对于具有n个记录的文件,要进行n-1趟排序。
代码如下:
void Dir_Insert(int A[],int N) //直接插入排序
{
int j,t;
for(int i=1;i { t=A[i]; j=i-1; while(A[j]>t) { A[j+1]=A[j]; j--; } A[j+1]=t; } } ②.希尔排序(不稳定): 希尔(Shell)排序的基本思想是: 先取一个小于n的整数d1作为第一个增量把文件的全部记录分成d1个组。 所有距离为d1的倍数的记录放在同一个组中。 先在各组内进行直接插入排序;然后,取得第二个增量d2 该方法实质上是一种分组插入方法。 一般取d1=n/2,di+1=di/2。 如果结果为偶数,则加1,保证di为奇数。 希尔排序是不稳定的,希尔排序的执行时间依赖于增量序列,其平均时间复杂度为O(n^1.3). 代码如下: void Shell(int A[],int n) //Shell排序 { int i,j,k,t; (n/2)%2 == 0 ? k = n/2+1 : k = n/2; //保证增量为奇数 while(k > 0) { for(j=k;j { t = A[j]; i = j - k; while(i>=0 && A[i]>t) { A[i+k]=A[i]; i=i-k; } A[i+k]=t; } if(k == 1) break; (k/2)%2 ==0 ? k=k/2+1 : k=k/2; } } 二.选择排序 选择排序的基本思想是每步从待排序的记录中选出排序码最小的记录,顺序存放在已排序的记录序列的后面,直到全部排完。 选择排序中主要使用直接选择排序和堆排序。 ①.直接选择排序(不稳定) 直接选择排序的过程是: 首先在所有记录中选出序码最小的记录,把它与第1个记录交换,然后在其余的记录内选出排序码最小的记录,与第2个记录交换......依次类推,直到所有记录排完为止。 无论文件初始状态如何,在第i趟排序中选出最小关键字的记录,需要做n-i次比较,因此,总的比较次数为n(n-1)/2=O(n^2)。 当初始文件为正序时,移动次数为0;文件初态为反序时,每趟排序均要执行交换操作,总的移动次数取最大值3(n-1)。 直接选择排序的平均时间复杂度为O(n^2)。 直接选择排序是不稳定的。 代码如下: void Dir_Choose(int A[],int n) //直接选择排序 { int k,t;
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- java 算法 方面