笔试题资源整理(3)

二:几种常用的排序方法整理

1),冒泡排序和快速排序

 1 void BubbleSort(int *a,int size)//冒泡排序,时间复杂度O(n^2),空间复杂度为1,稳定
 2 {
 3     for(int i=0;i<size-1;i++)
 4         for(int j=size-1;j>i;j--)
 5         {
 6           if(a[j]<a[j-1])
 7           {
 8              Swap(a[j],a[j-1]);
 9           }
10         }
补充一个更好的:
bool flag = true;
for (int i = 1; i < length && flag; i++)
{
flag = false;
for (int j = 0; j < length - i; j++)
{
if (array[j] > array[j + 1]) // Ascending,升序,小数上浮,大数下沉
{
flag = true;

temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
} // 每一轮比较后,如果flag仍旧为false,则表明元素集合已全部排好序,可以提前结束整个排序过程
}
11 } 12 13 int Partition(int *a,int low,int high) 14 { 15 int temp=a[low]; 16 while(low<high) 17 { 18 while(low<high&&a[high]>temp) 19 high--; 20 a[low]=a[high];//如果不满足上面条件,即该数小于temp,那么就将它移到前面 21 while(low<high&&a[low]<temp) 22 low++; 23 a[high]=a[low];//如果大于temp,就将它移到后面 24 } 25 a[low]=temp;//此标记找到正确位置,跳出上述的while循环是low与high相等时 26 return low; 27 } 28 void Qsort(int *a,int low,int high) //快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n),最坏O(n ^2)。 29 { 30 int key; 31 if(low<high) 32 { 33 key=Partition(a,low,high); 34 Qsort(a,low,key-1);//递归调用 35 Qsort(a,key+1,high); 36 } 37 38 } 39 void QuickSort(int *a,int length)//快速排序,在冒泡排序的基础上改进。 40 { 41 //int length=sizeof(a)/4; 42 //printf("长度为:%d",length);//这是什么节奏,在这里面算长度会出错???居然是13? 43 Qsort(a,0,length-1); 44 }

2),插入排序和希尔排序

 

 1 void InsertSort(int *a,int size)//插入排序,时间复杂度O(n^2),空间复杂度为1,稳定
 2 {
 3     int temp,j;
 4     for(int i=1;i<size;i++)
 5         if(a[i]<a[i-1])
 6         {
 7             temp=a[i];
 8              j=i;
 9             do{
10                 a[j]=a[j-1];
11                 j--;
12             }while(j>0&&a[j-1]>temp);
13           a[j]=temp;//找到可以插入的位置
14         }
15         
16 }
17 
18 void SellSort(int *a,int length)//希尔排序,时间复杂度O(n^2),空间复杂度为1,不稳定(是插入排序的改进)
19 {
20     int step,j,k,temp;//step为增量
21     for(step=length/2;step>0;step/=2)
22     {
23         for(j=step;j<length;j++)
24         {
25             if(a[j]<a[j-step])
26             {
27               Swap(a[j],a[j-step]);
28             }
29         }
30     }    
31 }

 

3),选择排序和堆排序

 

 1 void SelectionSort(int *a,int size)//选择排序,时间复杂度O(n^2),空间复杂度为1,不稳定,对所有序列都是稳定的才算稳定排序。
 2 //举个例子,序列5 8 5 2 9,从小到大排序,我们知道第一遍选择第1个元素5会和2交换,
 3 //那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法。
 4 {
 5     int min;
 6     for(int i=0;i<size-1;i++)
 7     {
 8         min=i;
 9         for(int j=i+1;j<size;j++)
10         {
11             if(a[min]>a[j])
12             {
13                 min=j;
14                 Swap(a[i],a[min]);
15             }
16 
17         }
18 
19     }
20 
21 }
22 
23 
24 void Heapify(int *arr, int low, int high)//
25 {
26     int large;
27     int temp = arr[low];
28     large = 2 * low + 1;
29     while(large <= high)
30     {
31         if(large<high && arr[large]<arr[large+1])
32             large = large + 1;
33         if(temp > arr[large])
34             break;
35         else
36         {
37             arr[low] = arr[large];
38             low = large;
39             large = 2 * low + 1;
40         }
41     }
42     arr[low] = temp;
43 }
44 void HeapSort(int *a,int length)//堆排序,时间复杂度为O(nlogn),空间复杂度1,不稳定
45 {
46     int i;
47     for(i=length/2-1;i>=0;i--)
48     Heapify(a,i,length-1);//先建成大顶堆
49 
50     for(i=length-1;i>=0;i--)
51     {
52       Swap(a[0],a[i]);
53       Heapify(a,0,i-1);
54     }
55 }

 

4),归并排序和计数排序

 

 1 void Merge(int *a,int *b,int start,int mid,int end)//归并排序,时间复杂度为O(Nlogn),空间复杂度为O(n),稳定
 2 {
 3   int j,k;
 4   for(j=mid+1,k=start;(start<=mid)&&(j<=end);k++)
 5   {
 6       if(a[start]<=a[j])
 7           b[k]=a[start++];
 8       else
 9           b[k]=a[j++];
10   }
11   if(start<=mid)
12   {
13       for(;start<=mid;k++)
14           b[k]=a[start++];
15   }
16   if(j<=end)
17   {
18       for(;j<=end;k++)
19           b[k]=a[j++];
20   }
21   for(int i=0;i<k;i++)
22           a[i]=b[i];
23    
24 }
25 void MSort(int *a,int *b,int start,int end)
26 {
27     int mid;
28     if(start!=end)
29     {
30         mid=(start+end)/2;
31         MSort(a,b,start,mid);
32         MSort(a,b,mid+1,end);
33         Merge(a,b,start,mid,end);
34     }
35     else;
36 }
37 
38 
39 void CountSort(int *a,int size)//这个排序的方法总感觉有点牵强。。。
40 {
41     int temp[10]={0},j=0;
42     for(int i=0;i<size;i++)
43         temp[a[i]]++; //假如a的值是3,2,1,6,5,7,8,9,0,4,这就意味着temp下标为他们时,值都是1
44     for(i=0;i<10;i++)
45     {
46         while(0 != temp[i])
47         {
48             a[j] = i;
49             temp[i]--;
50             j++;
51         }
52     }
53 }

 

运行代码:

  1 #include<stdio.h>
  2 #include<string.h>
  3 void Swap(int &a,int &b)
  4 {
  5     int temp=a;
  6     a=b;
  7     b=temp;
  8 }
  9 void BubbleSort(int *a,int size)//冒泡排序,时间复杂度O(n^2),空间复杂度为1,稳定
 10 {
 11     for(int i=0;i<size-1;i++)
 12         for(int j=size-1;j>i;j--)
 13         {
 14           if(a[j]<a[j-1])
 15           {
 16              Swap(a[j],a[j-1]);
 17           }
 18         }
 19 }
 20 void SelectionSort(int *a,int size)//选择排序,时间复杂度O(n^2),空间复杂度为1,不稳定,对所有序列都是稳定的才算稳定排序。
 21 //举个例子,序列5 8 5 2 9,从小到大排序,我们知道第一遍选择第1个元素5会和2交换,
 22 //那么原序列中2个5的相对前后顺序就被破坏了,所以选择排序不是一个稳定的排序算法。
 23 {
 24     int min;
 25     for(int i=0;i<size-1;i++)
 26     {
 27         min=i;
 28         for(int j=i+1;j<size;j++)
 29         {
 30             if(a[min]>a[j])
 31             {
 32                 min=j;
 33                 Swap(a[i],a[min]);
 34             }
 35 
 36         }
 37 
 38     }
 39 
 40 }
 41 void InsertSort(int *a,int size)//插入排序,时间复杂度O(n^2),空间复杂度为1,稳定
 42 {
 43     int temp,j;
 44     for(int i=1;i<size;i++)
 45         if(a[i]<a[i-1])
 46         {
 47             temp=a[i];
 48              j=i;
 49             do{
 50                 a[j]=a[j-1];
 51                 j--;
 52             }while(j>0&&a[j-1]>temp);
 53           a[j]=temp;//找到可以插入的位置
 54         }
 55         
 56 }
 57 
 58 int  Partition(int *a,int low,int high)
 59 {
 60    int temp=a[low];
 61    while(low<high)
 62    {
 63        while(low<high&&a[high]>temp) 
 64            high--;
 65        a[low]=a[high];//如果不满足上面条件,即该数小于temp,那么就将它移到前面
 66        while(low<high&&a[low]<temp)
 67            low++;
 68        a[high]=a[low];//如果大于temp,就将它移到后面
 69    }
 70    a[low]=temp;//此标记找到正确位置,跳出上述的while循环是low与high相等时
 71    return low;
 72 }
 73 void Qsort(int *a,int low,int high) //快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n),最坏O(n ^2)。
 74 {
 75     int key;
 76     if(low<high)
 77     {
 78       key=Partition(a,low,high);
 79       Qsort(a,low,key-1);//递归调用
 80       Qsort(a,key+1,high);
 81     }
 82 
 83 }
 84 void QuickSort(int *a,int length)//快速排序,时间复杂度O(nlogn),空间复杂度O(logn),不稳定,在冒泡排序的基础上改进
 85 {
 86  //int length=sizeof(a)/4;
 87  //printf("长度为:%d",length);//这是什么节奏,在这里面算长度会出错???居然是13?
 88  Qsort(a,0,length-1);
 89 }
 90 
 91 void CountSort(int *a,int size)//这个排序的方法总感觉有点牵强。。。
 92 {
 93     int temp[10]={0},j=0;
 94     for(int i=0;i<size;i++)
 95         temp[a[i]]++; //假如a的值是3,2,1,6,5,7,8,9,0,4,这就意味着temp下标为他们时,值都是1
 96     for(i=0;i<10;i++)
 97     {
 98         while(0 != temp[i])
 99         {
100             a[j] = i;
101             temp[i]--;
102             j++;
103         }
104     }
105 }
106 
107 void Merge(int *a,int *b,int start,int mid,int end)//归并排序,时间复杂度为O(Nlogn),空间复杂度为O(n),稳定
108 {
109   int j,k;
110   for(j=mid+1,k=start;(start<=mid)&&(j<=end);k++)
111   {
112       if(a[start]<=a[j])
113           b[k]=a[start++];
114       else
115           b[k]=a[j++];
116   }
117   if(start<=mid)
118   {
119       for(;start<=mid;k++)
120           b[k]=a[start++];
121   }
122   if(j<=end)
123   {
124       for(;j<=end;k++)
125           b[k]=a[j++];
126   }
127   for(int i=0;i<k;i++)
128           a[i]=b[i];
129    
130 }
131 void MSort(int *a,int *b,int start,int end)
132 {
133     int mid;
134     if(start!=end)
135     {
136         mid=(start+end)/2;
137         MSort(a,b,start,mid);
138         MSort(a,b,mid+1,end);
139         Merge(a,b,start,mid,end);
140     }
141     else;
142 }
143 
144 void Heapify(int *arr, int low, int high)//
145 {
146     int large;
147     int temp = arr[low];
148     large = 2 * low + 1;
149     while(large <= high)
150     {
151         if(large<high && arr[large]<arr[large+1])
152             large = large + 1;
153         if(temp > arr[large])
154             break;
155         else
156         {
157             arr[low] = arr[large];
158             low = large;
159             large = 2 * low + 1;
160         }
161     }
162     arr[low] = temp;
163 }
164 void HeapSort(int *a,int length)//堆排序,时间复杂度为O(nlogn),空间复杂度1,不稳定
165 {
166     int i;
167     for(i=length/2-1;i>=0;i--)
168     Heapify(a,i,length-1);//先建成大顶堆
169 
170     for(i=length-1;i>=0;i--)
171     {
172       Swap(a[0],a[i]);
173       Heapify(a,0,i-1);
174     }
175 }
176 
177 void SellSort(int *a,int length)//希尔排序,时间复杂度O(n^2),空间复杂度为1,不稳定(是插入排序的改进)
178 {
179     int step,j,k,temp;//step为增量
180     for(step=length/2;step>0;step/=2)
181     {
182         for(j=step;j<length;j++)
183         {
184             if(a[j]<a[j-step])
185             {
186               Swap(a[j],a[j-step]);
187             }
188         }
189     }    
190 }
191 
192 int main()
193 {
194     int a[10]={3,2,1,6,5,7,1,9,0,4},b[10];
195     int length=sizeof(a)/4;//一个整型占四个字节
196     // int temp;
197     //BubbleSort(a,length);//冒泡
198     //SelectionSort(a,length);//选择
199     //InsertSort(a,length);//插入
200     //QuickSort(a,length);//快速
201     //CountSort(a,length);//计数
202     //MSort(a,b,0,length-1);//归并
203     //HeapSort(a,length);//堆排序
204      SellSort(a,length);//希尔排序
205     for(int j=0;j<10;j++)
206         printf("%d\n",a[j]);
207     return 0;
208 }
View Code

 

 

 

 

 

posted @ 2013-09-27 22:44  wj704  阅读(211)  评论(0编辑  收藏  举报