【数据结构】-内部排序(交换排序)

灰太狼 2022-11-25 11:51 193阅读 0赞

### 内部排序-交换排序 ###

*  写在前面
 *  1.头文件及类型定义
 *  2.函数声明
 *  3.基本操作
 *   *  3.1 冒泡排序
     *   *  3.1.1 交换
         *  3.1.2 冒泡主过程
     *  3.2 快速排序
     *   *  3.2.1 划分
         *  3.2.2 快排主过程
 *  4.main函数
 *  5.小结

# 写在前面 #

【说明】以下代码实现最终均为**递增序列**，即从小到大排序。

# 1.头文件及类型定义 #

#include<stdio.h>
    #define ElemType int

# 2.函数声明 #

/*函数声明*/
    void swap(int& a, int& b);							//1-1.交换
    void BubbleSort(ElemType A[], int n);				//1-2.冒泡排序
    int Partition(ElemType A[], int low, int high);		//2-1.划分
    void QuickSort(ElemType A[], int low, int high);	//2-2.快速排序

# 3.基本操作 #

## 3.1 冒泡排序 ##

### 3.1.1 交换 ###

//1-1.交换
    void swap(int& a, int& b) {
        	//涉及两个元素实际交换，要带引用
    	int temp = a;
    	a = b;
    	b = temp;
    }

### 3.1.2 冒泡主过程 ###

//1-2.冒泡排序
    void BubbleSort(ElemType A[], int n) {
        
    	for (int i = 0; i < n - 1; i++) {
        	//若每趟均要交换，则共n-1趟冒泡
    		bool flag = false;		//代表本趟冒泡是否发生交换的标志
    		for (int j = n - 1; j > i; j--)		//一趟冒泡过程
    			if (A[j - 1] > A[j]) {
        		//若为逆序
    				swap(A[j - 1], A[j]);	//交换
    				flag = true;	//更改标志位，本趟发生交换
    			}
    		if (flag == false)
    			return;		//本趟遍历没有发生交换，说明表已经有序，提前结束算法
    	}
    }

## 3.2 快速排序 ##

### 3.2.1 划分 ###

//2-1.划分
    int Partition(ElemType A[], int low, int high) {
        	//一趟划分
    	ElemType pivot = A[low];	//将表中第一个元素作为枢轴
    	while (low < high) {
        		//用low和high搜索枢轴的最终位置
    		while (low < high && A[high] >= pivot)
    			high--;
    		A[low] = A[high];		//比枢轴小的元素移动到左端
    		while (low < high && A[low] <= pivot)
    			low++;
    		A[high] = A[low];		//比枢轴大的元素移动到右端
    	}
    	A[low] = pivot;				//枢轴元素存放到最终位置
    	return low;					//返回存放枢轴的最终位置
    }

### 3.2.2 快排主过程 ###

//2-2.快速排序
    void QuickSort(ElemType A[], int low, int high) {
        
    	if (low < high) {
        		//递归跳出的条件
    		int pivotpos = Partition(A, low, high);		//划分
    		QuickSort(A, low, pivotpos - 1);			//依次对两个子表进行递归排序
    		QuickSort(A, pivotpos + 1, high);
    	}
    }

# 4.main函数 #

int main() {
        
    	//1.冒泡排序
    	ElemType A[] = {
         10,9,8,7,6,5,4,3,2,1 };
    	BubbleSort(A, 10);
    	for (int i = 0; i < 10; i++)
    		printf("%d\t", A[i]);
    	printf("\n");
    
    	//2.快速排序
    	ElemType B[] = {
         10,9,8,7,6,5,4,3,2,1 };
    	QuickSort(B, 0, 9);
    	for (int i = 0; i < 10; i++)
    		printf("%d\t", B[i]);
    		
    	return 0;
    }

# 5.小结 #

*一、交换排序的概念*

*  主要分两步：  
    **① 比较**：从头到尾比较，最小的放到队头(以递增为例)。  
    **② 交换**

*二、关于两种交换排序的性能分析*

1.  冒泡排序  
    **空间复杂度**：O(1)  
    **时间复杂度**：O(n2)  
    **稳定性**:稳定  
    **适用性**：适用于顺序存储和链式存储的线性表
2.  快速排序  
    **①空间复杂度=O(递归层数)**  
    \---->最好情况：O(log2n)  
    \---->最坏情况：O(n)  
    \---->平均情况：O(log2n)  
    **②时间复杂度=O(n\*递归层数)**  
    \---->最好情况：O(nlog2n)  
    \---->最坏情况：O(n2)  
    \---->平均情况：O(nlog2n)  
    **稳定性**:不稳定  
    **适用**：仅适用于顺序存储的线性表  
    **【注】：快速排序在所有内部排序算法中平均性能最优**

*三、其他说明*

1.  冒泡排序较为简单，**重点掌握快速排序，并且手写代码**。
2.  交换排序的重要特点  
    (1) 对**冒泡排序**来说，**每经过一趟冒泡则必有一个元素会放在其最终的位置上**。  
    (2) 对**快速排序**来说  
    **①经过一次划分，则会有一个元素会放在其最终的位置上**  
    **②经过一趟排序**，如果枢轴靠边，则第二趟排序会有一个元素会放在其最终的位置上；若枢轴不靠边，则第二趟会有两个元素确定其最终的位置。  
    **上述特点可作为判断是否进行了冒泡排序或快速排序以及进行了几趟的依据**