2.交换排序

    交换排序                  是一类基于交换的排序，系统地交换反序的记录的偶对，直到不再有这样的偶对为止。其中最基本的是冒泡排序(Bubble Sort)。

01

02

 

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 
  5 void swap(int *a, int *b) /*交换*/
  6 {
  7     int tmp;
  8     tmp = *a;
  9     *a = *b;
 10     *b = tmp;
 11 }
 12 
 13 void print_array(int *a,int len)/*打印一个数组*/
 14 {
 15     int i;
 16 
 17     for(i = 0;i < len;i++)
 18     {
 19         printf("%5d",a[i]);
 20     }
 21     printf("\n");
 22 
 23 }
 24 
 25 void bubble_sort(int *v, int len)
 26 {
 27     int i;
 28     int j;
 29 
 30     int is_change = 1;/*用来提高效率*/
 31 
 32     for (i = 0; is_change && i < len; i++)
 33     {
 34         is_change = 0;
 35 
 36         for (j = 0; j < len - 1 - i; j++)
 37         {
 38             if (v[j] > v[j + 1])
 39             {
 40                 swap(v + j, v + j + 1);
 41                 is_change = 1;
 42             }
 43         }
 44          print_array(v, len);
 45     }
 46 
 47 }
 48 int main()
 49 {
 50     int a[] = {100,5,4,9,6,7,3,-4,50,1};
 51     int len = sizeof(a) / sizeof(a[0]);
 52     print_array(a,len);
 53     printf("\n");
 54     bubble_sort(a,len);
 55 
 56     return 0;
 57 
 58 }

输出结果：

 

03

 

04

 

 用递归方法实现快速排序：

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 
  5 void swap(int *a, int *b) /*交换*/
  6 {
  7     int tmp;
  8     tmp = *a;
  9     *a = *b;
 10     *b = tmp;
 11 }
 12 
 13 void print_array(int *a,int len)/*打印一个数组*/
 14 {
 15     int i;
 16 
 17     for(i = 0;i < len;i++)
 18     {
 19         printf("%5d",a[i]);
 20     }
 21     printf("\n");
 22 
 23 }
 24 
 25 void quick_sort(int *v,int left,int right)/*用递归的方法实现排序*/
 26 {
 27     int key;
 28     int i;
 29     int j;
 30 
 31     if(left > right)
 32     {
 33         return;
 34     }
 35 
 36     key = v[left];/*左边的数为基准数*/
 37     i = left;
 38     j = right;
 39 
 40     while(i < j)
 41     {
 42         while((i < j) && (v[j] >= key))//朝左走
 43         {
 44             j--;
 45         }
 46 
 47         while((i < j) && (v[i] <= key))//朝右走
 48         {
 49             i++;
 50         }
 51 
 52         if(i < j)
 53         {
 54             swap(v + i,v +j);
 55         }
 56     }
 57 
 58     swap(v + i,v + left);
 59 
 60     quick_sort(v,left,i - 1); /*对左边进行快速排序*/
 61     quick_sort(v,i + 1,right);/*对右边进行快速排序*/
 62 
 63 }
 64 
 65 int main()
 66 {
 67     int a[] = {100,5,4,9,6,7,3,-4,50,1};
 68     int len = sizeof(a) / sizeof(a[0]);
 69     print_array(a,len);
 70     printf("\n");
 71     quick_sort(a,0,len - 1);
 72 
 73     print_array(a,len);
 74 
 75     return 0;
 76 
 77 }

 还有很多方法:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 
  5 void swap(int *a, int *b) /*交换*/
  6 {
  7     int tmp;
  8     tmp = *a;
  9     *a = *b;
 10     *b = tmp;
 11 }
 12 
 13 void print_array(int *a,int len)/*打印一个数组*/
 14 {
 15     int i;
 16 
 17     for(i = 0;i < len;i++)
 18     {
 19         printf("%5d",a[i]);
 20     }
 21     printf("\n");
 22 
 23 }
 24 
 25 int partition_right(int v[], int left, int right)/*每次以最右值作为标准*/
 26 {
 27     int i = left;
 28     int j = right;
 29     int key = v[right];
 30 
 31     while (i < j)
 32     {
 33         while ((i < j) && (v[i] <= key))
 34         {
 35             i++;
 36         }
 37 
 38         while ((i < j) && (v[j] >= key) )
 39         {
 40             j--;
 41         }
 42 
 43         if (i < j)
 44         {
 45             swap(v + i, v + j);
 46         }
 47     }
 48 
 49     swap(v + i, v + right);
 50 
 51     return i;
 52 }
 53 
 54 void quick_sort(int *v, int left, int right)
 55 {
 56     int i;
 57 
 58     if (left > right)
 59     {
 60         return;
 61     }
 62 
 63     i = partition_right(v, left, right);
 64 
 65     quick_sort(v, left, i - 1);
 66     quick_sort(v, i + 1, right);
 67 }
 68 
 69 int main()
 70 {
 71     int a[] = {100,5,4,9,6,7,3,-4,50,1};
 72     int len = sizeof(a) / sizeof(a[0]);
 73     print_array(a,len);
 74     printf("\n");
 75     quick_sort(a,0,len - 1);
 76 
 77     print_array(a,len);
 78 
 79     return 0;
 80 
 81 }

用迭代也可以实现：

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 
  5 #define push2(A, B)  push(B); push(A);
  6 
  7 int stack[100];
  8 int top = 0;
  9 
 10 void init_stack()/*初始化*/
 11 {
 12     top = 0;
 13 }
 14 
 15 void push(int item)
 16 {
 17     stack[top++] = item;
 18 }
 19 
 20 int pop(void)
 21 {
 22     return stack[--top];
 23 }
 24 
 25 int is_empty(void)/*判空*/
 26 {
 27     return top == 0;
 28 }
 29 
 30 void swap(int *a, int *b) /*交换*/
 31 {
 32     int tmp;
 33     tmp = *a;
 34     *a = *b;
 35     *b = tmp;
 36 }
 37 
 38 void print_array(int *a,int len)/*打印一个数组*/
 39 {
 40     int i;
 41 
 42     for(i = 0;i < len;i++)
 43     {
 44         printf("%5d",a[i]);
 45     }
 46     printf("\n");
 47 
 48 }
 49 
 50 int partition_right(int v[], int left, int right)/*每次以最右值作为标准*/
 51 {
 52     int i = left;
 53     int j = right;
 54     int key = v[right];
 55 
 56     while (i < j)
 57     {
 58         while ((i < j) && (v[i] <= key))
 59         {
 60             i++;
 61         }
 62 
 63         while ((i < j) && (v[j] >= key) )
 64         {
 65             j--;
 66         }
 67 
 68         if (i < j)
 69         {
 70             swap(v + i, v + j);
 71         }
 72     }
 73 
 74     swap(v + i, v + right);
 75 
 76     return i;
 77 }
 78 
 79 void quick_sort(int *v, int left, int right)/*用迭代的方法实现快速排序*/
 80 {
 81     int i;
 82     init_stack();
 83     push2(left, right);
 84 
 85     while (!is_empty())
 86     {
 87         left = pop();
 88         right = pop();
 89 
 90         if (right <= left)
 91         {
 92             continue;
 93         }
 94 
 95         i = partition_right(v, left, right);
 96 
 97         if (i - left > right - i)
 98         {
 99             push2(left, i - 1);
100             push2(i + 1, right);
101         }
102         else
103         {
104             push2(i + 1, right);
105             push2(left, i - 1);
106         }
107     }
108 }
109 
110 int main()
111 {
112     int a[] = {100,5,4,9,6,7,3,-4,50,1};
113     int len = sizeof(a) / sizeof(a[0]);
114     print_array(a,len);
115     printf("\n");
116     quick_sort(a,0,len - 1);
117 
118     print_array(a,len);
119 
120     return 0;
121 
122 }

05

06

07