Java中常用的四种排序算法

···

package day0301;

public class bubblingSort {
public static void main(String[] args) {
bubblingSort s=new bubblingSort();
int[]arr= {6,3,8,2,9,1};
s.bubbling(arr);
}
/**
 * 冒泡排序 -- bubbling
 * 原理:比较两个相邻的元素,将值大的元素交换至右端
 * 思路:依次比较相邻的两个数,将小数放在前面,大的数放在后面,一次循环结束,执行第二次循环
 * 总结:N个数字要排序完成,总进行N-1躺排序,每i趟排序此时为N-1次,所以可以用双重循环语句,外层控制循环多少趟
 * 内层控制每趟的循环次数
 * 每次比较之后都会找到一个最大值,当再次排序的时候就不用考虑最大值,也就是每比较一次第二次比较就会少比一次
 * 时间复杂度：如果正序 最小为O(n) 最大为O(n^2)
 * 
 * 自己想到的 如果中间有两个数字的顺序是按顺序的不需要比较 这么时间复杂度中这趟排序就会是N-2次
 * */
public  void bubbling(int[]arr) {
System.out.println("排序前数组为");
for(int num:arr) {
System.out.println(num+"");
}
for(int i=0;i<arr.length-1;i++) {//外层控制排序的趟数
for(int j=0;j<arr.length-i-1;j++) {//内层控制每趟要排几次
if(arr[j]<arr[j+1]) {
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
for(int num:arr) {
System.out.println(num+"");
}
System.out.println();
}
}
System.out.println("排序后的数组为:");
for(int num:arr) {
System.out.println(num+"");
}
}

}

···

···

package day0301;


import java.util.Arrays;


public class insertSort {
/**
* 直接插入--insertSort 思想:对于给定的一个数组,初始时假设第一个记录自成一个有序序列,其余记录为无序序列,接着从第二个记录开始,按照记录的大小
* 依次将当前处理的记录插入到其之前的有序序列中,知道最有一个记录到有序序列中为止
*/
public static void insertSrot(int[] a) {
int tmp;
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j--) {
if (a[j] < a[j - 1]) {
tmp = a[j - 1];
a[j - 1] = a[j];
a[j] = tmp;
}
}
System.out.println(Arrays.toString(a));
}
}
public static void main(String[]args) {
int[]a= {49,38,65,97,76,13,27,50};
insertSrot(a);
for(int i:a) {
System.out.println(i+"");
}
}
}

···

···

package day0301;


public class quickSort {
/**
 * 快速排序 --quickeSort
 * 思想:基于分治的思想,是冒泡排序的改进型,首先在数组中选择一个基准点(该基准点的选取
 * 可能影响到快速排序的效率),然后分别从数组的两端扫描数组,设两个指标(lo指向起始位置
 * hi指向末尾),首先从后半部分开始,如果发现有元素比该基准点的值小,就交换lo和hi的位置
 * ,然后从前半步分开始扫描,发现有元素大于基准点的值,就交换lo和hi的位置值,如此往复循环
 * 直到lo>=hi，然后把基准点的值放到hi这个位置,一次排序完成。之后采用递归的方式分别对
 * 前半部和后半部排序,当前半部和后半部均有序的时，该数组就自然有序的了
 * 优点:比较的次数少
 * 缺点:如果元素比较少的情况下效率会比较低
 * 对于基准位置的选取一般有三种方法：固定切分，随机切分和三取样切分。固定切分的效率并不是太好，
 * 随机切分是常用的一种切分，效率比较高，最坏情况下时间复杂度有可能为O(N2).对于三数取中选择基准点是最理想的一种。
 * 如果是奇数个数组元素 是最理想的基准数直接就是最中间的数
 * 还有如果一个数组总元素过少 可以直接用数组本身的点sort()方法直接排序
 * */
public static int partition(int[]array,int lo,int hi) {
//固定切分方式
int key =array[lo];
while(lo<hi){
while(array[hi]>key&&hi>lo) {//从后半部分向前扫描
hi--;
}
array[lo]=array[hi];
while(array[lo]<=key&&hi>lo) {//从前半部向后扫描
lo++;
}
array[hi]=array[lo];
}
array[hi]=key;
return hi;
}
public static void sort(int[]array,int lo,int hi) {
if(lo>=hi) {
return;
}
int index=partition(array,lo,hi);
sort(array,lo,index-1);
sort(array,index+1,hi);
}
//时间复杂度O(NlogN)
}

···

package day0301;


public class quickSort1 {
public static int partition(int[]array,int lo,int hi) {
//三数取中 代表的就是奇数个 lo代表1 hi代表最后 最后减一刚好是中间 中间在加以就是
//这个数组的中间值位置
int mid=lo+(hi-lo)/2;
if(array[mid]>array[hi]) {
swap(array[mid],array[hi]);
} 
if(array[lo]>array[hi]) {
swap(array[lo],array[hi]);
}
if(array[mid]>array[lo]) {
swap(array[mid],array[lo]);
}
int key =array[lo];
while(lo<hi) {
while(array[hi]>=key&&hi>lo) {
hi--;
}
array[lo]=array[hi];
while(array[lo]<=key&&hi>lo) {
lo++;
}
array[hi]=array[10];
}
array[hi]=key;
return hi;
}
public static void swap(int a,int b) {
int temp=a;
a=b;
b=temp;
}
public static void sort(int[] array,int lo,int hi) {
if(lo>=hi) {
return;
}
int index=partition(array, lo, hi);
sort(array,lo,index-1);
sort(array,index+1,hi);
}
}

···

···

package day0301;


public class selectSort {
/**
 * 选择排序--selectSort
 * 思想:对于给定的一组记录,经过第一轮比较后,得到最小的记录,然后将该记录与第一个记录的位置进行交换
 * 接着对不包括第一个记录以外的其他记录进行第二轮比较,得到最小的记录并与第二个记录进行位置交换
 * 重复该过程，直接进行比较的记录只有一个时为止
 * 平均O(n^2),最好O(n^2),最坏O(n^2);空间复杂度O(1);不稳定;简单
 * */
public static void selestionSort(int[]a) {
int n=a.length;
for(int i=0;i<n;i++) {
int k=i;
//找出最小值的坐标
for(int j=i+1;j<n;j++) {
if(a[j]<a[k]) {
k=j;
}
}
//将最小值放到排序列末尾
if(k>i) {
int tmp=a[i];
a[i]=a[k];
a[k]=tmp;
}
}
}
public static void main(String[] args) {
int[] b = {49,38,65,97,76,13,27,50};
selestionSort(b);
for(int i:b) {
System.out.println(i+"");
}
}
}

···

···