排序算法——交换排序

目录

 

交换排序

1.1冒泡排序

1.1.1思路

1.1.2例子

1.1.3 复杂度和稳定性分析

1.1.4 java代码

1.2快速排序

1.2.1思路

1.2.2例子

​

1.2.3 复杂度和稳定性分析

1.2.4 java代码

---

交换排序

1.1冒泡排序

1.1.1思路

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

1.1.2例子

 

1.1.3 复杂度和稳定性分析

空间上看：

它只需要一个辅助空间temp ，因此其空间复杂度位O(1)。

时间上看：

1. 如果数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：

Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。

2. 如果数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为： O() 。

稳定性：

假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。

因此是稳定的。

1.1.4 java代码

public void bubbleSort(Integer[] arr, int n) {
        if (n <= 1) return;       //如果只有一个元素就不用排序了
 
        for (int i = 0; i < n; ++i) {
            // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {        //此处你可能会疑问的j<n-i-1，因为冒泡是把每轮循环中较大的数飘到后面，
                // 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少
                if (arr[j] > arr[j + 1]) {        //即这两个相邻的数是逆序的，交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (!flag) break;//没有数据交换，数组已经有序，退出排序
        }
  }

1.2快速排序

1.2.1思路

快速排序采用双向查找的策略，每一趟选择当前所有子序列中的一个关键字作为枢纽轴，将子序列中比枢纽轴小的前移，比枢纽轴大的后移，当本趟所有子序列都被枢轴按上述规则划分完毕后将会得到新的一组更短的子序列，他们将成为下趟划分的初始序列集。

1.2.2例子

设定基准值为数组第一个数据49

排序的全过程

1.2.3 复杂度和稳定性分析

空间上看：

地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；

     最优的情况下空间复杂度为：O(logn)  ；每一次都平分数组的情况

     最差的情况下空间复杂度为：O( n )      ；退化为冒泡排序的情况

时间上看：

最优的情况就是每一次取到的元素都刚好平分整个数组：

此时的时间复杂度公式则为：T[n] = 2T[n/2] + f(n)；T[n/2]，递归求得T[n] = 2^(logn) T[1] + nlogn  =  n T[1] + nlogn  =  n + nlogn  ；其中n为元素个数；因此最优时间复杂度为O( nlogn )

 最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序：

因此时间复杂度为 O()

稳定性：

假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。

因此是不稳定的。

1.2.4 java代码

/**
 * 快速排序
 * @param num	排序的数组
 * @param left	数组的前针
 * @param right 数组后针
 */
private static void QuickSort(int[] num, int left, int right) {
	//如果left等于right，即数组只有一个元素，直接返回
	if(left>=right) {
		return;
	}
	//设置最左边的元素为基准值
	int key=num[left];
	//数组中比key小的放在左边，比key大的放在右边，key值下标为i
	int i=left;
	int j=right;
	while(i<j){
		//j向左移，直到遇到比key小的值
		while(num[j]>=key && i<j){
			j--;
		}
		//i向右移，直到遇到比key大的值
		while(num[i]<=key && i<j){
			i++;
		}
		//i和j指向的元素交换
		if(i<j){
			int temp=num[i];
			num[i]=num[j];
			num[j]=temp;
		}
	}
	num[left]=num[i];
	num[i]=key;
	count++;
	QuickSort(num,left,i-1);
	QuickSort(num,i+1,right);
}