冒泡排序,插入排序,选择排序,希尔排序,归并排序

冒泡排序

import java.util.Arrays;

public class MaoPao {
public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7};
for(int i=0;i<a.length-1;i++) {
for(int j=0;j<a.length-1-i;j++) {
if(a[j]>a[j+1]) {
int temp =a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
System.out.print(Arrays.toString(a));
}
}

(第一个元素与第二个元素比大小，第一个比第二个大，则交换位子。然后接着交换过的第二个元素与第三个进行比较，以此类推，第一轮确定最后一个元素为最大值，第二轮确定倒数第二个元素，直到第一个元素为最小值)

时间复杂度O(n*n)

 

插入排序

import java.util.Arrays;

public class ChaRu {
public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7};
for(int i = 0;i < a.length;i++){
//将a[i]向前插入，
for(int j = i; j > 0 ;j--){
if(a[j] < a[j-1]){
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}else{
break;
}
}
}
System.out.println(Arrays.toString(a));
}
}

选择第i个元素，将第i个元素与第i-1个元素进行比较，小于则插入到前面的位子（也可以理解为交换位置）

时间复杂度为（n*n）

 

选择排序

import java.util.Arrays;

public class XuanZe {
public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7};
for(int i=0;i<a.length-1;i++) {
int min=i;//定义最小元素下标
for(int j=i+1;j<a.length;j++) {
if(a[j]<a[min]) {
min=j;//找最小值的下标
}
}
//交换位置
int temp=a[i];
a[i]=a[min];
a[min]=temp;
}
System.out.println(Arrays.toString(a));
}

}

第一轮遍历数组找到最小值的下标，然后和第一位交换位置，第二轮遍历，找到剩下元素中最小的值，选择其与第二个元素交换位置，以此类推

时间复杂度（n*n）

 

希尔排序

import java.util.Arrays;

public class XiEr {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[]=new int[] {5,22,10,52,3,1,7};
int n=a.length;
//希尔排序
for(int gap=n/2;gap>=0;gap--) {
//插入排序
for (int i=gap;i<n;i++) {
for(int j=i;j>0;j--) {
if(a[j]<a[j-1]) {
int temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
}
System.out.println(Arrays.toString(a));

/*int gap=1;//区间
while(gap>0) {
for(int i=gap;i<n;i++) {
int temp=a[i];
int j=i-gap;
//跨区间排列
while(j>=0&&a[j]>temp) {
a[j+gap]=a[j];
j-=gap;
}
a[j+gap]=temp;
}
gap=gap/3;
}*/

}
}

希尔排序是其中包含了插入排序

划分了区间gqp ，区间一般都是二分之一或者三分之一，最优的区间计算方法是没有答案，

希尔排序不断的缩小区间间隔来进行比较两个间隔区间值得大小，a[i]与a[i+gap]，来比较，

一直重复重复，直到gap为1的时候，其排序方法就是插入排序

/* */代码更简洁但是没理解是如何进行排序，

 

归并排序

import java.util.Arrays;

public class GuiBing {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[]=new int[] {5,22,10,52,3,1,7,100,-1};
sort(a);
System.out.println(Arrays.toString(a));
}

public static void sort(int []a,int start,int end) {
// TODO Auto-generated method stub
if(end==start+1) {
return;//如果只有一个元素
}
int mid = (end-start) / 2+ start;//中间位置
sort(a,start,mid);//前半部分排序
sort(a,mid,end);//后半部分排序
//后半部分第一个元素为mid而不是mid+1的原因？如果改为mid+1,则运行不出来

int i=start;
int j=mid;
int k=0;
int[] b=new int [end - start];
for(;i<mid&&j<end;) {
if(a[i]>a[j]) {
b[k++]=a[i++];//降序排序
}else {
b[k++]=a[j++];//降序排序
}
}
if(i<mid) {
while(i<mid) {//前半部分赋值
b[k++]=a[i++];
}
}else {
while(j<end) {//后半部分赋值
b[k++]=a[j++];
}
}
//两边数组排序合并到一起
for(int m=0;m<end-start;m++) {
a[m+start]=b[m];
}
}
public static void sort(int[] a) {
// TODO Auto-generated method stub
sort(a, 0, a.length);
}

}

归并排序分冶法的体现，把数组分为若干个小数组进行排序，然后再进行合并，

目前是把它分为两个数组，进行排序，但是第一个数组的最后一个元素，也是大数组的中间值mid，也是最第二个数组中第一个元素，这样在合并两个数组会更简别。