冒泡排序和快速排序算法

冒泡排序和快速排序算法

冒泡排序

原理：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现：

public static void bubbleSort(int arr[]) {
        for(int i =0 ; i<arr.length-1 ; i++) { 

            for(int j=0 ; j<arr.length-1-i ; j++) {  
 
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];     
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
               }
            }    
        }
    }

算法分析：

时间复杂度

最好情况下，时间复杂度为O(n)。

最坏情况下，时间复杂度为O(n²)。

平均时间复杂度：O(n²)。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

快速排序

原理：

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法

一趟速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；

5）重复第3、4步，直到i= =j。(3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j 这一过程一定正好是i+或j-完成的时候，此时令循环结束）

代码实现（两种分割算法）

//使用的partition划分算法
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 {
            //swap
            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);    
}    
 
public static void main(String[] args) {        
    int arr[] = new int[]{3,3,3,7,9,122344,4656,34,34,4656,5,6,7,8,9,343,57765,23,12321};        
    int len = arr.length-1;        
    arr=qsort(arr,0,len);        
    for (int i:arr) {            
        System.out.print(i+"\t");        
    }    
}

//快速排序split实现方法
public class T1 {
    public static void main(String args[])
    {
        int a[] = {5,7,1,6,4,8,3,2};
        quickSort(a, 0, a.length-1);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }

    //交换方法
    public static void swap(int a[], int i, int j)
    {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    //划分数组
    public static int split(int a[], int low, int high)
    {
        int i = low;    //i指向比较元素的期望位置
        int x = a[low];    //将该组的第一个元素作为比较元素
        //从第二个元素开始，若当前元素大于比较元素，将其跳过
        for(int j = low+1; j <= high; j++)
            //若找到了小于比较元素的元素，将其与前面较大的元素进行交换
            if(a[j] <= x)
            {
                i++;
                if(i != j)
                    swap(a, i, j);

            }
        swap(a, i, low);     //将比较元素交换到正确的位置上
        return i;    //返回比较元素的位置
    }

    public static void quickSort(int a[], int low, int high)
    {
        if(low < high)
        {
            int i = split(a, low, high);    //划分并获取比较元素的位置
            quickSort(a, low, i-1);     //对比较元素左边的数组进行排序
            quickSort(a, i+1, high);     //对比较元素右边的数字进行排序
        }
    }
}

性能分析

时间复杂度

最好情况下，时间复杂度度为O(nlog₂n)

最坏情况下，时间复杂度为O(n²)

平均时间复杂度：O(nlog₂n)，因此，该排序方法被认为是目前最好的一种内部排序方法。

空间复杂度：O(log₂n)

稳定性：快速排序不是一种稳定的排序算法