目录
1.直接插入排序算法
#include<stdio.h>
#define MAXNUM 100
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void insertSort(SortObject * pvector)
{ /* 按递增序进行直接插入排序 */
int i, j;
RecordNode temp;
RecordNode *data = pvector->record;
for( i = 1; i < pvector->n; i++ )
{ /* 依次插入记录R1, R2…Rn-1 */
temp = data[i];
for ( j = i-1; temp.key < data[j].key && j >= 0; j-- )
/* 由后向前找插入位置 将排序码大于ki的记录后移 */
data[j+1] = data[j];
if( j != i-1 ) data[j+1] = temp;
}
}
SortObject vector = {10,49, 38, 65, 97, 76, 13, 27, 49, 50, 101};
int main()
{
int i;
insertSort(&vector);
for(i = 0; i < vector.n; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}
2.二分法插入排序算法
#include<stdio.h>
#define MAXNUM 100
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void binSort(SortObject * pvector)
{ /* 按递增序进行二分法插入排序 */
int i, j, left, mid, right;
RecordNode temp;
RecordNode *data = pvector->record;
for( i = 1; i < pvector->n; i++ )
{
temp = data[i];
left = 0; right = i-1; /* 置已排序区间的下、上界初值 */
while (left <= right)
{
mid = (left + right)/2; /* mid指向已排序区间的中间位置 */
if (temp.key < data[mid].key)
right = mid-1; /* 插入元素应在左子区间 */
else left = mid+1; /* 插入元素应在右子区间 */
}
for (j = i-1; j >= left; j--)
data[j+1] = data[j]; /* 将排序码大于ki的记录后移 */
if (left != i) data[left] = temp;
}
}
SortObject vector={10, 49,38,65,97,76,13,27,49,50,101};
int main()
{
int i;
binSort(&vector);
for(i = 0; i < vector.n; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}3.表插入排序算法
#include<stdio.h>
struct Node; /* 单链表结点类型 */
typedef int KeyType;
typedef int DataType;
typedef struct Node ListNode;
struct Node
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
ListNode *next; /* 记录的指针字段 */
};
typedef ListNode * LinkList;
/* 对链表按递增序进行表插入排序，链表中第一个结点为表头结点。 */
void listSort(LinkList * plist)
{
ListNode *now, *pre, *p, *q, *head; head=*plist;
if (head->next == NULL || head->next->next == NULL)
return; /* 为空链表或链表中只有一个结点 */
pre = head->next; now = pre->next;
while (now != NULL) {
q = head; p = head->next;
while(p != now && p->key <= now->key)
{
q = p; p = p->next;
} /* 本循环结束时，已经找到了now的插入位置 */
if (p == now)
{ /* now应放在原位置 */
pre = pre->next; now = pre->next; continue;
}
/* 使now记录脱链，将now记录插入链表中 */
pre->next = now->next; q->next = now;
now->next = p; now = pre->next;
}
}
ListNode element[9]=
{
0, &element[1],
49, &element[2],
38, &element[3],
65, &element[4],
97, &element[5],
76, &element[6],
13, &element[7],
27, &element[8],
49, NULL
};
int main()
{
LinkList p = element;
listSort(&p);
p = p->next;
while (p != NULL)
{
printf("%d ",p->key);
p = p->next;
}
getchar();
return 0;
}4.shell排序算法
#include<stdio.h>
#define MAXNUM 100
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void shellSort(SortObject * pvector, int d)
{ /* 按递增序进行Shell排序 */
int i, j, inc;
RecordNode temp, *data = pvector->record;
for (inc = d; inc > 0; inc /= 2)
{
/* inc 为本趟shell排序增量 */
for (i = inc; i < pvector->n; i++)
{
temp = data[i]; /* 保存待插入记录Ri*/
for (j = i-inc; j >= 0 && temp.key < data[j].key; j -= inc)
data[j+inc] = data[j]; /* 查找插入位置，记录后移 */
data[j+inc] = temp; /* 插入记录Ri */
}
}
}
SortObject vector={8,49,38,65,97,76,13,27,49};
int main()
{
int i;
shellSort(&vector,4);
for(i=0;i<8;i++)
printf("%d ",vector.record[i]);
getchar();
return 0;
}
5.直接选择排序算法
#include<stdio.h>
#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void selectSort(SortObject * pvector)
{ /* 按递增序进行直接选择排序 */
int i, j, k;
RecordNode temp, *data = pvector->record;
for( i = 0; i < pvector->n-1; i++ )
{ /* 做n-1趟选择排序 */
k = i;
for (j = i+1; j < pvector->n; j++) /* 在无序区内找出排序码最小的记录Rk*/
if (data[j].key < data[k].key) k = j;
if (k != i)
{ /* 记录Rk与Ri互换 */
temp = data[i];
data[i] = data[k];
data[k] = temp;
}
}
}
SortObject vector={8, 49,38,65,97,76,13,27,49};
int main()
{
int i;
selectSort(&vector);
for(i = 0; i < 8; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}6.堆排序的算法源程序
#include<stdio.h>
#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
/* 定义宏是为了使程序清晰 */
#define leftChild(i) (2*(i)+1)
void sift(SortObject * pvector, int i, int n)
{
int child;
RecordNode temp = pvector->record[i], *data = pvector->record;
child = leftChild(i); /* Rchild是R0的左子女 */
while(child<n)
{
if (child < n-1 && data[child].key < data[child+1].key)
child++; /* child 指向Ri的左、右子女中排序码较大的结点 */
if (temp.key < data[child].key)
{
data[i] = data[child];
i = child; child = leftChild(i);/* child换到父结点位置，继续调整*/
}
else break; /* 调整结束 */
}
data[i] = temp; /* 将记录Ri放入正确位置 */
}
void heapSort(SortObject * pvector)
{ /* 对记录R0到Rn-1进行堆排序 */
int i, n = pvector->n;
RecordNode temp, *data = pvector->record;
for (i = n/2-1; i >= 0; i--)
sift(pvector, i, n); /* 建立初始堆 */
for (i = n-1; i > 0; i--)
{ /* 进行n-1趟堆排序 */
temp = data[0]; /* 当前堆顶记录和最后一个记录互换 */
data[0] = data[i];
data[i] = temp;
sift(pvector, 0, i); /* 从R0到Ri-1重建堆 */
}
}
SortObject vector={8, 49,38,65,97,76,13,27,49};
int main()
{
int i;
heapSort(&vector);
for(i = 0; i < 8; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}7.起泡排序的算法
#include<stdio.h>
#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void bubbleSort(SortObject * pvector)
{
int i, j, noswap;
RecordNode temp, *data = pvector->record;
for(i = 0; i < pvector->n-1; i++)
{ /* 做n-1次起泡 */
noswap = TRUE; /* 置交换标志 */
for (j = 0; j < pvector->n-i-1; j++) /* 从前向后扫描 */
if (data[j+1].key < data[j].key)
{ /* 交换记录 */
temp = data[j];
data[j] = data[j+1];
data[j+1] = temp;
noswap = FALSE;
}
if ( noswap ) break; /* 本趟起泡未发生记录交换，算法结束 */
}
}
SortObject vector={8, 49,38,65,97,76,13,27,49};
int main()
{
int i;
bubbleSort(&vector);
for(i = 0; i < 8; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}8.快速排序的算法源程序
#include<stdio.h>
#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct
{
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void quickSort(SortObject * pvector, int l, int r)
{
int i, j;
RecordNode temp, *data = pvector->record;
if (l >= r) return; /* 只有一个记录或无记录，则无须排序 */
i = l; j = r; temp = data[i];
while (i != j)
{ /* 寻找Rl的最终位置 */
while( data[j].key >= temp.key && j > i )
j--; /* 从右向左扫描，查找第1个排序码小于temp.key的记录 */
if (i < j) data[i++] = data[j];
while( data[i].key <= temp.key && j > i )
i++; /* 从左向右扫描，查找第1个排序码大于temp.key的记录 */
if (i < j) data[j--] = data[i];
}
data[i] = temp; /* 找到Rl的最终位置 */
quickSort(pvector, l, i-1); /* 递归处理左区间 */
quickSort(pvector, i+1, r); /* 递归处理右区间 */
}
SortObject vector = {8, 49,38,65,97,76,13,27,49};
int main()
{
int i;
quickSort(&vector, 0, 7);
for(i = 0; i < 8; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}9.基数排序的算法
#include<stdio.h>
#define D 3 /* D为排序码的最大位数 */
#define R 10 /* R为基数 */
typedef int KeyType;
typedef int DataType;
struct Node; /* 单链表结点类型 */
typedef struct Node RadixNode;
struct Node
{
KeyType key[D];
/* DataType info;*/
RadixNode *next;
};
typedef RadixNode * RadixList;
typedef struct QueueNode
{
RadixNode *f; /* 队列的头指针 */
RadixNode *e; /* 队列的尾指针 */
} Queue;
Queue queue[R];
void radixSort(RadixList * plist, int d, int r)
{
int i,j,k;
RadixNode *p, *head = (*plist)->next;
for(j = d-1; j >= 0; j--)
{ /* 进行d次分配和收集*/
p = head;
for(i = 0; i < r; i++)
{
queue[i].f = NULL; queue[i].e = NULL; /* 清队列 */
}
while (p != NULL)
{
k = p->key[j]; /* 按排序码的第j个分量进行分配*/
if (queue[k].f == NULL)
queue[k].f = p; /* 若第k个队列为空，则当前记录为队头*/
else (queue[k].e)->next = p;/* 否则当前记录链接到第k队的队尾*/
queue[k].e = p;
p = p->next;
}
for(i = 0; queue[i].f == NULL; i++) /* 找出第一个非空队列*/
;
p = queue[i].e; head = queue[i].f; /* head为收集链表的头指针*/
for(i++; i < r; i++)
if(queue[i].f != NULL)
{ /* 收集非空队列 */
p->next = queue[i].f;
p = queue[i].e;
}
p->next = NULL;
}
(*plist)->next = head;
}
struct Node element[11]={
0,0,0,NULL,/*表头*/
0,3,6,NULL,/*36*/
0,0,5,NULL,/*5*/
0,1,6,NULL,/*16*/
0,9,8,NULL,/*98*/
0,9,5,NULL,/*95*/
0,4,7,NULL,/*47*/
0,3,2,NULL,/*32*/
0,3,6,NULL,/*36*/
0,4,8,NULL,/*48*/
0,1,0,NULL /*10*/
};
int main()
{
int i;
RadixList p = element;
for (i = 0; i < 10; i++)
element[i].next = &element[i+1];
element[10].next = NULL;
radixSort(&p, 3, 10);
p = p->next;
while (p != NULL){
printf("%d ", p->key[1]*10+p->key[2]);
p = p->next;
}
getchar();
return 0;
}10.二路归并排序算法
#include<stdio.h>
#define MAXNUM 100
#define TRUE 1
#define FALSE 0
typedef int KeyType;
typedef int DataType;
typedef struct {
KeyType key; /* 排序码字段 */
/*DataType info; 记录的其它字段 */
} RecordNode;
typedef struct {
int n; /* n为文件中的记录个数，n<MAXNUM */
RecordNode record[MAXNUM];
} SortObject;
void merge(RecordNode r[], RecordNode r1[], int low, int m, int high)
{
/* r[low]到r[m]和r[m+1]到r[right]是两个有序段 */
int i = low, j = m + 1, k = low;
while ( i <= m && j <= high )
{ /* 反复复制两个段的第一个记录中较小的 */
if (r[i].key <= r[j].key)
r1[k++] = r[i++];
else r1[k++] = r[j++];
}
while (i <= m) r1[k++] = r[i++]; /* 复制第一个段的剩余记录 */
while (j <= high) r1[k++] = r[j++];/* 复制第二个段的剩余记录 */
}
/* 对 r 做一趟归并，结果放到 r1 中 */
void mergePass(RecordNode r[], RecordNode r1[], int n, int length) {
int i = 0, j; /* length为本趟归并的有序子段的长度 */
while(i + 2*length - 1 < n)
{
merge(r, r1, i, i+length-1, i + 2*length - 1);/* 归并长length的两个子段*/
i += 2*length;
}
if(i + length - 1 < n - 1) /* 剩下两段，后一段长度小于 length */
merge(r, r1, i, i+length-1, n-1);
else /* 将剩下的一段复制到数组r1 */
for(j = i; j < n; j++) r1[j] = r[j];
}
void mergeSort(SortObject * pvector)
{
RecordNode record[MAXNUM];
int length = 1;
while (length < pvector->n)
{
/* 一趟归并，结果存放在数组record中*/
mergePass(pvector->record, record, pvector->n, length);
length *= 2;
/* 一趟归并，结果存回 */
mergePass(record, pvector->record, pvector->n, length);
length *= 2;
}
}
SortObject vector = {8, 49,38,65,97,76,13,27,49};
int main()
{
int i;
mergeSort(&vector);
for(i = 0; i < 8; i++)
printf("%d ", vector.record[i]);
getchar();
return 0;
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
