算法

排序算法

内排序(Internal Sorting)：整个排序过程中所有的记录都可以直接存放在内存中
外排序(External Sorting)：内存无法容纳所有记录，排序过程中还需要访问外存

排序分类

插入排序

直接插入 O(n*n) 稳定

 public  void insert(int[] arr,int n){
       int j=0;
       int tem=0;
       for(int i=1;i<n;i++)
       {
           tem=arr[i];
           j=i-1;
           while(j>=0&&arr[j]>tem){
                arr[j+1]=arr[j];
                j--;
            }
            arr[j+1]=tem;
       }    
     }

Shell排序 O(n*n) 不稳定

public void shell(int[] arr,int n){
       int j=0;
       int tem=0;
    for(int inc=n/2;inc>0;inc=inc/2)
        for(int i=inc;i<n;i++){
           tem=arr[i];
           j=i-inc;
           while(j>=0&&arr[j]>tem){
                arr[j+inc]=arr[j];
                j=j-inc;
                }we
            arr[j+inc]=tem;
    }

}

选择排序

直接选择 不稳定

 public void select(int[] arr,int n){
            int min=0;
            int k=0;
            for(int i=0;i<n-1;i++){
                min=Integer.MAX_VALUE;
                for(int j=i;j<n;j++){
                    if(arr[j]<min) {
                      min=arr[j];
                      k=j;
                    }
                }
                arr[k]=arr[i];
                arr[i]=min;
            }
        }

堆排序 不稳定

交换排序

冒泡排序 稳定

 public void buble(int[] arr,int n){
          int tem=0;
          for(int i=1;i<n;i++)
              for(int j=n-1;j>=i;j--){
               //
                if(arr[j]>arr[j-1]){
                   tem=arr[j];
                   arr[j]=arr[j-1];
                   arr[j-1]=tem;            
                }
            }
        }

快速排序 不稳定

归并排序 稳定

基数排序 稳定

 public  void main()