排序算法的实现

最新推荐文章于 2023-05-08 10:11:28 发布
最新推荐文章于 2023-05-08 10:11:28 发布
阅读量530 收藏
点赞数
分类专栏： c++ 文章标签： 算法 ini
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zqt520/article/details/7359741
版权

1.插入排序

算法导论P3

/*
 * InsertSort.cpp
 *
 *  Created on: 2012-7-9
 *      Author: sangerhoo
 */

#include <iostream>

using namespace std;

void InsertSort(int *Array,int n)
{
	int i,j,key;
	for(j=1;j<n;j++)
	{
		key=*(Array+j);
		i=j-1;
		while(i>=0 && *(Array+i)>key)
		{
			*(Array+i+1)=*(Array+i);
			i--;
		}
		*(Array+i+1)=key;
	}
}
void ArrayPrint(int *Array,int n)
{
	int i;
	for(i=0;i<n;i++)
	{
		cout<<*(Array+i)<<"\t";
	}
	cout<<endl;
}

int main()
{

	int i;
	int Array[]={25,3,56,7,83,4,5,65,9,10};
	int length=sizeof(Array)/sizeof(int);
	cout<<"排序前"<<endl;
	ArrayPrint(Array,length);
	InsertSort(Array,length);;
	cout<<"排序后"<<endl;
	ArrayPrint(Array,length);
	return 0;
}


2.快速排序(用递归实现) 

/*
 * QuickSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */
#include<stdio.h>
#include<stdlib.h>

int Partition(int *array ,int i,int j)
{
	int t = *(array+i);
	while(i<j)
	{
		while(i<j && *(array+j)>=t)
			j--;
		if(i<j)
		{
			*(array+i)=*(array+j);
					i++;
		}
		while(i<j && *(array+i)<=t)
			i++;
		if(i<j)
		{
			*(array+j)=*(array+i);
			j--;
		}
	}
	*(array+i)=t;
	return i;
}

void QuickSort(int *array,int low,int high)
{
	int mid;
	if(low<high)
	{
		mid=Partition(array,low,high);
		QuickSort(array,low,mid-1);
		QuickSort(array,mid+1,high);
	}
}
void main()
{
	int array[]={12,34,67,8,23,90};
	int i;
	int n= sizeof(array)/sizeof(int);
	printf("n=%d",n);
	printf("派寻前\n");
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
	QuickSort(array,0,n-1);
	printf("派寻后\n");
	printf("n=%d\n",n);
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
}

算法导论版本：p85

/*
 * Quicksort.cpp
 *
 *  Created on: 2012-7-23
 *      Author: sangerhoo
 */
#include<iostream>
using namespace std;


void swap(int *a,int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
int Partion(int *array, int p, int r)
{
	int temp = *(array + r);
	int i = p ;
	for (int j = p; j <= r ;++j)
	{
		if (*(array + j) < temp)
		{
			swap(array + i,array + j);
			i++;
		}
	}
	swap(array + i, array + r);
	return i;
}
void Quicksort(int *array, int p, int r)
{
	if (p < r)
	{
		int i = Partion(array, p, r);
		Quicksort(array, p, i - 1);
		Quicksort(array, i + 1, r);
	}
}

void ArrayPrint(int *Array,int n)
{
	int i;
	for (i = 0; i < n; i++) {
		cout << *(Array + i) << "\t";
	}
	cout << endl;
}


int main()
{
	int Array[] = { 25, 3, 56, 7, 83, 4, 5, 65, 9, 10 };
	int length = sizeof(Array) / sizeof(int);
	cout << "排序前" << endl;
	ArrayPrint(Array, length);
	Quicksort(Array, 0, length - 1);
	cout << "排序后" << endl;
	ArrayPrint(Array, length);
	return 0;
}


3.冒泡排序 

/*
 * bubblesort.c
 *
 *  Created on: 2012-3-16
 *      Author: sangerhoo
 */
#include<stdio.h>
#include<stdlib.h>

void bubblesort(int *arry,int n)
{
	int a,i,j;
	for (i=n-1;i>0;i--)
	{
		for(j=0;j<i;j++)
		{
			if(*(arry+j)>*(arry+j+1))
			{
				a=*(arry+j);
				*(arry+j)=*(arry+j+1);
				*(arry+j+1)	=a;
			}
		}
	}
}

void main()
{
	int arry[8]={5,9,4,1,7,6,3,2};
	int i;
	printf("排序前\n");
	for(i=0;i<8;i++)
	{
		printf("%d",*(arry+i));
	}
	printf("\n");
	bubblesort(arry,8);
	printf("排序后\n");
	for(i=0;i<8;i++)
	{
		printf("%d",*(arry+i));
	}
	printf("\n");
}

4.选择排序

/*
 * SelectSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */
#include<stdio.h>
#include<stdlib.h>

void SelectSort(int *array,int n)
{
	int i,j,m,a;

	for(i=0;i<n-1;i++)
	{
		m=i;
		for(j=i+1;j<n;j++){
			if(*(array+j) < *(array+m))
						m=j;
		}
		if(m!=i)
			{
				a=*(array+m);
				*(array+m)=*(array+i);
				*(array+i)=a;
			}

	}

}

void main()
{
	int array[]={12,34,67,8,23,90};
	int i;
	int n= sizeof(array)/sizeof(int);
	printf("n=%d",n);
	printf("派寻前\n");
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
	SelectSort(array,n);
	printf("派寻后\n");
	printf("n=%d\n",n);
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
}


5.插入排序

/*
 * InsertSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */

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

void InsertSort(int *array,int n)
{
	int i,j,tmp;
	for(i=0;i<n;i++)
	{
		j=i+1;
		tmp=*(array+j);
		while(j!=0  && tmp>*(array+j-1))
		{
			*(array+j)=*(array+j-1);
			j--;
		}
		*(array+j)=tmp;
	}
}

void main()
{
	int array[]={12,34,67,8,23,90,10};
	int i;
	int n= sizeof(array)/sizeof(int);
	printf("n=%d",n);
	printf("派寻前\n");
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
	InsertSort(array,n);
	printf("派寻后\n");
	printf("n=%d\n",n);
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
}


6.Shell排序

/*
 * ShellSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */

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

void ShellInsert(int *array, int step, int n) {

	int i, j, key;
	for (i = step; i <n; i++) {
		if (*(array + i) < *(array + i - step)) {
			key = *(array + i);
			j = i - step;
			do {
				*(array + j + step) = *(array + j);
				j -= step;
			} while (j > 0 && key<*(array + j));
			*(array + j + step) = key;
		}
	}

}

void ShellSort(int *array, int n) {
	int addtion = n;
	do {
		addtion = addtion / 3 + 1;
		ShellInsert(array, addtion, n);
	} while (addtion > 1);
}
void main() {
	int array[] = { 12, 34, 67, 8, 23, 90, 10 };
	int i;
	int n = sizeof(array) / sizeof(int);
	printf("n=%d", n);
	printf("派寻前\n");
	for (i = 0; i < n; i++) {
		printf("%d \t", array[i]);
	}
	printf("\n");
	ShellSort(array, n);
	/*ShellInsert(array,3, n);*/
	printf("派寻后\n");
	printf("n=%d\n", n);
	for (i = 0; i < n; i++) {
		printf("%d \t", array[i]);
	}
	printf("\n");
}
 7.堆排序
/*
 * HeapSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */

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

int count =1;
void Restore(int *array,int i,int n)
{
	int j,k,r;
	int done=0;
	k=r=*(array+i);
	j=2*i;
	while((j<n) && (done == 0))
	{
		if(j<n)
		{
			if(*(array+j)<*(array+j+1))
			{
				j++;
			}
		}

		if(k>=*(array+j))
		{
			done=1;
		}
		else
		{
			*(array+j/2)=*(array+j);
			j*=2;
		}
	}
	*(array+j/2)=r;

}

void HeapSort(int *array,int n)
{

	int i,j,t;
	for(i=n/2;i>0;i--)
		Restore(array,i,n);
	for(i=n-1;i>0;i--)
	{
		t=*(array+i+1);
		*(array+i+1)=*(array+1);
		*(array+1)=t;
		Restore(array,1,i);
	}


}
void main()
{
	int array[]={0,12,34,67,8,23,90,10};//array[0]不起作用
	int i;
	int n= sizeof(array)/sizeof(int);
	printf("n=%d",n);
	printf("派寻前\n");
	for(i=1;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
	HeapSort(array,n-1);
	printf("派寻后\n");
	printf("n=%d\n",n);
	for(i=1;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
}


 8.归并排序
/*
 * MergerSort.c
 *
 *  Created on: 2012-3-17
 *      Author: sangerhoo
 */

#include<stdlib.h>
#include<stdio.h>
void merger(int *array,int l,int m,int r)
{
	int na=m-l+1;
	int nb=r-m;
	int array_a[na];
	int array_b[nb];
	int i,j=0,k=0;
	for(i=0;i<na;i++)
	{
		*(array_a+i)=*(array+l+i);
	}
	for(i=0;i<nb;i++)
	{
		*(array_b+i)=*(array+m+1+i);
	}

	for(i=0;i<r;i++)
	{
		//*(array+l+i)=(*(array_a+j)>*(array_b+k) ? *(array_a+j++) : *(array_b+k++) );
		if(*(array_a+j)>*(array_b+k))
		{
			*(array+l+i)=*(array_a+j);
			j++;

		}
		else
		{
			*(array+l+i)=*(array_b+k);
			k++;

		}
		if(j>=na)
		{
			i++;
			break;
		}
		if(k>=nb)
		{
			i++;
			break;
		}

	}

	while(j<na)
	{
		*(array+l+i)=*(array_a+j);
		i++;
		j++;
	}
	while(k<nb)
	{
		*(array+l+i)=*(array_b+k);
		i++;
		k++;
	}

}

void mergersort(int *array,int l,int r)
{
	int mid=0;
	if(l<r)
	{
	    mid=(l+r)/2;
		mergersort(array,l,mid);
		mergersort(array,mid+1,r);
		merger(array,l,mid,r);
	}

}

void main()
{
	int array[]={12,34,67,8,23,90,10,3};
	int i;
	int n= sizeof(array)/sizeof(int);
	printf("n=%d",n);
	printf("派寻前\n");
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
	mergersort(array,0,n-1);
	printf("派寻后\n");
	printf("n=%d\n",n);
	for(i=0;i<n;i++)
	{
		printf("%d \t",array[i]);
	}
	printf("\n");
}
















                

        

        

    

  


    

      

        

            

              
                
                  zqt520
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
广州大学 数据结构实验报告  实验四  查找和排序算法实现

				
			

			

				

					05-23
				

			

		

		

			
				
实验报告的主题聚焦于数据结构中的查找和排序算法实现，这是计算机科学中基础且重要的部分，尤其是在处理大量数据时。以下是对这些算法的详细说明：  1. **插入排序**：插入排序的基本思想是将一个记录插入到已经排...

			
		

	



                

              
                



	

		

			

				
					
Java排序算法实现：冒泡与选择排序示例代码

				
			

			

				

					01-04
				

			

		

		

			
				
Java排序算法实现主要涉及到两种经典的算法：冒泡排序和选择排序。这两种算法都是基于比较的排序方法，适用于小规模或教学目的的数据排序。  **冒泡排序（Bubble Sort）** 是一种简单直观的排序算法，其核心思想是...

			
		

	



                


  
              

                


	

		

			

				
					
排序算法：希尔排序算法实现及分析

				
			

			

				

					重庆李四
				

				

					02-23
					
					5428
					
				

			

		

		

			
				
希尔排序算法介绍希尔排序是D.LShell 与1957年提出来的一种排序算法，在这之前排序算法的时间复杂度都是O(n^2),希尔排序算法是突破这个时间复杂度的第一批算法之一。我们知道直接插入排序算法（不知道的请看：排序算法：直接插入排序算法实现及分析），在某些情况下的效率是很很高的，1.当我们的记录本身就是基本有序（小的关键字基本在前面，大的基本在后面）的，我们只需要少量的插入操作，就可以完成排序...

			
		

	





	

		

			

				
					
实验四  查找和排序算法实现

				
			

			

				

					雨化于画
				

				

					02-22
					
					5474
					
				

			

		

		

			
				
广州大学学生实验报告
开课实验室：计算机科学与工程实验（电子楼418A）
学院	计算机科学与网络工程学院	
实验课程	数据结构实验	
实验项目	实验四  查找和排序算法实现

一、实验目的：
1、各种排序算法的实现
2、各种查找算法实现
二、使用仪器、器材
微机一台
操作系统：WinXP
编程软件：C++
三、实验内容及原理
1、各种排序算法的实现 
用随机函数生成16个2位正整数（10~99），...

			
		

	



		

			
		



	

		

			

				
					
SWUST OJ 1016: 插入排序算法实现

				
			

			

				

					橙橙橙汁i的博客
				

				

					05-10
					
					1573
					
				

			

		

		

			
				
1016: 插入排序算法实现
题目描述
插入排序算法实现。
输入

第一行是待排序数据元素的个数；
第二行是待排序的数据元素。

输出

一趟直接插入排序算法结果。

样例输入

10
50 36 41 19 23 4 20 18 12 22

样例输出

36 50 41 19 23 4 20 18 12 22

思路：


插入排序假设待排序的记录存放在数组 R[0….n-1] 中，排序过程的某一中间时刻， R 被划分成两个子区间 R[0…i-1] 和 R[i….n-1] ，其中：前一个子区间是已排好序

			
		

	





	

		

			

				
					
常用十大排序算法

					
热门推荐

				
			

			

				

					qq_51664685的博客
				

				

					04-26
					
					14万+
					
				

			

		

		

			
				
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。

			
		

	





	

		

			

				
					
C语言实现快速排序算法

				
			

			

				

					wantsnowfly的博客
				

				

					01-15
					
					5498
					
				

			

		

		

			
				
快排作为公认最优秀的排序方法，是每一个程序员都应该掌握的，那么，今天就由我来为大家简单讲解一下快速排序算法的代码。

源代码如下：

#include<stdio.h>
void quicksort(int *a,int left,int right)
{
 if(left>right)
 {
  return ;
 }
 int i=left;
 int j=right;
 int key=a[left];
 while(i!=j)
...

			
		

	





	

		

			

				
					
快速排序算法

				
			

			

				

					鹏鹏2077
				

				

					05-08
					
					5103
					
				

			

		

		

			
				
快速排序（Quicksort），计算机科学词汇，适用领域Pascal，c++等语言，是对冒泡排序算法的一种改进。本次实现使用的Java代码。快速排序是一种高效的排序算法，其核心思想是分治法。快速排序的基本思路是先选取一个枢轴元素，通过一趟排序将待排序序列分成两部分，其中左边部分的所有元素都小于等于枢轴元素，右边部分的所有元素都大于等于枢轴元素，然后分别递归地对左右两部分进行排序，直到整个序列有序。

			
		

	





	

		

			

				
					
直接插入排序算法

				
			

			

				

					m0_64529905的博客
				

				

					08-03
					
					2997
					
				

			

		

		

			
				
在有序区（r[1]~r[i-1]）中插入r[i],首先找到第i个记录的正确插入位置，然后将r[i]插入到有序序        列中。1、 基本思想：在插入第i个元素时，前（i-1） 个元素已经有序。(2)  r[0]暂存r[i]的元素，避免了因元素的后移覆盖r[i]的值。（1）在查找嘻哈如位置的循环中r[0]起到监视哨（或者监视哨兵的作用）最好情况（正序）：例如1、2、3、4、5、6。最差情况（逆序）：例如6、5、4、3、2、1。比较次数：n-1 （共有n个元素）移动次数：2（n-1）时间复杂度：O(n).

			
		

	





	

		

			

				
					
十大经典排序算法-归并排序算法详解

				
			

			

				

					qq_35344198的博客
				

				

					06-19
					
					12万+
					
				

			

		

		

			
				
一、什么是归并排序
1.概念
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的
2.算法原理
这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分

序列逐层拆分如下

然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并
创建一个大序列，序列长度为两个小序列长度

			
		

	





	

		

			

				
					
C语言实现选择排序算法

				
			

			

				

					qq_58417838的博客
				

				

					11-14
					
					3147
					
				

			

		

		

			
				
选择排序算法

			
		

	





	

		

			

				
					
java实现七种经典排序算法

				
			

			

				

					诸葛浪
				

				

					07-29
					
					4012
					
				

			

		

		

			
				
七种常见排序算法java代码及图示，所有代码均可单独独立运行

			
		

	





	

		

			

				
					
java十大排序算法实现

				
			

			

				

					11-20
				

			

		

		

			
				
java十大排序算法实现 1. 冒泡排序（Bubble Sort） 2. 选择排序（Selection Sort） 3. 插入排序（Insertion Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6. 堆排序（Heap Sort） 7. 计数排序...

			
		

	





	

		

			

				
					
matlab排序算法实现-合并排序、简单选择排序、快速排序、冒泡排序、直接插入排序

					
最新发布

				
			

			

				

					08-30
				

			

		

		

			
				
将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。...本资源通过matlab实现合并排序、简单选择排序、快速排序、冒泡排序、直接插入排序5种常用的排序算法，并部分绘制代表算法原理的动图。

			
		

	





	

		

			

				
					
Java排序算法实现

				
			

			

				

					03-06
				

			

		

		

			
				
Java排序算法实现 Java排序算法实现 Java排序算法实现

			
		

	





	

		

			

				
					
二进制，八进制，十进制，十六进制互相转化的C语言源代码

				
			

			

				

					zqt520的专栏
				

				

					09-23
					
					2万+
					
				

			

		

		

			
				
#include
#include
#include
void D_B(int);
void D_O(int);
void D_X(int);
void B_D(int);
void B_O(int);
void B_X(int);
void O_B(int);
void O_D(int);
void O_X(int);
void X_B(char r[],int k);
void X_D(cha

			
		

	





	

		

			

				
					
华为下午编程大赛题目（C/C++） 2012

				
			

			

				

					zqt520的专栏
				

				

					04-23
					
					6699
					
				

			

		

		

			
				
1.扑克问题问题描述：
在扑克中，牌的类型包括：A(1),2,3,4,5,6,7,8,9,T(10),J(11),Q(12),K(13),D（小鬼devilkin），B(大鬼Belial）。
请做一个简单的程序，输入两张牌的字符，比如"2"和"K"，判断牌的大小，规则如下：
B>D>2>A>K>Q>J>10....>3 最小的为3
判断规则：比较cFirstCard和cSecondCard，如果F

			
		

	





	

		

			

				
					
算法实现——X和Y的中位数问题

				
			

			

				

					zqt520的专栏
				

				

					04-10
					
					3476
					
				

			

		

		

			
				
问题描述：
设X[0:n-1]和Y[0:n-1]为2 个数组,每个数组中含有n 个已排好序的数。试设计一个
O(log n)时间的算法,找出X和Y 的2n个数的中位数。
例如，当n=7，X=[1，3，6，7，8，9，10]；Y=[2，4，5，11，12，13，14]时，X 和Y
的中位数是7。
«算法设计：
对于给定的n 个元素的数组X[0:n-1]和Y[0:n-1]，试设计一个O(log n)时

			
		

	





	

		

			

				
					
华为编程大赛2012

				
			

			

				

					zqt520的专栏
				

				

					04-22
					
					3414
					
				

			

		

		

			
				
华为编程大赛高级下午4-6点场









纯交流

1、比较两个扑克牌大小，这个很简单就是把A J Q K 大小王 10 对应的字符赋值成数字，然后数字比较就可以

2、干瞪眼。先判断特殊情况，因为输入符合规范，所以
（0）A=B无论什么情况返回平局
（1）A BB /AA B这种情况不满足题意，无法比较
（2）AAA/AA|B AA|A/BBB，也就是一

			
		

	





	

		

			

				
					
七大排序算法实现详解及示例

				
			

			

				

					
				

			

		

		

			
				
以下是对7种排序算法实现的详细说明：  1. **冒泡排序**：冒泡排序是一种简单的排序方法，通过不断交换相邻的逆序元素来逐步排序。这里提供了两种版本：  - **BubbleSort1**：这是一个基本的冒泡排序实现，它遍历数...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值