排序

冒泡

//O(n^2) O(1)
public class BubbleSort {
        public  static  void main(String[] args) {
           // int[] arr = {3, 9, -1, 10, -2,8,5,2,4,50};
            int[] arr=new int[80000];
            for(int i=0;i<80000;i++)
            {
                arr[i]=(int)(Math.random()*800000);
            }
            boolean flag=false;
            for (int j =  arr.length - 1;j>=0; j--)

            {   for (int i = 0; i < j; i++) {
                    if (arr[i] > arr[i + 1]) {
                        int k = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = k;
                        flag=true;
                    }

                }
                if(flag==false) break;
                else
                    flag=false;
            }
            for(int i=0;i<arr.length;i++)
            {
                System.out.println(arr[i]);
            }
        }
}

插入

//O(n^2) O(1)
public class InsertSort {
    public  static  void main(String[] args) {
        int[] arr = {101,34,119,1};



         insertSort(arr);
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
    //插入排序 时间复杂度 n^2
    public  static  void insertSort(int[] arr)
    {
        //逐步推导 便于理解

        //第一轮

        //定义待插入的数
        int insertVal=arr[1];
        int insertIndex=1-1;

        //找到插入的位置
        //1.insertIndex>=0保证在给insertval找插入位置时 不越界
        //2.insertVal<arr[insertIndex] 待插入的数还没有找到插入位置
        //3 就需要将arr[insertIndex]后移


        for(int i=1;i<arr.length;i++)
        {
            int val=arr[i];
           int j=i-1;
            while (j>=0&&val<arr[j]) {
            arr[j+1]=arr[j];
            // arr[j]=0;
              j--;
            }
            arr[j+1]=val;
            }
        }
    }

选择

//O(n^2) O(1)
public class SelectSort {
    public  static  void main(String[] args) {
         int[] arr = {3, 9, -1, 10, -2,8,5,2,4,50};
        //int[] arr=new int[80000];
       /* for(int i=0;i<80000;i++)
        {
            arr[i]=(int)(Math.random()*800000);
        }*/


          for (int i = 0; i < arr.length; i++) {
            int min=arr[i];
            int minj=i;
              for (int j = i; j < arr.length; j++)
              {
                if(arr[j]<min)
                {
                    min=arr[j];
                    minj=j;
                }
            }

                  int k = arr[i];
                  arr[i] = arr[minj];
                  arr[minj] = k;

        }

        for(int i=0;i<arr.length;i++)
        {
            System.out.println(arr[i]);
        }
    }
}

快排

//O(nlogn) O(logn)
public class QuickSort {

    public  static  void main(String[] args) {
        int[] arr={-9,-78,0,23,-567,70};
         qsort(arr,0,arr.length-1);
        System.out.println("arr="+ Arrays.toString(arr));
    }
    public static int[] qsort(int arr[],int start,int end) {
        int pivot = arr[start];
        int i = start;
        int j = end;
        while (i<j) {
            while ((i<j)&&(arr[j]>pivot)) {
                j--;
            }
            while ((i<j)&&(arr[i]<pivot)) {
                i++;
            }
            if ((arr[i]==arr[j])&&(i<j)) {
                i++;
            } else {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        if (i-1>start) arr=qsort(arr,start,i-1);
        if (j+1<end) arr=qsort(arr,j+1,end);
        return (arr);
    }
}

归并

//O(nlogn) O(n)
public class MergeSort {
    public  static  void main(String[] args) {
        int[] arr={8,4,5,7,1,3,6,2};
        int[] temp=new int[arr.length];
         mergeSort(arr,0,arr.length-1,temp);

    }

    //分+合的方法
    public  static  void  mergeSort(int[] arr,int left,int right,int[] temp)
    {
        if(left<right)
        {
            int mid=(left+right)/2;//中间索引
            //向左递归进行分解
            mergeSort(arr,left,mid,temp);
            //向右递归进行分解
            mergeSort(arr,mid+1,right,temp);
         //到合并时
            Merge(arr,left,mid,right,temp);
            System.out.println("arr="+ Arrays.toString(temp));
        }

    }

    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边序列的初始索引
     * @param right 右边序列的索引
     * @param mid 中间索引
     * @param temp 中转数组
     */
    //合并的方法
    private static  void Merge(int[] arr,int left,int mid,int right,int[] temp)
    {
        System.out.println("dd");
      int i=left; //初始化 i 左边有序序列的初始索引
        int j=mid+1;//初始化 j 右边有序序列的初始索引
        int t=0;//指向temp 数组的当前索引
       //（-）
        //先把左右两边（有序）的数据按照规则填充到temp数组
        //直到两边的有序序列有一边处理完为止

        while(i<=mid&&j<=right)
        {
            //如果左边的有序序列的当前小于等于右边有序序列的当前元素
            //即将左边的元素拷贝到temp中
            if(arr[i]<=arr[j])
            {
                temp[t]=arr[i];
                t+=1;
                i+=1;
            }
            else
            {
                //反之 将右边有序序列的当前元素填充到temp数组中
                temp[t]=arr[j];
                t+=1;
                j+=1;
            }
        }
        //（二）
        // 把有剩余数据的一边数据依次全部填充到temp

        while (i<=mid)//左边的有序序列还有剩余的元素，就全部填充到temp
        {
                temp[t]=arr[i];
                t+=1;
                i+=1;
        }
        while (j<=right)//右边的有序序列还有剩余的元素，就全部填充到temp
        {
            temp[t]=arr[j];
            t+=1;
            j+=1;
        }
        //（三）
        //把有temp数组的元素拷贝到arr
        //并不是每次都拷贝所有的
        t=0;
        int templeft=left;
        while (templeft<=right)//第一次合并时 templeft=0;right=1;
        {
            arr[templeft]=temp[t];
            t+=1;
            templeft+=1;
        }
    }
}

希尔

import java.util.Arrays;

public class ShellSort {
    public  static  void main(String[] args) {
        int[] arr=new int[80000];
        for(int i=0;i<80000;i++)
        {
            arr[i]=(int)(Math.random()*800000);
        }
        shellSort2(arr);
    }
    //交换法
    //使用逐步推导的方法来编写
    //O（nlogn）～O（n2） O(1)
    public static  void shellSort(int[] arr)
    {  int temp=0;
        //根据前面的逐步分析 使用循环语句
        for(int gap=arr.length/2;gap>0;gap=gap/2)
        {

            //第一轮
            //因为第一轮排序，是将10个数据分成了5组，
            for(int i=gap;i<arr.length;i++)
            {//遍历各组中所有的元素（共5组，每组两个元素），步长5
                for(int j=i-gap;j>=0;j-=gap)
                {
                    //如果当前元素大于加上步长后的那个元素，说明交换
                    if(arr[j]>arr[j+gap])
                    {
                        temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }

        }
        System.out.println("希尔排序后="+Arrays.toString(arr));
     /*
        //第一轮
        //因为第一轮排序，是将10个数据分成了5组，
        for(int i=5;i<arr.length;i++)
        {//遍历各组中所有的元素（共5组，每组两个元素），步长5
            for(int j=i-5;j>=0;j-=5)
            {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if(arr[j]>arr[j+5])
                {
                     temp=arr[j];
                    arr[j]=arr[j+5];
                    arr[j+5]=temp;
                }
            }
        }
        System.out.println("希尔排序第一轮后="+Arrays.toString(arr));
        //第二轮
        //因为第二轮排序，是将10个数据分成了2组，
        for(int i=2;i<arr.length;i++)
        {//遍历各组中所有的元素（共5组，每组两个元素），步长5
            for(int j=i-2;j>=0;j-=2)
            {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if(arr[j]>arr[j+2])
                {
                    temp=arr[j];
                    arr[j]=arr[j+2];
                    arr[j+2]=temp;
                }
            }
        }
        System.out.println("希尔排序第二轮后="+Arrays.toString(arr));
        //第三轮
        //因为第三轮排序，是将10个数据分成了1组，
        for(int i=1;i<arr.length;i++)
        {//遍历各组中所有的元素（共5组，每组两个元素），步长5
            for(int j=i-1;j>=0;j-=1)
            {
                //如果当前元素大于加上步长后的那个元素，说明交换
                if(arr[j]>arr[j+1])
                {
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println("希尔排序第三轮后="+Arrays.toString(arr));
        */
    }
    //对交换式希尔排序进行优化-移动法
    public static  void shellSort2(int[] arr) {
        //根据前面的逐步分析 使用循环语句
        //增量gap并逐步缩小增量
        for (int gap = arr.length / 2; gap > 0; gap = gap / 2) {
              //从第gap个元素，逐个对其所在的组进行直接插入排序
            for(int i=gap;i<arr.length;i++)
            {
                int j=i;
                int temp=arr[j];

                    while (j-gap>=0&&temp<arr[j-gap])
                    {
                        //移动
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    //当退出循环后
                    //就给temp找到了插入的位置
                    arr[j]=temp;

            }
        }
        System.out.println("希尔排序后="+Arrays.toString(arr));
    }
}

基数

//O(n*k) O(n+k)
public class RedixSort {
    public  static  void main(String[] args) {
        int[] arr = {53,3,542,748,14,214};

        redixSort(arr);
    }
    //基数排序方法
    public static  void redixSort(int[] arr)
    {
        //根据前面的堆导过程 可以得到前面基数排序的代码
        //1.得到数组中最大的数的位数
        int max=arr[0]; //假设第一个最大
        for(int i=1;i<arr.length;i++)
        {
            if(arr[i]>max)max=arr[i];
        }
        //得到最大数是几位数
        int maxlength=(max+"").length();




        //第一轮（针对每个元素的个位进行处理）

        //定义一个二维数组，表示10个桶，每个桶都是一个一维数组
        //为了防止在放入数的时候数据溢出，则每个一维数组的大小为arr.length
        int[][] bucket=new int[10][arr.length];

        //为了记录每个桶中，实际存放了多少个数据，我们定义了一个一维数组，来记录各个桶每次放入的数据个数
        int[] bucketElementCounts=new int[10];

        for(int i=0,n=1;i<maxlength;i++,n*=10)
        {
            //针对每个元素对应的位进行排序，第一次是个位，第二次是10位
            for(int j=0;j<arr.length;j++)
            {
                //取出每个元素的个位的值
                int digitOfElement=arr[j]/n%10;
                //放入对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            //按照这个桶的数据（一维数组的下标依次取出数据，放入原来数组）
            int index=0;
            //遍历每一个桶，并将桶中数据，放入到原数组
            for(int k=0;k<bucketElementCounts.length;k++)
            {
                //如果桶中有数据，才放入原数组
                if(bucketElementCounts[k]!=0)
                {
                    //循环第K个桶
                    for(int f=0;f<bucketElementCounts[k];f++)
                    {
                        arr[index++]=bucket[k][f];
                        //index++;
                    }
                }
                //第一轮处理后需要将每个bucketElementCounts[k]=0!!
                bucketElementCounts[k]=0;
            }
            System.out.println("第"+(i+1)+"轮"+ Arrays.toString(arr));
        }
       /* //第一轮
        for(int j=0;j<arr.length;j++)
        {
          //取出每个元素的个位的值
            int digitOfElement=arr[j]%10;
            //放入对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //按照这个桶的数据（一维数组的下标依次取出数据，放入原来数组）
        int index=0;
        //遍历每一个桶，并将桶中数据，放入到原数组
        for(int k=0;k<bucketElementCounts.length;k++)
        {
            //如果桶中有数据，才放入原数组
            if(bucketElementCounts[k]!=0)
            {
                //循环第K个桶
                for(int i=0;i<bucketElementCounts[k];i++)
                {
                    arr[index++]=bucket[k][i];
                    //index++;
                }
            }
            //第一轮处理后需要将每个bucketElementCounts[k]=0!!
            bucketElementCounts[k]=0;
        }
        System.out.println("第一轮"+ Arrays.toString(arr));
/*
        //========================
        //第二轮
        for(int j=0;j<arr.length;j++)
        {
            //取出每个元素的个位的值
            int digitOfElement=arr[j]/10%10;
            //放入对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //按照这个桶的数据（一维数组的下标依次取出数据，放入原来数组）
       index=0;
        //遍历每一个桶，并将桶中数据，放入到原数组
        for(int k=0;k<bucketElementCounts.length;k++)
        {
            //如果桶中有数据，才放入原数组
            if(bucketElementCounts[k]!=0)
            {
                //循环第K个桶
                for(int i=0;i<bucketElementCounts[k];i++)
                {
                    arr[index++]=bucket[k][i];
                    //index++;
                }
            }
            bucketElementCounts[k]=0;
        }
        System.out.println("第二轮"+ Arrays.toString(arr));

        //========================
        //第二轮
        for(int j=0;j<arr.length;j++)
        {
            //取出每个元素的百位的值
            int digitOfElement=arr[j]/100%10;
            //放入对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //按照这个桶的数据（一维数组的下标依次取出数据，放入原来数组）
        index=0;
        //遍历每一个桶，并将桶中数据，放入到原数组
        for(int k=0;k<bucketElementCounts.length;k++)
        {
            //如果桶中有数据，才放入原数组
            if(bucketElementCounts[k]!=0)
            {
                //循环第K个桶
                for(int i=0;i<bucketElementCounts[k];i++)
                {
                    arr[index++]=bucket[k][i];
                    //index++;
                }
            }
            bucketElementCounts[k]=0;
        }
        System.out.println("第三轮"+ Arrays.toString(arr));*/
    }
}