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));
    }

}