插入、折半、链式、shell、选择、冒泡和快速递归和非递归排序
①排序的基本概念
排序(Sort)是将无序的记录序列(或称文件)调整成有序的序列。
稳定排序和非稳定排序
设文件f=(R1……Ri……Rj……Rn)中记录Ri、Rj(i≠j,i、j=1……n)的key相等,即Ki=Kj。若在排序前Ri领先于Rj,排序后Ri仍领先于Rj,则称这种排序是稳定的,其含义是它没有破坏原本已有序的次序。反之,若排序后Ri与Rj的次序有可能颠倒,则这种排序是非稳定的,即它有可能破坏了原本已有序记录的次序
内排序和外排序
若待排文件f在计算机的内存储器中,且排序过程也在内存中进行,称这种排序为内排序。内排序速度快,但由于内存容量一般很小,文件的长度(记录个数)n受到一定限制。若排序中的文件存入外存储器,排序过程借助于内外存数据交换(或归并)来完成,则称这种排序为外排序。我们重点讨论内排序的一些方法、算法以及时间复杂度的分析。
②插入排序的实现
#include <stdio.h>
#define N 8
void show_sort(int *arr);
void insert_sort(int *arr);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
printf("未排序数据\n");
show_sort(arr);
printf("排序数据\n");
insert_sort(arr);
return 0;
}
//插入排序
void insert_sort(int *arr)
{
int i,j,tmp;
for(i=1;i<N;i++)
{
//记录插入的元素
tmp = arr[i];
//逐个排序
for(j=i-1;j>=0;j--)
{
//判断插入的元素是否小于已排序的元素
if(tmp<arr[j])
arr[j+1] = arr[j];
else
break;
}
//插入元素到找到的位置
arr[j+1] = tmp;
show_sort(arr);
}
}
void show_sort(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
③折半排序
#include <stdio.h>
#define N 8
void show_sort(int *arr);
void bininsert_sort(int *arr);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
printf("未排序\n");
show_sort(arr);
printf("排序\n");
bininsert_sort(arr);
return 0;
}
//折半插入排序
void bininsert_sort(int *arr)
{
int i,j,low,high,mid,tmp;
for(i=1;i<N;i++)
{
//记录插入的元素
tmp = arr[i];
//查找插入的位置
for(low=0,high=i-1;low<=high;)
{
mid = (low+high)/2;
if(arr[mid]>arr[i])
high = mid-1;
else
low = mid+1;
}
//移动大于插入元素的元素
for(j=i;j>=low;j--)
arr[j] = arr[j-1];
arr[low] = tmp;
show_sort(arr);
}
}
void show_sort(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
④链式排序
#ifndef __LINKSORT_H__
#define __LINKSORT_H__
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;
typedef struct node
{
data_t data;
struct node *next;
}lnode,*pnode;
extern void init_linklist(pnode *H);
extern void create_linklist(pnode h);
extern void sort_linklist(pnode h);
extern void show_linklist(pnode h);
#endif
#include "linksort.h"
void init_linklist(pnode *H)
{
*H = (pnode)malloc(sizeof(lnode));
if(NULL == *H)
{
perror("Malloc failed");
exit(-1);
}
(*H)->data = 0;
(*H)->next = NULL;
}
void create_linklist(pnode h)
{
pnode p,q;
q = h;
int val;
while(1)
{
printf("Please input:");
scanf("%d",&val);
while(getchar() != '\n');
if(-1 == val)
break;
p = (pnode)malloc(sizeof(lnode));
if(NULL == p)
{
perror("Malloc failed");
exit(-1);
}
p->data = val;
p->next = q->next;
q->next = p;
q = p;
}
}
void sort_linklist(pnode h)
{
pnode p,q,r;
//将链表拆分成两部分
p = h;
q = p->next;
p->next = NULL;
//按顺序将数据逐个插入到有序的链表中
while(q)
{
r = q;
q = q->next;
//在有序的链表中寻找r要插入的位置
p = h;
while(p->next && p->next->data<=r->data)
p = p->next;
//将r指向的节点插入有序链表中
r->next = p->next;
p->next = r;
}
}
void show_linklist(pnode h)
{
while(h->next)
{
printf("%d ",h->next->data);
h = h->next;
}
puts("");
}
#include "linksort.h"
int main(int argc, const char *argv[])
{
pnode H;
init_linklist(&H);
create_linklist(H);
show_linklist(H);
sort_linklist(H);
show_linklist(H);
return 0;
}
⑤选择排序
#include <stdio.h>
#define N 8
void show_selection(int *arr);
void sort_selection(int *arr);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
printf("未排序\n");
show_selection(arr);
printf("排序\n");
sort_selection(arr);
return 0;
}
void show_selection(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
void sort_selection(int *arr)
{
int i,j,x,max;
//这里因为是两两比较,所以是小于N-1次
for(i=0;i<N-1;i++)
{
//max记录每一次循环最大值的下标
max = 0;
//这里因为是两两比较,所以是小于N-1次
//另外外层每循环一次就少一组比较的数据所以要N-1-i
for(j=0;j<N-1-i;j++)
//判断并记录买一次最大值的下标
if(arr[max]<arr[j+1])
max = j+1;
//得到需要互换的下标
x = N-i-1;
//判断互换下标的位置是否和max一样,如果一样不能异或互换
if(x != max)
{
//异或互换
arr[max] = arr[max]^arr[x];
arr[x] = arr[max]^arr[x];
arr[max] = arr[max]^arr[x];
}
show_selection(arr);
}
}
⑥冒泡排序
#include <stdio.h>
#define N 8
void show_bubble(int *arr);
void sort_bubble(int *arr);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
printf("未排序\n");
show_bubble(arr);
printf("排序\n");
sort_bubble(arr);
return 0;
}
void show_bubble(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
void sort_bubble(int *arr)
{
int i,j,tmp;
//这里因为是两两比较,所以是小于N-1次
for(i=0;i<N-1;i++)
{
//这里因为是两两比较,所以是小于N-1次
//另外外层每循环一次就少一组比较的数据所以要N-1-i
for(j=0;j<N-1-i;j++)
if(arr[j]>arr[j+1])
{
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
show_bubble(arr);
}
}
⑦shell排序
#include <stdio.h>
#define N 8
void shell_sort(int *arr);
void show_sort(int *arr);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
printf("未排序\n");
show_sort(arr);
printf("排序\n");
shell_sort(arr);
return 0;
}
void shell_sort(int *arr)
{
int i,j,d,tmp;
//定义shlle的缩小增量d
for(d=N/2;d>0;d=d/2)
{
//插入排序
for(i=d;i<N;i++)
{
//记录插入的元素
tmp = arr[i];
//逐个排序
for(j=i-d;j>=0;j=j-d)
{
//判断car的元素是否小于已排序的元素
if(tmp < arr[j])
arr[j+d] = arr[j];
else
break;
}
//插入元素到找到的位置
arr[j+d] = tmp;
}
show_sort(arr);
puts("");
}
}
void show_sort(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
⑧递归快速排序
#include <stdio.h>
#define N 8
void show_quicksort(int *arr);
int quickpass(int *arr,int low,int high);
void quicksort(int *arr,int low,int high);
int main(int argc, const char *argv[])
{
int arr[N] = {50,36,66,76,95,12,25,36};
quicksort(arr,0,N-1);
show_quicksort(arr);
return 0;
}
void show_quicksort(int *arr)
{
int i;
for(i=0;i<N;i++)
printf("%d ",arr[i]);
puts("");
}
//单步排序
int quickpass(int *arr,int low,int high)
{
int tmp;
tmp = arr[low];
//当low小于high的时候保持循环
while(low < high)
{
//当low<high并且找到基准tmp<=下标high的位置
while(low < high && tmp <= arr[high])
high--;
//判断不是因为low<high退出的循环
if(low < high)
arr[low] = arr[high];
//当low<high并且找到基准tmp>=下标low的位置
while(low < high && tmp >=arr[low])
low++;
//判断不是因为low<high退出的循环
if(low < high)
arr[high] = arr[low];
}
show_quicksort(arr);
arr[high] = tmp;
//返回最后基准的位置
return high;
}
//递归排序
void quicksort(int *arr,int low,int high)
{
int mid;
if(low < high)
{
mid = quickpass(arr,low,high);
quicksort(arr,low,mid-1);
quicksort(arr,mid+1,high);
}
}
⑨使用栈实现非递归快速排序
#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;
typedef struct stacknode
{
data_t data;
struct stacknode *next;
}lstack,*pstack;
extern void init_linkstack(pstack *S);
extern void push_linkstack(pstack s,data_t val);
extern void pop_linkstack(pstack *s,data_t *val);
extern void show_linkstack(pstack s);
#endif
#include "linkstack.h"
void init_linkstack(pstack *S)
{
*S = (pstack)malloc(sizeof(lstack));
if(NULL == *S)
{
perror("Malloc failed");
exit(-1);
}
(*S)->next = NULL;
}
void push_linkstack(pstack s,data_t val)
{
pstack p;
p = (pstack)malloc(sizeof(lstack));
if(NULL == p)
{
perror("Malloc failed");
exit(-1);
}
p->data = val;
p->next = s->next;
s->next = p;
}
void pop_linkstack(pstack *s,data_t *val)
{
pstack p;
if((*s)->next == NULL)
{
printf("The stack is empty\n");
return ;
}
p = (*s)->next;
free(*s);
*s = p;
*val = (*s)->data;
}
void show_linkstack(pstack s)
{
while(s->next)
{
printf("%d ",s->next->data);
s = s->next;
}
puts("");
}
#ifndef __QUICKSORT_H__
#define __QUICKSORT_H__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "linkstack.h"
#define N 16
extern void show_quick(int *arr);
extern int quickpass(int *arr,int low,int high);
extern void quicksort(int *arr,int low,int high);
#endif
#include "linkstack.h"
#include "quicksort.h"
void show_quick(int *arr)
{
int i;
for(i=0;i<16;i++)
printf("%d ",arr[i]);
puts("");
}
//单步排序
int quickpass(int *arr,int low,int high)
{
int tmp;
tmp = arr[low];
//当low小于high的时候保持循环
while(low < high)
{
//当low<high并且找到基准tmp<=下标high的位置
while(low<high && tmp<=arr[high])
high--;
//判断不是因为low<high退出的循环
if(low < high)
arr[low] = arr[high];
//当low<high并且找到基准tmp>=下标low的位置
while(low<high && tmp>=arr[low])
low++;
//判断不是因为low<high退出的循环
if(low < high)
arr[high] = arr[low];
}
arr[high] = tmp;
//返回最后基准的位置
return high;
}
//非递归排序
void quicksort(int *arr,int low,int high)
{
pstack p;
int mid;
//初始化栈
init_linkstack(&p);
//压栈,因为栈的特性所以先压高位再压低位
push_linkstack(p,high);
push_linkstack(p,low);
//判断栈是否为空
while(p->next)
{
//出栈
pop_linkstack(&p,&low);
pop_linkstack(&p,&high);
//单步排序
mid = quickpass(arr,low,high);
//判断高位是否还有数据,如果右就压栈
if(mid+1 < high)
{
push_linkstack(p,high);
push_linkstack(p,mid+1);
}
//判断低位是否还有数据,如果右就压栈
if(mid-1 > low)
{
push_linkstack(p,mid-1);
push_linkstack(p,low);
}
show_quick(arr);
}
}
#include "quicksort.h"
#include "linkstack.h"
int main(int argc, const char *argv[])
{
int arr[16] = {50,36,66,76,95,12,25,36,7,22,55,89,33,40,99,2};
printf("未排序\n");
show_quick(arr);
printf("排序\n");
quicksort(arr,0,15);
return 0;
}
栈非递归实现步骤