排序算法之交换排序-冒泡排序与快速排序

1.冒泡排序

1.1 算法思想

1.1.1 首先将第一个记录和第二个记录进行比较，若为逆序则交换交换两个记录。然后比较第二个记录和第三个记录。以此类推。以上过程称为第一趟排序，其结果使最大的记录被安置到最后一个位置。

1.1.2 然后进行第二趟排序，其结果使次大的记录被安置到第n-1个位置

1.1.3 重复上述操作，直至排序完成

1.2 算法图解

 

 

1.3 代码与结果

public class BubbleSort {
    public static void main(String[] args) {
        int a[]={49,38,65,97,76,13,27,49};
        Bsort(a);
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ");
        }
    }
    public static void Bsort(int a[])
    {
        for(int i=0;i<a.length;i++)
        {
            for(int j=1;j<a.length-i;j++)
            {
                if(a[j-1]>a[j])
                {
                    swap(a,j-1,j);
                }
            }
        }
    }
    public static void swap(int a[],int i,int j)
    {
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

13 27 38 49 49 65 76 97 

1.4 总结

1.4.1 平均时间复杂度O(n2)，空间复杂度O(1);

1.4.2 是稳定排序

 

2.快速排序

2.1 算法思想

2.1.1 选择待排序表中的第一个记录作为枢轴，并记录此枢轴的值temp，并附设两个指针low，high分别指向表的上界和下界

2.1.2 从表的最右侧依次向左搜索，找到第一个关键字小于temp的记录，将其移到low处

2.1.3 从表的最左侧依次向右搜索，找到第一个关键字大于temp的记录，将其移到high处

2.1.4 重复步骤2和3，直至low与high相等。此时low或high的位置即为枢轴在此趟排序中的最终位置，原表被分为两个子表。

2.2 算法图解

 

2.3 代码与结果

public class QuickSort {

    public static void main(String[] args) {
        int a[]={49,38,65,97,76,13,27,49};
        Qsort(a,0,a.length-1);
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]+" ");
        }
    }

    public static void Qsort(int a[],int low,int high)
    {
        if(low<high)
        {
            int posLoc = partition(a,low,high);
            Qsort(a,low,posLoc-1);
            Qsort(a,posLoc+1,high);
        }
    }

    public static int partition(int a[],int low,int high)
    {
        int temp=a[low];
        while(low<high)
        {
            while(low<high&&a[high]>temp) high--;
            a[low]=a[high];
            while (low<high&&a[low]<temp) low++;
            a[high]=a[low];
        }
        a[low]=temp;
        return  low;
    }

}

13 27 38 49 49 65 76 97 

2.4 总结

2.4.1 平均时间复杂度O(nlogn)

2.4.2 最大递归调用次数与递归树的深度一致，最好的空间复杂度为(logn)，最坏的空间复杂度为O(n)

2.4.3 是不稳定排序，适合初始记录无序，n较大的情况