交换类排序

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 是递归退出的条件
• 交换与基准元素期望达到的序列逆序的元素