冒泡排序算法及相应的优化

/*

*代码亲自测试

*/
public class BubbleSort {
    //冒泡排序：简单算法
    public int[] sort1(int[] arr)
    {
        int temp = 0;
        for(int i = 0; i < arr.length; i++)
        {
            
            for(int j = 0; j < arr.length-i-1; j++)
            {
                if(arr[j]>arr[j+1] )
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
    //冒泡排序优化1:假设我们现在排序arr[]={1,2,3,4,5,6,7,8,10,9}这组数据，
    //按照上面的排序方式，第一趟排序后将10和9交换已经有序，接下来的8趟排序就是多余的，什么也没做。
    //所以我们可以在交换的地方加一个标记，如果那一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。
    public int[] sort2(int[] arr)
    {
        int temp = 0;
        int flag = 0;
        for(int i = 0; i < arr.length; i++)
        {
            flag = 0;
            for(int j = 0; j< arr.length-i-1;j++)
            {
                if(arr[j] > arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = 1;
                }
            }
            if(flag == 0)
            {
                return arr;
            }
        }
        return arr;
    }
    //冒泡排序优化2：优化一仅仅适用于连片有序而整体无序的数据(例如：1， 2，3 ，4 ，7，6，5)。
    //但是对于前面大部分是无序而后边小半部分有序的数据(1，2，5，7，4，3，6，8，9，10)排序效率也不可观，对于种类型数据，
    //我们可以继续优化。既我们可以记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。
    public int[] sort3(int[] arr)
    {
        int temp = 0;
        int flag = 0;
        int k = arr.length-1;
        int pos = 0;
        for(int i = 0; i< arr.length;i++)
        {
            flag = 0;
            for(int j = 0; j < k; j++)
            {
                if(arr[j] > arr[j+1])
                {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j] = temp;
                    flag =1;
                    pos = j;
                }
            }
            if(flag == 0)
            {
                return arr;
            }
            k = pos;
        }
        return arr;
    }
    //冒泡排序优化3：一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面。例如：排序数据1，2，3，4，5，6，0
    public int[] sort4(int[] arr)
    {
        int pos =0;//存储最后一个交换位置
        int flag = 0; //存储是否交换过
        int temp = 0;//临时变量
        int n=0;
        int k = arr.length -1;
        for(int i = 0; i < arr.length; i++)
        {
            flag = 0;
            for(int j = n; j < k; j++)
            {
                if(arr[j] > arr[j+1])
                {
                    temp= arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    pos = j;//获取最后交换位置
                    flag = 1;
                }
            }
            if(flag == 0)
            {
                return arr;
            }
            k = pos;//下一次比较到记录位置即可
            for(int j = k; j>n;j--)
            {
                if(arr[j] < arr[j-1])
                {
                    temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                    flag = 1;
                }
            }
            n++;
            if(flag == 0)
            {
                return arr;
            }
        }
        return arr;
    }
}

转载于:https://www.cnblogs.com/zhangchuan1001/p/10715218.html