浅谈冒泡,插入,选择，快速排序等思想和代码实现

1.冒泡排序：

冒泡排序又叫做相邻比较法,它指的是相邻元素进行比较后交换，逐步将无序变成有序的过程。以升序为例：

第一趟中,从第一个数开始，进行n-1次比较,选择出最大的一个数放在第n个位置.(在第一趟或者每一趟比较中只能筛选出最大的一位数放后面，一直比较到结束.)

第二趟中,从第一个数开始，进行n-2次比较(最大的数在第一趟中已经选出来了,放最后,故排除,以下都一样),选择出次最大的一个数放在第n-1个位置,

.........

第n-1趟中,从第一个数开始,进行最后一次比较,比较好的数放在第二个位置(没有第n趟,因为，最后一个数最小,放第一个位置)

比如以48，63，35，77，15举例说明：

第一趟,48，63，35，77，15;

48和63比较,比他小,则可不用交换位置为：48,63,35,77,15;

,63在和35比较,比他大,则交换位置为:48,35,,63,77,15;

,63在和77比较,比他小,则不用交换位置为:48,35,,63,77,15;

,77在和15比较,比他大,则交换位置为:48,35,,63,15,77;

上面为第一趟比较结果,,,以下n-2趟则比较方法相同,不在说明;

package Nishui;

public class MaoPao {

public static void main(String[] args) {

int array[] = {1,4,2,7,9,0,5};

int arr[] = BubbleSort(array);

for(int i = 0;i<arr.length;i++){

System.out.print(arr[i] + "\t");

}

}

public static int[] BubbleSort(int array[]){

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

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

if(array[j] > array[j+1]){

int x = array[j];

array[j] = array[j+1];

array[j+1] = x;

}

}

}
return array;

}
}

2.插入排序:

其基本操作是把第i个数插入到前面的i-1个数中去.

比如以48，63，35，77，15举例说明：

开始,集合为空,{}，48，63，35，77，15;

第一趟,把48放入集合为,{48}，63，35，77，15;

第二趟,把63放入集合中和48比较为,{48,63}，35，77，15;

第三趟,把35放入集合中和其中的2个数比较为:{35，48,63}，77，15;

第四趟,把77放入集合中和其中的3个数比较为:{35，48,63，77}，15;

第五趟,把15放入集合中和其中的4个数比较为:{15，35，48,63，77};

package Nishui;

public class ChaRu {

public static void main(String[] args) {

int array[] = {1,4,2,7,9,0,5};
int arr[] = InsertSort(array);
for(int i = 0;i<arr.length;i++){

System.out.print(arr[i] + "\t");

}

}

public static int[] InsertSort(int[] array){

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

for(int j = i;j>0;j--){

if(array[j] < array[j-1]){

int t = array[j];

array[j] = array[j-1];

array[j-1] = t;

}

}

}
return array;

}
}

3.选择排序：

开始时选择一个最小的元素为基准,一般我们把数组首元素看成最小的元素进行第一次比较,好依次和后面的数比较.

这里我们以升序为准,在一组数中:

第一个数和n-1个数进行比较,找到比他小的数时,与其交换下标，接着和后面的数在比较，直到比较到最后一个数,再让最小的数和第1个数进行交换.

第二个数和n-2个数进行比较找到此最小的数和第二个数交换进行交换,.....

比如以48，63，35，77，15 举例说明：

第一趟：首先我们记录首元素48的下标k,把他看成最小的元素下标,让他和后面的4个元素比较，发现35比他小,于是就把35的下标j 赋值给48的下标k,(让k记录最小元素下标,这时候最小元素变成了35，则35在和后面的数进行比较,）,再让后面的数和35进行比较，发现15比35更小 ,于是就把15的下标赋给了35的下标k(k记录最小元素下标),这时已经比较到了最后一个元素，则此时停止比较,把这个最小的元素和第一个元素交换位置！则第一趟比较为:{15,63,48,77,35}

第二趟:{15,63,48,77,35}，则把第二个元素看出最小,也就是把63看成最小,并记录他的下标为k，这时候让他和后面的3个元素比较,发现48比他小，,于是就把48的下标j 赋值给63的下标k,(让k记录最小元素下标,这时候最小元素变成了48，则48在和后面的数进行比较,）,再让后面的数和48进行比较，发现35比48更小 ,于是就把35的下标赋给了48的下标k(k记录最小元素下标),这时已经比较到了最后一个元素，则此时停止比较,把这个最小的元素和第二个元素交换位置！则第二趟比较为:{15,35,63,77,48}

第三趟到最后一趟比较方法同上！

package Nishui;

public class XuanZe {

public static void main(String[] args) {

int array[] = {1,4,2,7,9,0,5};
int arr[] = SeleSort(array);
for(int i = 0;i<arr.length;i++){

System.out.print(arr[i] + "\t");

}

}

public static int[] SeleSort(int[] array){

for(int i = 0;i<array.length;i++){
int k = i;//k记录每一次比较的最小元素下标
for(int j = 0;j<array.length;j++){//进行比较，看以i为下标的元素是否为最小元素！

//不是的话，则进行下标赋值,

if(array[j] > array[k]) k = j;

}

if(k!=i)//说明以i为下标的元素并非最小元素,让他和i交换位置
{

int t = array[i];

array[i] = array[k];

array[k] = t;

}

}

return array;

}
}

4.快速排序:

从待排序的一组数中,选择第一个数为基准,让他和后面的数进行比较,比他小的放左边，比他大的放右边.

具体的细节为假如待排序数组为r[left',r[left+1],,,r[right]，则可以设2个指针i和j，他们的初值为r[left]和r[right].

开始时，首先将基准数r[left]放在变量x中,使得r[i]或者r[left]为空，然后进行以下2种操作,直到i 和 j 相遇时结束！

(1)j 从右向左扫描,直到 r[j].key <x.key时,把 r[j].key的值移至空单元r[i]中,此时的r[j]相当于空单元.

(2)i 从左向右扫描,直到r[i].key<x.key时,把r[i]的值移至空单元r[j]中，此时r[i]又相当于空单元了.

当i 和 j 相遇时结束操作,此时r[i]的左边的数比他小,右边的数比他大,此时就完成了快排的第一次划分,接下来的第二次划分和第一次,这时把r[i] 的左边当成一组数进行划分,r[i]的右边当成一组数也进行如上划分即可！

比如以48，63，35，77，15 举例说明：

第一趟划分后为:

{15,35 } 48 { 77,63}

快速排序:{15,35} 结束

{63,77}结束

最终结果: 15,35,48,63,77

package Nishui;

public class KuaiSu {

public static void main(String[] args) {

int array[] = {1,4,2,7,9,0,5};
int arr[] = QSort(array,0,array.length-1);
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i] + "\t");
}

}

public static int[] QSort(int[] array,int low,int hight){

if(low<hight){

int s = array[low];

int i = low;

int j = hight+1;

while(true){

while(i+1 < array.length&& array[++i]<s);//向右寻找大于s的数组元素索引

while(j-1 >-1&& array[--j]>s);//向左寻找小于s的数组元素索引

if(i>=j){//如果 i 大于等于 j ，则退出循环

break;

}

else{//交换i和j 位置的元素值

int t = array[i];

array[i] = array[j];

array[j] = t;

}

}

array[low] = array[j];

array[j] = s;

QSort(array,low,j-1);//对左边进行递归

QSort(array,j+1,hight);//对右边进行递归

}

return array;

}
}