内部排序

最新推荐文章于 2024-06-06 09:35:49 发布
置顶 最新推荐文章于 2024-06-06 09:35:49 发布
阅读量625 收藏
点赞数 1
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigdata_lijun/article/details/8829863
版权
一：插入排序
1.直接插入排序：首先默认前面1,2……N个元素师排好序的。 
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void InsertSort(ElemType a[],int n)
{
	ElemType x;
	int i,j;
	for(i=1;i<n;i++)
	{
		x=a[i];
		for(j=i-1;j>=0;j--)
		{
			if(x<a[j])
				a[j+1]=a[j];
			else
				break;
		}
		a[j+1]=x;
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		InsertSort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

2.折半插入排序:若要插入一个记录，可先对有序的记录序列折半，确定要插入记录的位置在前一半序列，还是在后一半序列中，不断地对有序的记录序列折半，最后找到合适的插入位置。 
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void Binsort(ElemType a[],int n)
{
	ElemType x;
	int i,j,low,high,mid;
	for(i=1;i<n;i++)
	{
		x=a[i];
		low=0;
		high=i-1;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(x<a[mid])
				high=mid-1;
			else
				low=mid+1;
		}
		for(j=i-1;j>=low;j--)
			a[j+1]=a[j];
		a[low]=x;
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		Binsort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

3.希尔排序： 不断地把待排序的一组记录按间隔值分成若干小组，分别进行组内直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。对间隔值(用d 表示)的取法有多种，希尔提出的方法是：d1=[n/2]，di+1=[di/2]，最后一次排序时间的间隔值必须为1，其中n 为记录数。 
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void Shellsort(ElemType a[],int n)
{
	ElemType x;
	int i,j,d;
	d=n/2;
	while(d>=1)
	{
		for(i=d;i<n;i++)
		{
			j=i-d;
			while(j>=0)
			{
				if(a[j]>a[j+d])
				{
					x=a[j];
					a[j]=a[j+d];
					a[j+d]=x;
					j=j-d;
				}
				else
					j=-1;
			}
		}
		d=d/2;
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		Shellsort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

二：交换排序
1.冒泡排序： 依次比较相邻的两个数，将小数放在前面，大数放在后面。 
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void BubbleSort(ElemType a[],int n)
{
	ElemType x;
	int i,j,flag;
	for(i=0;i<n;i++)
	{
		flag=0;
		for(j=n-1;j>i;j--)
			if(a[j]<a[j-1])
			{
				flag=1;
				x=a[j];
				a[j]=a[j-1];
				a[j-1]=x;
			}
		if(flag==0)
			break;
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		BubbleSort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

2.快排：

（1）．先从数列中取出一个数作为基准数。

（2）．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

（3）．再对左右区间重复第二步，直到各区间只有一个数。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void QuickSort(ElemType a[],int l,int r)
{
	ElemType x;
	int i,j;
	if(l<r)
	{
		i=l,j=r,x=a[l];
		while(i<j)
		{
			while(i<j&&a[j]>=x)
				j--;
			if(i<j)
				a[i++]=a[j];
			while(i<j&&a[i]<x)
				i++;
			if(i<j)
				a[j--]=a[i];
		}
		a[i]=x;
		QuickSort(a,l,i-1);
		QuickSort(a,i+1,r);
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		QuickSort(a,0,n-1);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

三：选择排序

1.直接选择：每次选择最小的放在前面。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void SelectSort(ElemType a[],int n)
{
	int i,j,k;
	ElemType x;
	for(i=0;i<n;i++)
	{
		k=i;
		for(j=i+1;j<n;j++)
			if(a[j]<a[k])
				k=j;
		if(k!=i)
		{
			x=a[i];
			a[i]=a[k];
			a[k]=x;
		}
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		SelectSort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}

2.堆排序： 

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef int ElemType;
void sift(ElemType a[],int n,int i)
//假定a[i+1]~a[n-1]构成的堆是有序的，a[i]为待插入的根结点
{
	ElemType x=a[i];
	int j=2*i+1;
	while(j<=n-1)
	{
		if(j<n-1 && a[j]<a[j+1])
			j++;
		if(a[j]>x)
		{
			a[i]=a[j];
			i=j;
			j=2*j+1;
		}
		else
			break;
	}
	a[i]=x;
}

void HeapSort(ElemType a[],int n)
{
	int i;
	ElemType x;
	for(i=n/2-1;i>=0;i--)
		sift(a,n,i);
	for(i=1;i<n;i++)
	{
		x=a[n-i];
		a[n-i]=a[0];
		a[0]=x;
		sift(a,n-i,0);
	}
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		HeapSort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}


#include <iostream>
#include<algorithm>
using namespace std;

void HeapAdjust(int *a,int i,int size)  //调整堆 
{
    int lchild=2*i;       //i的左孩子节点序号 
    int rchild=2*i+1;     //i的右孩子节点序号 
    int max=i;            //临时变量 
    if(i<=size/2)          //如果i不是叶节点就不用进行调整 
    {
        if(lchild<=size&&a[lchild]>a[max])
        {
            max=lchild;
        }    
        if(rchild<=size&&a[rchild]>a[max])
        {
            max=rchild;
        }
        if(max!=i)
        {
            swap(a[i],a[max]);
            HeapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆 
        }
    }        
}

void BuildHeap(int *a,int size)    //建立堆 
{
    int i;
    for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2 
    {
        HeapAdjust(a,i,size);    
    }    
} 

void HeapSort(int *a,int size)    //堆排序 
{
    int i;
    BuildHeap(a,size);
    for(i=size;i>=1;i--)
    {
        //cout<<a[1]<<" ";
        swap(a[1],a[i]);           //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 
          //BuildHeap(a,i-1);        //将余下元素重新建立为大顶堆 
          HeapAdjust(a,1,i-1);      //重新调整堆顶节点成为大顶堆
    }
} 

int main(int argc, char *argv[])
{
     //int a[]={0,16,20,3,11,17,8};
    int a[100];
    int size;
    while(scanf("%d",&size)==1&&size>0)
    {
        int i;
        for(i=1;i<=size;i++)
            cin>>a[i];
        HeapSort(a,size);
        for(i=1;i<=size;i++)
            cout<<a[i]<<" ";
        cout<<endl;
    }
    return 0;
}


四：归并排序 

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

typedef int ElemType;


void TwoMerge(ElemType a[],ElemType b[],int m,int n,int t)
{
	int i=m,j=n+1,k=m;
	while(i<=n && j<=t)
	{
		if(a[i]<a[j])
		{
			b[k]=a[i];
			i++;
		}
		else
		{
			b[k]=a[j];
			j++;
		}
		k++;
	}
	while(i<=n)
	{
		b[k]=a[i];
		i++;
		k++;
	}
	while(j<=t)
	{
		b[k]=a[j];
		j++;
		k++;
	}
}

void MergePass(ElemType a[],ElemType b[],int n,int len)
{
	int p=0;
	while(p+2*len-1<n)
	{
		TwoMerge(a,b,p,p+len-1,p+2*len-1);
		p+=2*len;
	}
	if(p+len<n)
		TwoMerge(a,b,p,p+len-1,n-1);
	else
	{
		int i;
		for(i=p;i<n;i++)
			b[i]=a[i];
	}
}

void MergeSort(ElemType a[],int n)
{
	int len=1;
	ElemType *b=new ElemType[n];
	while(len<n)
	{
		MergePass(a,b,n,len);
		len*=2;
		MergePass(b,a,n,len);
		len*=2;
	}
	free(b);
}

int main()
{
	int n,i;
	ElemType a[100000]={0};
	printf("请输入要测试的数据的个数：");
	while(1)
	{
		scanf("%d",&n);
		if(n==0)
			break;
		srand(time(NULL));
		for(i=0;i<n;i++)
			a[i]=rand()%100000;
		printf("原序：");
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n排序后：");
		MergeSort(a,n);
		for(i=0;i<n;i++)
			printf("%d  ",a[i]);
		printf("\n***************************************\n");
	}
	return 0;
}




不仅仅是寻找
关注
专栏目录
数据结构判断题精编
大土的博客
12-20 7714
声明所有题搜集于网络。题在长度为n的顺序表中，求第i个元素的直接前驱算法的时间复杂度为O(1)O(1)。（ ）第i个元素的直接前驱为第i-1个元素，直接存取，事件复杂度为O(1)O(1)。答案：对内部排序是指排序过程在内存中进行的排序。（ ）答案：对当待排序序列初始有序时，简单选择排序的时间复杂性为O(n)O(n)。( ) 为O(0)O(0),理解各个排序的本质，或熟记排序间的比较。答案：错
数据结构-排序
06-25 5497
判断题 1.希尔排序是稳定的算法。 T F 稳定的算法：保证排序前两个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。 希尔排序会多次进行插入排序，一次插入排序是稳定的，但是因为希尔排序每次插入排序选择的步长不一样，导致希尔排序不稳定。 2.仅基于比较的算法能得到的最好的“最坏时间复杂度”是O(NlogN)。 ...
数据结构内部排序和外部排序
叁木大数据
01-22 3023
数据结构内部排序和外部排序1.1 概念1.2 衡量方法1.3 区分与汇总 1.1 概念 内排序：在排序过程中，所有元素调到内存中进行的排序。 外排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行访问的排序过程 1.2 衡量方法 内部排序：比较次数，也就是时间复杂度 外部排序：IO次数，也就是读写外存的次数 1.3 区分与汇总 内排序和外排序 的区分就是看排序...
各种内部排序算法的比较及应用（插入排序、交换排序、选择排序、归并排序、基数排序）
最新发布
心碎烤肠的博客
06-06 1838
这篇文章总结了所有内部排序的适用场景，性质特点，以及空间和时间复杂度的考量； 前半部分是对内部排序的总结，后半部分是对所有内部排序的具体性能分析；
内部排序算法的特点
weixin_69884785的博客
05-23 1307
内部算法：直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序算法，简单选择排序，堆排序，归并排序，基数排序 1.内部排序算法的时间/空间复杂度 2.内部排序算法的稳定性 3.内部排序算法的排序趟数 4.内部排序算法总比较次数 5.内部排序算法能否并行执行 6.内部排序算法顺序存储更换为链式存储 7.各内部排序算法的特点
超详细！各种内部排序算法的比较
KK_2018的技术博客_程序员不止是程序员
11-30 2235
先来个表格总结直观展示下： 各种内部排序算法的性质 算法种类 时间复杂度 空间复 杂度 稳定性 最好情况 平均情况 最坏情况 插入排序 直接插入排序 O(n) O(n^2) O(n^2) O(1) 稳定 折半插入排序 O(n) O(n^2) O(n^2) O(1) 稳定 希尔排序 O(n^1.3) O(nlogn) ...
c语言6种内部排序,数据结构6种内部排序算法的比较
weixin_42524499的博客
05-20 1646
1、需求分析(1)输入数据的形式为：伪随机数产生程序产生，且每次输入数不少于100个，至少要用5组不同的输入数据(2)输出的形式为：输出关键字参加的比较次数和关键字的移动次数(关键字交换计为3次移动)的数据(3)程序能达到的功能：对起泡排序，直接插入排序，简单选择排序，快速排序，希尔排序，堆排序这6种常用的内部排序算法进行比较，比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3...
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录
04-15
在本文中，我们将深入探讨内部排序算法，包括它们的工作原理、优缺点以及如何使用Python、JavaScript、Java、Go和PHP这些编程语言来实现它们。 1. 冒泡排序：冒泡排序是一种简单的交换排序方法，通过不断比较相邻...
各种内部排序方法及其比较实验报告
12-11
"各种内部排序方法及其比较实验报告" 内部排序是指在计算机内存中对数据进行排序的方法。内部排序方法有很多，常见的有直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序等。 直接插入...
数据机构综合课设内部排序算法比较.docx
03-26
**内部排序算法详解** 内部排序是指数据记录在内存中进行排序的过程。本篇文章将深入探讨10种常见的内部排序算法，包括它们的基本思想、比较次数和移动次数的计算，以便更直观地理解不同算法的效率。 1. **直接...
基于C++实现的各种内部排序算法汇总
12-31
这里就把各种内部排序算法总结归纳了一下，包括插入排序（直接插入排序，折半插入排序，希尔排序）、交换排序（冒泡排序，快速排序）、选择排序（简单选择排序，堆排序）、2-路归并排序。（另：至于堆排序算法，前面...
【排序结构5】 基于比较的内部排序总结
07-26
【排序结构5】基于比较的内部排序总结 在计算机科学中，排序是将一组数据按照特定顺序排列的过程。内部排序，或称为内存排序，是指数据记录在内存中进行的排序，与外部排序（数据量太大无法全部装入内存）相对。本...
Dijkstra算法
05-20 3564
Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。 　　Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。 其基本思想是，设置顶点集
筛选法求质数
07-11 1183
#include #include #include #define m 10000001 int main() { clock_t start, finish; int i,j,p[m],count; start=clock(); for(i=0;i<m;i++) p[i]=1; for(i=2;i*i<m;i++) if(p[i]) { for(j=i+i;j<m;
RMQ和LCA
05-07 1073
RMQ和LCA 【内容简介】 　　讨论解决RMQ、LCA问题的算法、以及RMQ、LCA两类问题的相互转换。它们在字符串处理和生物学计算中有着广泛应用，在信息学奥赛中更是被广泛应用和扩展，所以熟练掌握RMQ和LCA问题就显得十分重要。 ※在内容开始，我们假设一个算法预处理时间为 f(n)，查询时间为g(n)。这个算法复杂度的标记为(或f(n)-g(n))。 【关键词】RMQ、LCA、ST
Bellman-Ford算法
05-20 912
Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯特•福特（Lester Ford）发明。Bel
Floyd-Warshall
05-20 756
Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。   使用条件&范围 通常可以在任何图中使用，包括有向图、带负权边的图。   Floyd-Warshall 算法用来找出每对点之间的最短距离。它需要用邻接矩阵来储存边，这个算法通过考虑最佳子路径来得到最佳路径。   1.注意单独一条边的路径也不一定是最佳路径。 2.从任意一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值