插入、折半、链式、shell、选择、冒泡和快速递归和非递归排序

最新推荐文章于 2022-10-05 14:38:50 发布

Epley

最新推荐文章于 2022-10-05 14:38:50 发布

阅读量178

点赞数

分类专栏： C语言数据结构

本文链接：https://blog.csdn.net/m198984/article/details/103739850

版权

C语言数据结构专栏收录该内容

12 篇文章 0 订阅

订阅专栏

插入、折半、链式、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;
}

栈非递归实现步骤
在这里插入图片描述

Epley

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
插入、折半、链式、shell、选择、冒泡和快速递归和非递归排序

插入、折半、链式、shell、选择、冒泡和快速递归和非递归排序①排序的基本概念排序(Sort)是将无序的记录序列（或称文件）调整成有序的序列。稳定排序和非稳定排序设文件f=（R1……Ri……Rj……Rn）中记录Ri、Rj（i≠j，i、j=1……n）的key相等，即Ki=Kj。若在排序前Ri领先于Rj，排序后Ri仍领先于Rj，则称这种排序是稳定的，其含义是它没有破坏原本已有序的次序。反之，若...
复制链接

扫一扫

专栏目录