插入排序：
插入排序的核心思想是为第i个元素找到合适的位置。
在升序排序中，第i+1个元素会逐个和前i个元素相比较，若其小于第j（k<=i）个元素，则将第j个元素后移成为第j+1个元素，其继续喝第j-1个元素相比；若其小于第j个元素，则将之置于j+1个元素的位置。
这种排序比较适用于待排元素个数较少的情况，也比较适用于待排元素已经基本有序的情况。
#ifndef insertion_sort_h
#define insertion_sort_h
#include "printf_array.h"
void insertion_sort(int *a, int n);
#endif#include "insertion_sort.h"
void insertion_sort(int *a, int n)
{
int j = 0;
int key = 0;
for(int i = 1; i < n; i++)
{
key = a[i];
j = i - 1;
while(j >= 0 && a[j] > key)
{
a[j + 1] = a[j];
j--;
}
a[j + 1] = key;
}
}
归并排序：
这是一种典型的使用分而治之思想的排序算法。他将待排元素一分为二，分别对这两部分进行排序，然后再将已排序的两部分进行合并，这样合并后的元素就是有序的了；而一分为二的每部分元素都会按照这种思想执行下去，直到被分的元素只有一个为止。
在合并的过程中要为待合并的两部分元素分配空间，这里实际分配的空间比所需要的空间大了一个，是用了编程上的技巧来简化合并过程。
这种排序方法的执行时间是nlg（n），但是需要额外的空间代价，这种排序方法比较适合于待排元素较多，且对程序运行空间较为充足的情况。
#ifndef merge_sort_h
#define merge_sort_h
#include <stdlib.h>
#include "printf_array.h"
void real_merge(int *a, int p, int r);
void merge(int *a, int p, int q, int r);
void merge_sort(int *a, int n);
#endif#include "merge_sort.h"
void merge_sort(int *a, int n)
{
real_merge(a, 0, n - 1);
}
void real_merge(int *a, int p, int r)
{
int q = 0 ;
if(p < r)
{
q = (p + r) / 2;
real_merge(a, p, q);
real_merge(a, q + 1, r);
merge(a, p, q, r);
}
}</pre><pre code_snippet_id="447850" snippet_file_name="blog_20140811_10_706962" name="code" class="cpp">void merge(int *a, int p, int q, int r)
{
int n1 = q - p + 1 +1;
int n2 = r - q + 1;
int *L = (int *)malloc(n1* sizeof(int));
int *R = (int *)malloc(n2* sizeof(int));
for(int i = 0; i < n1 - 1; i++)
L[i] = a[p + i];
for(int i = 0; i < n2 - 1; i++)
R[i] = a[q + i + 1];
L[n1 - 1] = 65536;
R[n2 - 1] = 65536;
for(int i = 0, j = 0, k = p; k <= r; k++)
{
if(L[i] <= R[j])
{
a[k] = L[i];
i++;
}else{
a[k] = R[j];
j++;
}
}
free(L);
free(R);
}
选择排序：
这种排序的核心思想是为第i个位置找到合适的元素，和插入排序的思想相反。
第i个元素会逐个和后n-i个元素相比较，找出本次比较中最小的元素，将第i个元素和其交换位置。
适用于待排元素个数较少的情况。
#ifndef selection_sort_h
#define selection_sort_h
#include "myswap.h"
#include "printf_array.h"
void selection_sort(int *a,int n);
#endif#include "selection_sort.h"
void selection_sort(int *a,int n)
{
int i=0,j=0;
int temp=0;
int k=0;
for(i=0;i<n-1;i++)
{
temp=a[i];
for(j=i+1;j<n;j++)
{
if(temp>a[j])
{
k=j;
temp=a[j];
}
}
if(temp!=a[i])
swap(a[i],a[k]);
}
}
堆排序：
最大堆的性质：节点i大于等于其左右两个子节点。
最大堆化是维护了最大堆的性质，它假设节点i的左右两个子堆都满足了最大堆的性质，对节点i的处理过程。
建立最大堆是从第n/2个元素到第一个元素逐个调用最大堆化的过程，结束后将建立一个最大堆。
堆排序首先调用建立最大堆，建立一个最大堆，然后将堆顶元素和堆中最后一个元素置换，再对堆顶元素调用最大堆化，直到堆的长度为0.
最大堆适用于找出堆中最大的m个元素问题。
其实若m的个数小于lgn，则用直接查找的方法会更快。
#ifndef HEAP_SORT_H
#define HEAP_SORT_H
void max_heapify(int *a, int i, int heap_length);
void build_max_heap(int *a, int n);
void heap_sort(int *a, int n);
#endif#include "heap_sort.h"
#include "myswap.h"
void heap_sort(int *a, int n)
{
int heap_length = n;
build_max_heap(a, n);
for(int i = n-1; i > 0; i--){
swap(a[0], a[i]);
heap_length--;
max_heapify(a, 0, heap_length);
}
}
void build_max_heap(int *a, int n)
{
for(int i = (n - 1) / 2; i >= 0; i--){
max_heapify(a, i, n);
}
}
void max_heapify(int *a, int i, int heap_length)
{
int max_index = i;
int left_child_index = 2 * i + 1, right_child_index = 2 *(i + 1);
if(left_child_index < heap_length && a[left_child_index] > a[i] )
max_index = left_child_index;
if(right_child_index < heap_length && a[right_child_index] > a[max_index])
max_index = right_child_index;
if(max_index != i){
swap(a[i], a[max_index]);
max_heapify(a, max_index, heap_length);
}
}
快速排序：
快速排序的核心思想是找到指定元素的最终位置，并将小于该元素的元素置于其左边，大于该元素的元素置于其右边；两边的元素也都会按照这种思想执行下去，直到只剩下一个元素。
放置指定元素两边的元素的过程需要将所有元素分为三个区域：比指定元素小的，比指定元素大的，待划分的。
这种排序方法适用于待排元素较多，且严重无序的情况。
这种排序方法稍加修改便可作为快速找到第i小元素的方法。
#ifndef QUICK_SORT_H
#define QUICK_SORT_H
void quick_sort(int *a, int n);
void real_quick_sort(int *a, int start_index, int end_index);
int randomized_partition(int *a, int start_index, int end_index);
int partition(int *a, int start_index, int end_index);
int ramdom(int start_index, int end_index);
#endif#include "quick_sort.h"
#include "myswap.h"
#include <stdlib.h>
#include <time.h>
void quick_sort(int *a, int n)
{
real_quick_sort(a, 0, n-1);
}
void real_quick_sort(int *a, int start_index, int end_index)
{
int pivot = 0;
if(start_index < end_index){
pivot = randomized_partition(a, start_index, end_index);
real_quick_sort(a, start_index, pivot-1);
real_quick_sort(a, pivot+1, end_index);
}
}
int randomized_partition(int *a, int start_index, int end_index)
{
int pivot = 0;
pivot = ramdom(start_index, end_index);
swap(a[pivot], a[end_index]);
return partition(a, start_index, end_index);
}
int partition(int *a, int start_index, int end_index)
{
int key = a[end_index];
int i = start_index - 1;
for(int j = i + 1; j < end_index; j++){
if(a[j] <= key){
i++;
swap(a[i], a[j]);
}
}
swap(a[i+1], a[end_index]);
return i + 1;
}
int ramdom(int start_index, int end_index)
{
srand(time(0));
return rand() % (end_index - start_index) + start_index;
}
计数排序：
计数排序的核心思想是找到每个元素之前的元素个数，再将它们一一列出。
1.要找出待排元素的最大元素，并创建一个比其大一的空间。
2.找出每个元素的个数。
3.找出小于等于元素x的个数。
4.依次列出元素
#ifndef COUNTING_SORT_H
#define COUNTING_SORT_H
void counting_sort(int *a, int n);
int find_max_num(int *a, int n);
#endif#include "counting_sort.h"
#include <stdlib.h>
void counting_sort(int *a, int n)
{
int *b, *c;
int length = find_max_num(a, n) + 1;
b = (int *)malloc(n * sizeof(int));
c = (int *)malloc(length * sizeof(int));
for(int i = 0; i < length; i++ ){
c[i] = 0;
}
for(int i = 0; i < n; i++){
c[a[i]]++;
}
for(int i = 1; i < length; i++){
c[i] += c[i - 1];
}
while(c[0] > 0){
b[c[0] - 1] = 0;
c[0]--;
}
for(int i = 1; i < length; i++){
while((c[i] - c[i - 1]) > 0){
b[c[i] - 1] = i;
c[i]--;
}
}
for(int i = 0; i < n; i++){
a[i] = b[i];
}
free(b);
free(c);
}
int find_max_num(int *a, int n)
{
int max_num = a[0];
for(int i = 1; i < n; i++){
if(max_num < a[i]){
max_num = a[i];
}
}
return max_num;
}
#ifndef sort_verification_h
#define sort_verification_h
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "printf_array.h"
enum {
length=8
};
int do_sort_verifition(int *a,int length,int order);
void sort_verification(char *str, void (*sort)(int *a,int n) );
#endif#include "sort_verification.h"
void sort_verification(char *str, void (*sort)(int *a,int n) )
{
printf("verifing %s :",str);
int flag=0;
srand((unsigned int)time(NULL));
for(int i=0;i<100;i++)
{
int a[length]={0};
for(int i=0;i<length;i++)
a[i]=rand()%100;
//printf_array("before", a, length);
sort(a,length);
//printf_array("after", a, length);
flag=do_sort_verifition(a,length,1);
if(flag==0)
{
printf("you are fail in %s\n",str);
break;
}
}
if(flag)
printf("you are sucess in %s\n",str);
}
// order equals 1 indicate ascending should be verified
int do_sort_verifition(int *a,int length,int order)
{
if(order)
{
for(int i=0;i<length-1;i++)
if(a[i]>a[i+1])
return 0;
return 1;
}else{
for(int i=0;i<length-1;i++)
if(a[i]<a[i+1])
return 0;
return 1;
}
}#ifndef myswap_h
#define myswap_h
void swap(int &a,int &b);
#endif#include "myswap.h"
void swap(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}#ifndef printf_array_h
#define printf_array_h
#include <stdio.h>
void printf_array(char *str, int *a,int length);
#endif#include "printf_array.h"
void printf_array(char *str, int *a,int length)
{
printf("\n%s:", str);
for(int i = 0;i < length;i++)
{
printf("\t%d",a[i]);
}
printf("\n");
}
#include "sort_verification.h"
#include "selection_sort.h"
#include "insertion_sort.h"
#include "merge_sort.h"
#include "heap_sort.h"
#include "quick_sort.h"
#include "counting_sort.h"
int main(int argc, char* argv[])
{
sort_verification("selection_sort", selection_sort);
sort_verification("insertion_sort", insertion_sort);
sort_verification("merge_sort", merge_sort);
sort_verification("heap_sort", heap_sort);
sort_verification("quick_sort", quick_sort);
sort_verification("counting_sort", counting_sort);
return 0;
}
143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
