数组中五种排序方法（冒泡，选择，插入，希尔，快速排序）以及二分法查找和杨辉三角

五种排序方法以及二分查找和杨辉三角

一，冒泡排序（两个相邻的元素进行比较，小的向前，大的向后）

public class TestSort {

    public static void main(String[] args) {
        //int[] nums={20,8,1,15,23};
        int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前");
        for (int num : nums) {
            System.out.print(num+",");
        }
        bubbleSort(nums);
        quickSort(nums, 0, nums.length-1);
        System.out.println();
        System.out.println("排序之后");
        for (int num : nums) {
            System.out.print(num+",");
        }

    }
    //冒泡排序(N个数字来排列，两两比较小靠前，外层循环n-1,内层循环n-i-1)
    public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
    }
 }

二，选择排序（选择一个元素，让选择依次和后面的元素进行比较，小的向前，大的向后）

public class TestSort {

    public static void main(String[] args) {
        //int[] nums={20,8,1,15,23};
        int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前");
        for (int num : nums) {
            System.out.print(num+",");
        }
        selectSort2(nums);
        quickSort(nums, 0, nums.length-1);
        System.out.println();
        System.out.println("排序之后");
        for (int num : nums) {
            System.out.print(num+",");
        }

    }
    //选择排序
    public static void  selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int t=arr[i];
                    arr[i]=arr[j];
                    arr[j]=t;
                }
            }
        }
    }
    //优化选择排序
    public static void  selectSort2(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            int pos=i;//pos指向最小的元素
            for(int j=i+1;j<arr.length;j++){
                if(arr[pos]>arr[j]){
                    pos=j;//一定指向最小的元素
                }
            }
            if(i!=pos){
                int t=arr[i];
                arr[i]=arr[pos];
                arr[pos]=t;
            }
        }
    }
 }

三，插入排序（从第二元素开始，向前找到插入的位置，保证前面的元素都有顺序）

public class TestSort {

    public static void main(String[] args) {
        //int[] nums={20,8,1,15,23};
        int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前");
        for (int num : nums) {
            System.out.print(num+",");
        }
        insertSort(nums);
        quickSort(nums, 0, nums.length-1);
        System.out.println();
        System.out.println("排序之后");
        for (int num : nums) {
            System.out.print(num+",");
        }

    }
    //插入排序
    public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            for(int j=i-1;j>=0;j--){
                if(arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
    }
    //优化插入排序
    public static void insertSort2(int[] arr){
        for(int i=1;i<arr.length;i++){
           int t=arr[i];
           int pos=i-1;
           while(pos>=0&&arr[pos]>t){
                arr[pos+1]=arr[pos];
                pos--;
           }
           arr[pos+1]=t;
        }
    }
 }

四，希尔排序（是直接插入排序算法的一种更高效的改进版本）

public class TestSort {

    public static void main(String[] args) {
        //int[] nums={20,8,1,15,23};
        int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前");
        for (int num : nums) {
            System.out.print(num+",");
        }
        //bubbleSort(nums);
        //selectSort2(nums);
        //insertSort2(nums);
        //Arrays.sort(nums);
        //shellSort(nums);
        quickSort(nums, 0, nums.length-1);
        System.out.println();
        System.out.println("排序之后");
        for (int num : nums) {
            System.out.print(num+",");
        }

    }
    //希尔排序
    public static void shellSort(int[] arr){
        int gap=arr.length;
        while(true){
            gap/=2;
            for(int i=0;i<gap;i++){
                for(int j=i+gap;j<arr.length;j+=gap){//插入排序
                    int t=arr[j];
                    int pos=j-gap;
                    while(pos>=0&&arr[pos]>t){
                        arr[pos+gap]=arr[pos];
                        pos-=gap;
                    }
                    arr[pos+gap]=t;
                }
            }
            if(gap==1){
                break;
            }
        }
    }
 }

五，快速排序（通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小；然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。）

public class TestSort {

    public static void main(String[] args) {
        //int[] nums={20,8,1,15,23};
        int[] nums={10,38,65,97,76,13,27,49,78,34,12,64,1};
        System.out.println("排序之前");
        for (int num : nums) {
            System.out.print(num+",");
        }
        //bubbleSort(nums);
        //selectSort2(nums);
        //insertSort2(nums);
        //Arrays.sort(nums);
        //shellSort(nums);
        quickSort(nums, 0, nums.length-1);
        System.out.println();
        System.out.println("排序之后");
        for (int num : nums) {
            System.out.print(num+",");
        }

    }
    //快速排序 :采用递归分治的思想

    public static void quickSort(int[] arr,int start,int end){
        int i=start;
        int j=end;
        int pivot=arr[start];
        while(i<j){
            //从后向前
            while(i<j&&arr[j]>pivot){
                j--;
            }
            arr[i]=arr[j];
            i++;
            //从前向后
            while(i<j&&arr[i]<pivot){
                i++;
            }
            arr[j]=arr[i];
            j--;
        }

        arr[i]=pivot;

        //前面有元素
        if(i-1>start){
            quickSort(arr, start, i-1);
        }
        //后面又元素
        if(j+1<end){
            quickSort(arr, j+1, end);
        }


    }

}

六，二分法查找（二分查找的前提是数据必须有序）

public class TestArray7 {

    public static void main(String[] args) {
        int[] arr={10,38,65,97,76,13,27,49,78,34,12,64,1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        int i = binarySearch(arr, 50);
        System.out.println(i);

        //Arrays.binarySearch(, )

    }

    public static int binarySearch(int[] arr,int key){
        int low=0;
        int upper=arr.length-1;
        while(low<=upper){
            int mid=(low+upper)>>>1;
            if(key<arr[mid]){
                upper=mid-1;
            }else if(key>arr[mid]){
                low=mid+1;
            }else{
                return mid;
            }
        }

        return -1;
    }
}

七，杨辉三角

public class Homework16 {
    public static void main(String[] args) {
        /**
         * 8行8列的杨辉三角
         */
        int row = 6;//行数
        int[][] yanghui = new int[row][row];//6行6列数组

        for (int i = 0; i < row; i++){//行
            for(int j = 0;j<= i;j++){//列
                if (j==0 || j==i){
                    yanghui[i][j]=1;

                }else{
                    yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
                }
//              System.out.print(yanghui[i][j]+" ");
            }
//          System.out.println();
        }
        //等腰输出处理
        for (int i = 0; i < row; i++){
            int num = row -i;
            for(int j = 0;j<= num;j++){
                System.out.print(" ");
            }
            for(int k= 0;k<= i;k++){
                System.out.print(yanghui[i][k]+" ");
            }
            System.out.println();
        }
    }
}