一、冒泡排序
冒泡排序是排序算法中最简单最暴力的算法，他主要的排序方式是将所排列的数据，两个两个进行比较，然后将较大的数（或较小的数）一点一点的排到最后一个，由于比较的过程中，最大数（最小数）移动的趋势像是冒水泡一样，所以叫冒泡排序。
比如我们现在获得一组数据{3,1,6,5,4,7},我们下面对这组数据进行排序演示。
首先，我们将3与他的下一个数据1相比较，我们发现3>1，所以我们将3与1交换位置，然后继续用3与6进行比较，6>3所以不进行交换，然后6与5比较，6>5,进行交换，所以下一位就是6与4比较，6>4进行交换，然后6与7比较，6<7,所以不进行交换。这样就完成了第一轮排序，此时我们得到的数组的最后一个空间里存储的值就会是最大值，所以我们下一轮的时候就不再去考虑他，等到再次进入下一轮循环的时候又会得到一个次大值，以此类推逐步将数组排序完成。下面是图解
第一轮外层循环
初始状态{3,1,6,5,4,7}， 第一轮内层循环后{1,3,6,5,4,7}
第二轮内层循环后{1,3,6,5,4,7}
第三轮内层循环后{1,3,5,6,4,7}
第四轮内层循环后{1,3,5,4,6,7}
第五轮内层循环后{1,3,5,4,6,7}
至此，第一轮外层循环结束。后续的则有大家自行推导，以下是代码图
import java.util.*;
public class maopao {
public static void main(String[] args) {
int[] a = {3,1,6,5,4,7};
maopao(a);
}
public static void maopao(int []a) {
int temp;
for(int i=0;i<a.length;i++)
{
for(int j=0;j<a.length-i-1;j++)
{
if(a[j]>a[j+1])
{
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
二、选择排序
选择排序是一种相较于冒泡排序更加快速的排序方法，他的排序方式是将拥有的数据逐个击破，依次处理，通过假定想要进行排序的下标存储空间内的元素作为最小元素，其下标作为最小下标然后通过与数组内的其他数据进行比较，从而找到最小值和其下标，与本轮所假定最小的值进行位置交换，例如第一轮，我们所找的就是应该放在下标为0的存储单元的元素，即这组数据的最小值。同样的第二轮为次小值，以此类推，直到数组完成排序工作。下面我们再次用{3,1,6,5,4,7}这组数据来进行演示
首轮确定啊下标0位置
通过交换后得到第一轮后的结果{1,3,6,5,4,7}
同理第二轮为{1,3,4,5,6,7}
第三轮。。。。直到最后完成排序
下面为该方法的代码实现
```java
import java.util.*;
public class xuanze {
public static void main(String[] args) {
int a[] = {3,1,6,5,4,7};
sort(a);
}
public static void sort(int[] a) {
int minIndex;
int temp;
for(int i=0;i<a.length;i++)
{
minIndex=i;
for(int j=i+1;j<a.length;j++)
{
if(min>a[j])
{
minIndex = j;
}
}
temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
三、插入排序
插入排序是我了解到的现金位置最快速的排序方式，我对于他的理解就像是打扑克牌时的一个码牌的过程，即把排从头到尾，从小大大，依次排列，每当摸进来一张牌，就与他前面的牌进行比较，如果比前面的牌小，那么就交换与前者的位置，然后在与前者比较，反复执行此类操作，直到这个数到了第一位或者前面的元素小于这个元素，我们依旧拿这一组数据来测试{3,1,6,5,4,7}
首先，我们把每个元素都看成一张牌，然后假定我们现在只能看到第一张牌3
然后我们抽到了第二张牌1，那么我们手里的牌序应该变成{1,3}，然后是第三场牌6，此时手里的牌序为{1，3，6}，紧接着第四张牌5，然后手里的牌序变为{1，3，5，6}，第五张4。。。{1，3，4，5，6}，最后就是第六张7。。。。{1，3，4，5，6，7}下面是代码的执行部分
import java.util.*;
public class cahrupaixu {
public static void main(String[] args) {
int a[] = {3,1,6,5,4,7};
sort(a);
}
public static void sort(int[] a) {
int temp;
for(int i=1;i<a.length;i++)
{
for(int j=i;j> 0 && a[j]<a[j-1];j--) {
temp = a[j-1];
a[j-1] = a[j];
a[j] = temp;
}
}
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
}
}
对数器
为了测试这阶段对于排序算法的学习，我编写了一个测试算法运行速率和排序是否准确的一个测试工具，主要的作用就是通过Java自身随机生成那大量的测试数据排除代码结果的偶然性，然后通过返回的执行所用时间来判断自己所写的算法的时间复杂度，从而检测出自己的算法的优劣程度，以下则是代码的实现
import java.util.*;
public class Duishuqi {
public static void main(String args[]) {
int testtime = 500000;//测试50万次
int maxSize = 100;//数据上限值为100
int maxValue = 100;//数组长度确定
boolean succeed = true;
long startTime = System.currentTimeMillis();
for(int i=0;i<testtime;i++) {
int [] arr1 = generateRandomArray(maxSize,maxValue);//编写方法
int [] arr2 = copyArray(arr1);
sort(arr1);//自己编写的某种排序方法
comparator(arr2);//调用java自身的排序方法
if(!Arrays.equals(arr1, arr2)) {//将java自身的方法的记过与缩写算法的结果
succeed = false; //相比较，判断是否相同，若相同，则算法正确
break;
}
}
long endTime = System.currentTimeMillis();//用于计算时间差
System.out.println(succeed?"Nice!":"Not Good!");
if(succeed) {//测定排序正确后算法所用的时间
System.out.println("Time:"+(endTime-startTime));
}
}
private static void comparator(int[] arr2) {//调用Java自带的数组排序方法
Arrays.sort(arr2);
}
private static int[] copyArray(int[] arr1) {//数组拷贝方法
int [] arr = new int [arr1.length];
for(int i=0;i<arr1.length;i++)
{
arr[i] = arr1[i];
}
return arr;
}
private static int[] generateRandomArray(int maxSize, int maxValue) {
//实现自动生成数据的方法
int [] arr = new int [maxValue];
for(int i=0;i<maxValue;i++)
{
arr[i] = (int) (Math.random()*maxSize);
}
return arr;
}