JAVA实现各种排序算法----更新中----

以下纯属练手，先不考虑优化，接近原版思想

快速排序：

也是用到最多的排序方法，这里写的是我的启蒙思想啊哈算法里面的样式，每个元素递归执行log(n)次，n个元素，时间复杂度为nlog(n)

import java.util.Scanner;
class quickSort {
static int[] a = {8,6,4,5,1,7,3,2};
static void quickSort(int left,int right) {
int i,j,t,tmp;

if(left>right)
return;
tmp = a[left];
i = left;
j = right;
while(i!=j) {
while(a[j] >= tmp && i<j) {
j--;
}
while(a[i] <= tmp && i<j) {
i++;
}
if(i<j){
a[i] ^= a[j];
a[j] ^= a[i];
a[i] ^= a[j];
}
}
a[left] = a[i];
a[i] = tmp;
quickSort(left,i-1);
quickSort(i+1,right);
return ;//整个排序的结束
}
public static void main(String[] args) {

//int n;
// Scanner sc = new Scanner(System.in);
// int n = sc.nextInt();
// for(int i = 1; i <= n; i++) {
//     a[i] = sc.nextInt();
// }
quickSort(0,7);
System.out.println(java.util.Arrays.toString(a));

}
}

插入排序：

其实就是两个集合思想，左边排序的好的，右边没有排序好的，不断从右边并入左边排序好的，i是当前位置，j=i-1是超前搜索一位

比如 a[0],a[1],a[2],a[3],a[4]

         1      3     5    9     2

此时找到a[i]

此时的 1 3 5 9 2就看做一个集合，要排序的集合，从2开始往后遍历，j只是往前搜索一步

i=4,j=3;因为a[3]=9比2大，2的位置就放9了，然后9的位置放5，直到遇到j=0,此时的1是比2小的，所以当前pos1的位置就放一开始存好的2.前面的j+1=i(pos)都已排好，然后这个pos1的位置之前的也在前面的插入排序排好，所以这步的排序就排好了。

class InsertSort {
    public static void main(String[] args) {
        int[] a = {8,6,7,4,5,3,2,1};
        int i,j;
        for(i = 1; i < 8; i++) {
            if(a[i] < a[i-1]) {//比较左边排好的序列，只要比最大的小，即要完成下面的插入操作。这一步tao哥其实已经说到，其实就算没有这步，在下面a[j]>tmp会判断，a[j]就等于a[i-1]，tmp就等于a[i]
                int tmp = a[i];
                for(j = i-1; j>=0&&a[j] > tmp; j--)
                    a[j+1] = a[j];
                
                    a[j+1] = tmp;//当前是a[j]<tmp,比较结束，把tmp插入赋给当前
            }
        }
        System.out.println(java.util.Arrays.toString(a));

    }
}

选择排序，每次找到最小的，依次插到i：0-n位置

class selectSort {
public static void main(String[] args) {
int j,min,i,index;
int[]a = {8,7,6,5,4,3,2,1};
for(i = 0; i < a.length; i++) {
min = a[i];
index = i;//初始化，其实也为什么意思
for( j = i+1; j < a.length; j++) {
if(min >= a[j]) {
min = a[j];
index = j;
}
}
a[index] = a[i];
a[i] = min;//每次找好的序列
System.out.println(min);
System.out.println(java.util.Arrays.toString(a));

}
}
}
}

交换排序：

import java.util.Arrays;

import javax.xml.transform.Templates;

/**
* 交换排序算法实现
*   第一个数与后面的数一一比较，如果后面的数比第一个数小，则交换，
*   交换完第一个元素继续与后面的数一一比较，一轮之后第一个数最小。
* @author htt
*
*/
public class SwapSort {
public int[] jhuang(int[] are){
int tmp = 0;
for(int j = 0;j < are.length;j++){
//int min = are[j];
for(int i = j+1;i < are.length;i++)
{
if(are[j] > are[i]){
tmp = are[j];
are[j] = are[i];
are[i] = tmp;
}
}
}
return are;
}

public static void main(String[] args) {
int[] n = new int[]{28,15,19,33,12};
SwapSort swapSort = new SwapSort();
int[] result = swapSort.jhuang(n);
System.out.println(Arrays.toString(result));
}

}