基本排序算法程序实现

简单算法O(n^2):冒泡法<简单选择排序<直接插入排序(性能比较)

改进算法:希尔排序、堆排序、归并排序、快速排序

数组交换语句swap()

1 void swap(int* sortList,int intA,int intB)
2 {
3     int a=sortList[intA];
4     sortList[intA]=sortList[intB];
5     sortList[intB]=a;
6 }

冒泡法(改进)

void BubbleSort(int* sortList,int len)
{
	bool isOrder=false; //哨兵
	for(int i=0;(i<len-1)&&!isOrder;i++)
	{
		isOrder=true;
		for(int j=len-1;j>=i;j--)
		{
			if(sortList[j]<sortList[j-1])
			{
				swap(sortList,j,j-1);
				isOrder=false;
			}
		}
	}
}

简单选择排序

void SimpleSort(int* sortList, int len)
{
	int minIndex;
	for(int i=0;i<len;i++)
	{
		minIndex=i;
		for(int j=i+1;j<len;j++)
		{
			if(sortList[i]>sortList[j])
				minIndex=j;
		}
		if(minIndex!=i)
			swap(sortList,i,minIndex);
	}
}

直接插入排序

 1 void DirectInsertionSort(int* sortList,int len)
 2 {
 3     int tempInt;
 4     for(int i=1;i<len;i++)
 5     {
 6         if(sortList[i]>sortList[i-1])continue;
 7
 8         tempInt=sortList[i];
 9         int j;
10         for(j=i-1;sortList[j]>tempInt&&j>=0;j--)
11         {
12             sortList[j+1]=sortList[j];
13         }
14
15         sortList[j+1]=tempInt;
16     }
17 }

改进算法

希尔排序

 1 void ShellSort(int* sortList,int len)
 2 {
 3     int g=len;
 4     do
 5     {
 6         g=g/3+1;
 7         for(int i=0;i<g;i++)
 8         {
 9             for(int j=i+g;j<len;j+=g)
10             {
11                 if(sortList[j]<sortList[j-g])
12                 {
13                     int temp=sortList[j];
14                     int k=j-g;
15                     while(sortList[k]>temp&&k>=0)
16                     {
17                         sortList[k+g]=sortList[k];
18                         k-=g;
19                     }
20                     sortList[k+g]=temp;
21                 }
22             }
23         }
24     }while(g>1);
25 }

堆排序(注意数组从1开始)

 1 void HeapSort(int* sortList,int len)
 2 {
 3
 4     for(int j=len/2;j>0;j--)
 5     {
 6         HeapAdjust(sortList,j,len);
 7     }
 8
 9     for(int fn=len;fn>1;fn--)
10     {
11         swap(sortList,1,fn);
12         HeapAdjust(sortList,1,fn-1);
13     }
14 }
15
16 void HeapAdjust(int* sortList,int r,int k)
17 {
18     int temp,j;
19     temp=sortList[r];
20     for(j=2*r;j<=k;j=j*2)
21     {
22         if(j<k&&sortList[j]<sortList[j+1])
23             j++;
24         if(temp>=sortList[j])
25             break;
26         sortList[r]=sortList[j];
27         r=j;
28     }
29     sortList[r]=temp;
30 }

归并排序

递归思想

 1 const int MAXSIZE=10000;
 2
 3 void MergeSort(int* sortList,int len)
 4 {
 5     MSort(sortList,sortList,0,len-1);
 6 }
 7
 8 void MSort(int* SR,int* TR,int st,int fn)
 9 {
10     int* TR2=new int[MAXSIZE];
11     int mid;
12     if(st==fn)
13     {
14         TR[st]=SR[st];
15     }
16     else
17     {
18         mid=(st+fn)/2;
19         MSort(SR,TR2,st,mid);
20         MSort(SR,TR2,mid+1,fn);
21         Merge(TR2,TR,st,mid,fn);
22     }
23     delete[] TR2;
24 }
25
26 void Merge(int* TR2,int* TR,int st,int mid,int fn)
27 {
28   int index,s1,s2;
29   index=st;
30   for(s1=st,s2=mid+1;s1<=mid&&s2<=fn;index++)
31   {
32       if(TR2[s1]<TR2[s2])
33       {
34           TR[index]=TR2[s1++];
35       }
36       else
37       {
38           TR[index]=TR2[s2++];
39       }
40   }
41
42   if(s1<=mid)
43       for(s1;s1<=mid;s1++)
44           TR[index++]=TR2[s1];
45
46   if(s2<=fn)
47       for(s2;s2<=fn;s2++)
48           TR[index++]=TR2[s2];
49 }

快速排序

 1 void QuitSort(int* sortList,int len)
 2 {
 3     QSort(sortList,0,len-1);
 4 }
 5
 6 void QSort(int* sortList,int low,int high)
 7 {
 8     int pivot;
 9     if(low<high)
10     {
11         pivot=Partition(sortList,low,high);
12         QSort(sortList,low,pivot-1);
13         QSort(sortList,pivot+1,high);
14     }
15 }
16
17 int Partition(int* sortList,int low,int high)
18 {
19     int pivot=sortList[low];
20     while(low<high)
21     {
22         while(high>low&&sortList[high]>=pivot)
23             high--;
24         swap(sortList,low,high);
25         while(high>low&&sortList[low]<=pivot)
26             low++;
27         swap(sortList,low,high);
28     }
29     return low;
30 }
时间: 2024-07-29 08:41:42

基本排序算法程序实现的相关文章

数据结构基础 排序算法(一) 概念篇

本辑将会对笔试面试最常涉及到的12种排序算法(包括插入排序.二分插入排序.希尔排序.选择排序.冒泡排序.鸡尾酒排序.快速排序.堆排序.归并排序.桶排序.计数排序和基数排序)进行详解.每一种算法都有基本介绍.算法原理分析.图解演示.算法代码.笔试面试重点分析.笔试面试题等板块. 一.插入排序 1)算法简介 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常

12种排序算法:原理、图解、动画视频演示、代码以及笔试面试题目中的应用

出处:http://blog.csdn.net/han_xiaoyang/article/details/12163251. 声明:版权所有,转载请注明出处,谢谢. 0.前言 从这一部分开始直接切入我们计算机互联网笔试面试中的重头戏算法了,初始的想法是找一条主线,比如数据结构或者解题思路方法,将博主见过做过整理过的算法题逐个分析一遍(博主当年自己学算法就是用这种比较笨的刷题学的,囧),不过又想了想,算法这东西,博主自己学的过程中一直深感,基础还是非常重要的,很多难题是基础类数据结构和题目的思想综

13种排序算法详解

0.前言 从这一部分开始直接切入我们计算机互联网笔试面试中的重头戏算法了,初始的想法是找一条主线,比如数据结构或者解题思路方法,将博主见过做过整理过的算法题逐个分析一遍(博主当年自己学算法就是用这种比较笨的刷题学的,囧),不过又想了想,算法这东西,博主自己学的过程中一直深感,基础还是非常重要的,很多难题是基础类数据结构和题目的思想综合发散而来.比如说作为最基本的排序算法就种类很多,而事实上笔试面试过程中发现掌握的程度很一般,有很多题目,包括很多算法难题,其母题或者基本思想就是基于这些经典算法的,

【转】朱兆祺教你如何攻破C语言学习、笔试与机试的难点(连载)

原文网址:http://bbs.elecfans.com/jishu_354666_1_1.html 再过1个月又是一年应届毕业生应聘的高峰期了,为了方便应届毕业生应聘,笔者将大学四年C语言知识及去年本人C语言笔试难点进行梳理,希望能对今年应届毕业生的应聘有所帮助. 2013年10月18日更新-->    攻破C语言这个帖子更新到这里,我不仅仅是为了补充大学学生遗漏的知识,我更重要的是希望通过我的经验,你们实际项目中的C语言写得漂亮,写出属于你的风格.“朱兆祺STM32手记”(http://bb

算法复杂度,及三种主要排序算法的研究

一.时间复杂度 1.时间频度  T(n),n为问题的规模 即--算法中语句的执行次数.又叫语句频度. 2.时间复杂度 记作 O( f(n) ),这里的f(n)是一个T(n)的同数量级函数. 如O(1)表示算法的语句执行次数为一个常数,不随规模n的增长而增长: 又如T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同, 但时间复杂度相同,都为O(n^2). 3.算法的性能 主要用算法的 时间复杂度 的数量级来评价一个算法的时间性能. 二.空间复杂度 S(n),包括3方面: 1.算

面试常见算法-排序查找算法

算法是程序员必被的一个技能,在面试中常常出现,下面总结了面试中出现的常见算法,这些算法程序员应该牢记在心中,要非常熟练. 插入排序算法 原理:将数组分为无序区和有序区两个区,然后不断将无序区的第一个元素按大小顺序插入到有序区中去,最终将所有无序区元素都移动到有序区完成排序. 要点:设立哨兵,作为临时存储和判断数组边界之用. public class InsertSort { private static void insertSort(int[] a) { int j; int tmp; for

最易理解的qsort排序算法

快速排序算法程序可以写得千奇百怪,但最易理解的个人认为仍是下面的: #include<stdio.h> #include<time.h> #include<stdlib.h> void swap(int *a ,int *b) { int t = *a; *a = *b; *b = t; } int partition(int array[],int l,int r) { int pivot = array[r]; int curpos = l; int j ; for

内部排序之直接插入排序

1. 基本思想 将待排序记录Key=A[i+1]插入到已排序序列A[1…i]中.Key由后向前依次与A[1…i]中的元素进行比较,若A[x]<=Key,将Key插入到A[x]的后面,即A[x+1]=Key,否则将元素A[x]后移. S0:从无序序列A[n]的第一个元素A[1]开始,该元素可被认定已完成排序. S1:取出下一个元素并记录为Key,在已排序序列中倒序遍历. S2:若已排序序列中的元素A[x]<=Key,将Key插入到A[x]的后面,否则将元素A[x]后移. S3:重复步骤S2,直到

从插入排序到希尔排序

本博文主要是我以前写过的一些算法程序,里面主要从简单的插入排序到希尔排序说明. #include#include void shellSort(int *arr,int len); //在插入排序基础上进行修达到希尔排序void shellSortReal(int *arr,int len); //简化的希尔排序void insertSort(int *arr,int len); //原生态插入排序 int main(){ int arr[5]={36,13,37,12,78}; //shell