交换类排序

1. 交换两个数

1.1 临时变量

swap(int *pa, int *pb)
{
int tmp = 0;

tmp = *pa;
*pa = *pb;
*pb = tmp;
}

1.2 赋值运算————大数容易溢出

swap(int *pa, int *pb)
{
*pa = *pa + *pb;
*pb = *pa - *pb;
*pa = *pa - *pb;
}

1.3 位运算

swap(int *pa, int *pb)
{
*pa = *pa ^ *pb;
*pb = *pa ^ *pb;
*pa = *pa ^ *pb;
}

swap(int *pa, int *pb)
{
*pa ^= *pb;
*pb ^= *pa;
*pa ^= *pb;
}

1.4 注释:

左值: 写权限
右值: 只读权限

2. 冒泡排序

1. What:

• 在无序区的元素中，
• 比较相邻元素的关键字对应的值，
• 交换那些不满足次序要求的偶对，直到全部满足为止。

2.How:

static void BubbleSort (int A[], int n)
{
int i = 0;
int j = 0;
int exchange = 0;

for (i = 0; i < n-1; ++i) /* n 个数最多需要 n-1 趟排序才能满足次序的要求 /
{
exchange = 0; / 经过一趟排序后, 检查相邻的元素是否发生过交换 /
for (j = n-1; j > i; --j) / 从后往前两两比较相邻的元素, 每趟比较后使得一个元素归位。*/
{
if (A[j-1] > A[j])
{
swap(&A[j-1], &A[j]);
exchange = 1;
}
}

if (0 == exchange)
{
return ;
}
}
}

3.Why:

• 每一趟排序使得一个元素归位，有序区的元素一定小于(顺序)[大于(逆序)]无序区的元素,因此是全局有序的。
• A[j-1] > A[j] 保证了冒泡排序算法的稳定性。
• j > i 保证每次的比较都在无序区。

3. 快速排序

1. What:

• 是冒泡排序的改进
• 每次使得一个元素归位
• 结束条件每个子区间只有一个元素

2.How:

/* 快速排序 /
static void quickSort(int a[], int low, int high) / a[low, high] 是无序区中的元素 */
{

int i = 0;
int j = 0;
int temp = 0;

i = low;
j = high;
temp = a[i]; /* 保存要归位的元素 */

if (low < high) /* 递归条件出口 /
{
while (i != j)
{
while (j>i && a[j] > temp)
{
--j;
}
a[i] = a[j];/ 逆序则交换 */

while(i<j && a[i] < temp)
{
++i;
}
a[j] = a[i]; /* 逆序则交换 */
}

a[i] = temp; /* 每趟排序使得一个元素归位 */

quickSort(a,low,i-1); /* 左区间进行递归排序 /
quickSort(a,i+1,high); / 有区间进行递归排序 */
}

return;
}

3.Why:

• 每一趟排序使得一个元素归位，但不是全局有序。
• low < high 是递归退出的条件
• 交换与基准元素期望达到的序列逆序的元素