第一个:冒泡排序(Bubble_sort)
对于冒泡排序可谓最简单了,但是有时候会有很多人不理解它的排序思想,而忘记它的打法。
举个例子int []array = {5,1,3,2,4};冒泡排序是排array.length-1次躺序,为什么?
因为冒泡排序是稳定排序,而且每一次趟序都能把一个数字放在最终固定的位置上,所以,当排序到最后一个数字的时候就不用再排序了。所以总共排array.length-1次趟序。
冒泡排序的每一次趟序都是从0号位索引开始依次往后两两比较,且每一次排好一个数字,就减少一个数字的比较,所以在第二个for循环中会出现for(int j=0;j<array.length-1-i;j++)的情况。
两两比较的时候,判断前面的数字大于后面的数字时进行两两交换。
冒泡排序代码如下:
package sort_algorithm;
public class Bubble_sort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
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 temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
for(int i:array)
{
System.out.print(i+" ");
}
System.out.println();
}
}
第二个:归并排序(MergeSort)
很多人都觉得归并排序原理很简单,但是不知道代码该怎么打,觉得代码应该很复杂吧,毕竟是归并嘛。
归并排序整体的思想是递归,将一个数组不断从中间分成两半,然后比较排序,用新的排出顺序来的数组覆盖老数组,直至排号序,先归并再排序的思想进行递归调用。而且归并的递归有如折半查找和折半排序。
package sort_algorithm;
public class MergeSort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
sort(array,0,array.length-1);
for(int i:array)
System.out.print(i+" ");
System.out.println();
}
public static void sort(int[]a,int low,int high)
{
int mid = (low+high)/2;
if(low<high)
{
sort(a,low,mid);
sort(a,mid+1,high);
merge(a,low,mid,high);
}
}
public static void merge(int[]a,int low,int mid,int high)
{
int i=low;
int j=mid+1;
int []temp = new int[high-low+1];
int index=0;
while(i<=mid&&j<=high)
{
if(a[i]>a[j])
{
temp[index++]=a[j++];
}
else if(a[i]<a[j])
{
temp[index++]=a[i++];
}
}
while(i<=mid)
{
temp[index++]=a[i++];
}
while(j<=high)
{
temp[index++]=a[j++];
}
for(int x=0;x<temp.length;x++)
{
a[x+low]=temp[x];
}
}
}
第三个:快速排序(quickSort)
快速排序将第一个数字为关键字key,选择一个 i 索引和一个 j 索引,i 从头往尾遍历,寻找第一个大于key的值,j 从尾往头遍历寻找第一个小于key的值。然后再i<j的时候交换,当i>j后,将array[j]于array[key]交换,将该数组以原来的key为分界点分为两个数组,然后进行重复以上的操作,进行递归调用
源代码如下:
package sort_algorithm;
public class QuickSort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
quickSort(array);
for(int i:array)
{
System.out.print(i+" ");
}
System.out.println();
}
public static void quickSort(int[]a)
{
quickSort(a,0,a.length-1);
}
public static void quickSort(int[]a,int low,int high)
{
if(low>high)
return;
int i = low;
int j = high;
int key = a[low];
while(i<j)
{
while(i<j&&a[j]>key)
{
j--;
}
while(i<j&&a[i]<=key)
{
i++;
}
if(i<j)
{
int p = a[i];
a[i] = a[j];
a[j] = p;
}
}
int p = a[j];
a[j] = a[low];
a[low] = p;
quickSort(a,low,j-1);
quickSort(a,j+1,high);
}
}
第四个:简单选择排序
简单选择排序,是将先将第一个元素作为最小元素,然后向后遍历数组,寻找出一个最小的且小于第一个元素的数字,进行交换,然后将数组中第二个数字再次作为最小元素,然后向后遍历所有数字,寻找一个最小的且小于第二个数字的数与其交换,然后以此类推,往后遍历。
源代码如下:
package sort_algorithm;
public class Select_sort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
for(int i=0;i<array.length-1;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[i]>array[j])
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
for(int i:array)
{
System.out.print(i+" ");
}
System.out.println();
}
}
第五个:简单插入排序
简单插入排序形象的解释是这样的 5,2,3,1,4;
(5)2,3,1,4
(2,5)3,1,4
(2,3,5)1,4
(1,2,3,5),4
(1,2,3,4,5)
解释完毕。
源代码如下:
package sort_algorithm;
public class Simple_insertion_sort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
for(int i=0;i<array.length-1;i++)
{
for(int j=i+1;j>0;j--)
{
if(array[j]<array[j-1])
{
int temp = array[j];
array[j] = array[j-1];
array[j-1] = temp;
}
}
}
for(int i:array)
{
System.out.print(i+" ");
}
System.out.println();
}
}
第六个:希尔排序
希尔排序是难化的简单插入排序,一般取数组长度一半作为初始化标准值的gap,以gap为步长间隔进行数组中数字的排序,gap每次以除2 的方式缩小,知道缩小到步长为1。在数组中步长间隔为gap的数字直接进行比较和排序,随着gap的逐渐缩小,数组直接的组数也也越来越小,知道gap=1后,数组排序完毕
源代码如下:
package sort_algorithm;
public class Shell_sort
{
public static void main(String[]args)
{
int[]array = {6,1,7,3,4,2,5,10,9,8};
for(int gap = array.length/2;gap>0;gap/=2)
{
for(int i=gap;i<array.length;i++)
{
int j = i;
while(j-gap>=0&&array[j-gap]>array[j])
{
int temp = array[j-gap];
array[j-gap] = array[j];
array[j] = temp;
j-=gap;
}
}
}
for(int i:array)
System.out.print(i+" ");
System.out.println();
}
}