java学习笔记（四）

1.选择排序

数组中的每个元素与第一个元素比较，如果这个元素小于第一个元素，就将它们交换

使用前面的规则，可以选择出一个最小元素放在第一个位置

每次在剩下的元素中使用前面的规则，经过n-1轮次比较完成排序

简单说：每轮选择最小的放在前面

源数据：[8,3,5,1,4,2,7]

第一趟前：8[3,5,1,4,2,7]

第二趟前：1,8[5,3,4,2,7]

第三趟前：1,2,8[5,4,3,7]

伪代码：

i=0~<ary.length-1

j=i+1~ary.length

for(i){

for(j){

if(ary[i]<ary[j])

ary[i]<-->ary[j];

}

}

程序实现：

//选择排序，从小到大

public static int[] selectionSort(int[] ary){

for(int i=0;i<ary.length-1;i++){

for(int j=i+1;j<ary.length;j++){

if(ary[i]>ary[j]){

int tmp=ary[i];

ary[i]=ary[j];

ary[j]=tmp;

}

}

}

return ary;

}

2.冒泡排序

逐一比较数组中相邻的两个元素，如果后面的元素小于前面的元素就交换前后元素

经过一个轮次的比较，一定有一个最大的排在最后面的位置，作为已经排序后的元素

每轮次比较剩下的元素，经过n-1次比较，可实现排序

简单说：比较相邻元素，每轮次最大的漂移到最后

初始：[8,3,5,1,4,2,7]

第一趟后：[3,5,1,4,2,7]8

第二趟后：[3,1,4,2,5]7,8

...

最后：[1,2,3,4,5,7,8]

伪代码：

i=0~ary.length-1

j=0~ary.length-i-1

for(i){

for(j){

if(ary[j]<ary[j+1]){

ary[j]<-->ary[j+1];

}

}

}

程序实现：

//冒泡排序，从大到小

public static int[] bubbleSort(int[] ary){

for(int i=0;i<ary.length-1;i++){

for(int j=0;j<ary.length-i-1;j++){

if(ary[j]<ary[j+1]){

int tmp=ary[j];

ary[j]=ary[j+1];

ary[j+1]=tmp;

}

}

}

return ary;

}

3.插入排序

从第一个元素开始，钙元素可以认为已经被排序

取出第一个未排序元素为temp，在已排序的元素序列中从后向前扫描，逐一比较

如果temp小于已排序元素，将该元素移到下一位置

重复上一步骤，直到找到已排序的元素小于或等于新元素的位置，将新元素插入

初始：8[3,5,1,4,2,7]

第一趟后：3,8[5,1,4,2,7]

第二趟后：3,5,8[1,4,2,7]

..

最后：[1,2,3,4,5,6,7,8]

伪代码：

i=1~ary.length-1

j=i-1~>=0(j--)

for(i){

ary[i]->temp

for(j){

if(temp<ary[i])

ary[j]-->ary[j+1];//移动

else

break;//找到插入的位置

}

temp-->ary[j+1];//j+1是插入位置

}

程序实现：

public static int[] insertSort(int[] ary){

for(int i=1;i<ary.length;i++){

int temp=ary[i];

int j;

/*
for(j=i-1;j>=0;j--){//for循环中的if一般要优化掉

if(temp<ary[j]){

ary[j+1]=ary[j];

}

else

break;

}*/

for(j=i-1;j>=0&&temp<ary[j];j--){

ary[j+1]=ary[j];

}

ary[j+1]=temp;

}

return ary;

}

4.递归调用

递归：一个函数在其定义调用自身的一种方法

通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

递归策略只需少量的程序就可描述出解题过程所需的多次重复计算，大大地减少了程序的代码量

注意：

（1）递归就是在过程或函数里调用自身

（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口

（3）递归性能比较差

简单的递归小程序：

public static int f(int n){

if(n==1)

return 1;

return n+f(n-1);

}