java学习之排序

排序

• 概念：排序是将一群数据，依指定的顺序进行排列的过程。
• 重要性：排序时数据处理中一种很重要的运算，也是很常用的运算，一般数据处理工作25%的时间都是在进行排序。

– 交换式排序法：属于内部排序法，是运用数据值比较后，依判断规则对数据位置进行交换，以达到排序的目的。主要有冒泡排序、快速排序。
– 选择式排序法：属于内部排序法，是从待排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，再依原则交换位置后达到排序的目的。分为选择排序法、堆排序法。
– 插入式排序：属于内部排序法，是对于待排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。分为插入排序法、希尔排序法、二叉树排序法。

冒泡排序

    public class Sort 
{
    public static void main(String[] args) 
    {
        int arr[]={1,5,-1,8,4};

        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 temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
    }
}   

快速排序法

public class Sort 
{
    public static void main(String[] args) 
    {
        int len=15;
        int[] arr=new int[len];
        for(int i=0;i<len;i++)
        {
            arr[i]=(int)(Math.random()*100);
        }
    //  quickSort1(arr, 0, arr.length-1);
        quickSort2(arr, 0, arr.length-1);
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
    }

/*  public static void quickSort1(int a[],int left,int right)
    {
        int l=left;
        int r=right;
        int pivot=a[(l+r)/2];//找一个基准数,这里就取中间的
        while(l<r)
        {
            while(a[l]<pivot)l++;
            while(a[r]>pivot)r--;

            if(l>=r)break;

            int temp=a[l];
            a[l]=a[r];
            a[r]=temp;
        }
    //  System.out.println(pivot);
    //  System.out.println(l);
    //  System.out.println(r);
        if(left<r-1)quickSort1(a,left,r-1);
        if(right>l+1)quickSort1(a,l+1,right);
    }*/
    public static void quickSort2(int a[],int left,int right)
    {
        if(left<right)
        {
            int l=left,r=right,pivot=a[l];
            while(l<r)
            {
                while(l<r&&a[r]>pivot)r--;
                if(l<r)
                    a[l++]=a[r];
                while(l<r&&a[l]<pivot)l++;
                if(l<r)
                    a[r--]=a[l];
            }
            a[l]=pivot;
            quickSort2(a,left,l-1);
            quickSort2(a,l+1,right);
        }
    }
}

选择排序法

int arr[]={1,5,-1,8,4};
    for(int i=0;i<arr.length-1;i++)
        {
            int min=arr[i];
            int minIndex=i;
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[j]<min)
                {
                    min=arr[j];
                    minIndex=j;
                }
            }
            //找到最小值得位置,交换位置
            int temp=arr[i];
            arr[i]=arr[minIndex];
            arr[minIndex]=temp;
        }
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
         }

插入排序法：

for(int i=1;i<arr.length;i++)
{
//要插入的数
int insertVal=arr[i];
//和前一个数比较
int index=i-1;
while(index>=0&&insertVal<arr[index])
{
//把arr[index]向后移
arr[index+1]=arr[index];
index--;
}
//把insertVal插入适当位置
arr[index+1]=insertVal;
}