冒泡排序和直接插入排序和和快速排序和选择排序

简单排序（学完了要及时复习，不然像没学一样，而且

以后要花更多的时间）

冒泡排序：小的数往上冒

冒泡排序（BubbleSort）是重复地走访要排序的数列，

一次比较两个元素，如果他们的顺序错误，就把他们就

把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

 

原理：

1.比较相邻的元素。如果第二个比第一个大，就交换他们两个。（小的在前）

2.对每一对相邻元素作同样的工作，从第一对到结尾的

最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，出最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到

没有任何一对数字需要比较。

 

时间复杂度：

若文件的初始状态是正序的，一趟扫描即可完成排序。

所需要的关键字比较次数C和记录和记录移动次数M

均达到最小值：Cmin=n-1;

Mmin=0；

所以冒泡排序最好的时间复杂度为O(n)。

public class BubbleSort{
    public static void sort(long[] arr){
        long tmp=0;
        for (int i=0;i<arr.length-1;i++) {
            //趟数,并让最小的于前
        for (int j=arr.length-1;j>i;j--) {
                if (arr[j]<arr[j-1]) {
                    //进行交换
                    tmp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=tmp;
                }
            }    
        }
    }
}

public class TestSort1{
    public static void main(String[] args) {
        long[] arr=new long[5];
        arr[0]=34;
        arr[1]=23;
        arr[2]=2;
        arr[4]=1;
        arr[3]=-4;
        //如果没有赋值完的话，后面的直接补0
        System.out.print("[");
        for (long num:arr){
            //用法？？
            System.out.print(num+" ");

        }
        System.out.print("]");
        System.out.println();

        BubbleSort.sort(arr);
        //排序后再打印 

        System.out.print("[");
        for(long num:arr){
            System.out.print(num+" ");
        }
        System.out.print("]");
        System.out.println();

    }
}
/*
运行结果：
  i         j
[34 23 2 -4 1 ]
[-4 1 2 23 34 ]
*/

//自己再去默写一次

 

选择排序：

选择最小的于前并交换位置，其余不变

public class SelectionSort1{
    public static void sort(long[] arr){
        int k=0;
        long tmp=0;
        for (int i=0;i<arr.length-1;i++) {
            //趟数小于length-1，因为最后一个不用排序，就是最大的
            k=i;
            //最小的指向数，k去指向
            for (int j=i;j<arr.length;j++) {
                //为什么是arr.length而不是length-1?length-1只能到length-1
              //边界位置还是要思考思考！！最后再测试测试
                if(arr[j]<arr[k]) {
                    k=j;
                }
            }
            tmp=arr[i];
            arr[i]=arr[k];
            arr[k]=tmp;
        }
    }
}

public class TestSort2{
    public static void main(String[] args) {
        long[] arr=new long[5];
        arr[0]=34;
        arr[1]=23;
        arr[2]=2;
        arr[4]=1;
        arr[3]=-4;
        //如果没有赋值完的话，后面的直接补0
        System.out.print("[");
        for (long num:arr){
            //用法？？
            System.out.print(num+" ");

        }
        System.out.print("]");
        System.out.println();

        SelectionSort1.sort(arr);
        //排序后再打印

        System.out.print("[");
        for(long num:arr){
            System.out.print(num+" ");
        }
        System.out.print("]");
        System.out.println();

    }
}
/*
arr.length-1的循环结果
[34 23 2 -4 1 ]
[-4 2 23 34 1 ]
arr.length的循环结果
[34 23 2 -4 1 ]
[-4 1 2 23 34 ]
*/

直接插入排序：

直接插入排序是一种简单的插入排序法，其基本思想是

把待排序的记录按其关键码值的大小逐个插入到一个已经

排好序的有序序列中，直到所有的记录插入完为止，得到

一个新序列。

例如，已知待排序的一组记录是

60,71,49,11,24,3,66

假设在排序过程中，前三个记录已经按关键码值递增

的次序重新排序，构成一个有序序列：

49，60，71

将待排序记录中的第四个记录11插入尚需序列总，得到

一个新的含4个记录的有序序列。

1.设置监视r0，将待插入记录的值赋给r0；

2.设置开始查找的位置j；

3.在数组中进行搜索，搜索中将第j个记录后移，直到

r0.key>=[j].key为止；

4.将r0插入r[j+1]的位置上

 

 

快速排序

package Sort;

import java.util.Arrays;

public class QuickSort {
    public static void sort(int a[], int low, int hight) {
        int i, j, index;
        if (low > hight) {
            return;                  
        }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        while (i < j) { // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index)
                j--;
            if (i < j)
                a[i++] = a[j];// 用比基准小的记录替换低位记录
            while (i < j && a[i] < index)
                i++;
            if (i < j) // 用比基准大的记录替换高位记录
                a[j--] = a[i];
        }
        a[i] = index;// 将基准数值替换回 a[i]
        sort(a, low, i - 1); // 对低子表进行递归排序  i - 1 ??
        sort(a, i + 1, hight); // 对高子表进行递归排序

    }

    public static void quickSort(int a[]) {
        sort(a, 0, a.length - 1);
    }

    public static void main(String[] args) {

        int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }
}