Chapter 9 (排序)

1.排序算法：

//****************************Sort.h********************************************
#ifndef SORT_H
#define SORT_H

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

//冒泡排序
void BubbleSort(int data[],int len);

//简单选择排序
void SelectSort(int data[],int len);

//直接插入排序
void InsertSort(int data[],int len);

//希尔排序
void ShellSort(int data[],int len);

//堆排序
void HeapSort(int data[],int len);

//归并排序
void MergeSort(int data[],int len);

//快速排序
void QuickSort(int data[],int len);

#endif  //SORT_H

//****************************Sort.c********************************************
#include "Sort.h"

void swap(int a[],int i,int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

//冒泡排序
void BubbleSort(int data[],int len)
{
	int i,j;
	bool flag;
	for(i=0;i < len-1;i++)
	{
		flag = false;
		for(j = len-1;j >i;j--)
		{
			if(data[j] < data[j-1])
			{
				swap(data,j,j-1);
			}

		}
		if(!flag) //标志位未被置位，序列已经有序
		{
			break;
		}
	}
}

//简单选择排序
void SelectSort(int data[],int len)
{
	int i,j,min;
	for(i=0;i < len;i++)
	{
		min = i;
		for(j=i+1;j < len;j++)
		{
			if(data[j] < data[min])
			{
				min = j;
			}
		}
		if(min != i)

		{
			swap(data,i,min);
		}
	}

}

//直接插入排序
void InsertSort(int data[],int len)
{
	int i,j;

	for(i=1;i < len;i++)
	{
		if(data[i] < data[i-1])
		{
			int tmp = data[i];
			for(j= i-1;j >= 0 && data[j] > tmp;j--)
			{
				data[j+1] = data[j];
			}
			data[j+1] = tmp;
		}

	}
}

//希尔排序
void ShellSort(int data[],int len)
{
	int increment = len;
	int i,j;

	do
	{
		increment = increment/3+1;

		for(i=increment+1;i < len;i++)
		{
			if(data[i] < data[i-increment])
			{
				int tmp = data[i];

				for(j= i-increment;j >= 0 && data[j] > tmp ;j-=increment)
				{
					data[j+increment] = data[j];
				}
				data[j+increment] = tmp;
			}
		}

	}
	while(increment>1);
}

void HeapAdjust(int data[],int s,int m)
{
	int i,tmp;
	tmp = data[s];
	for(i=2*s;i <= m;i*=2)
	{
		if(i<m && data[i] < data[i+1])
		{
			++i;
		}

		if(tmp >= data[i])
		{
			break;
		}
		data[s] = data[i];
		s = i;
	}
	data[s] = tmp;
}

//堆排序
void HeapSort(int data[],int len)
{
	int i;
	for(i=len/2;i >= 0;i--)
	{
		HeapAdjust(data,i,len-1);
	}

	for(i=len-1;i > 0;i--)
	{
		swap(data,0,i);
		HeapAdjust(data,0,i-1);
	}
}

void Merge(int data[],int tmp[],int s,int m,int t)
{
	int j,k,l;

	for(j=m+1,k=s;j<=t && s<=m;k++)
	{
		if(data[s] < data[j])
		{
			tmp[k] = data[s++];
		}
		else
		{
			tmp[k] = data[j++];
		}
	}
	if(s <= m)
	{
		for(l=0;l <= m-s;l++)
		{
			tmp[k+l] = data[s+l];
		}
	}

	if(j <= t)
	{
		for(l=0;l <= t-j;l++)
		{
			tmp[k+l] = data[j+l];
		}
	}
}

void MSort(int data[],int tmp[],int s,int t)
{
	int tmp1[1000];
	int m;
	if(s == t)
	{
		tmp[s] = data[s];
	}
	else
	{
		m = (s+t)/2;
		MSort(data,tmp1,s,m);
		MSort(data,tmp1,m+1,t);
		Merge(tmp1,tmp,s,m,t);
	}
}
//归并排序
void MergeSort(int data[],int len)
{
	MSort(data,data,0,len-1);
}

int Partition(int data[],int low,int high)
{
	int key = data[low];

	while(low < high)
	{
		while(low<high && data[high] > key)
		{
			high--;
		}
		data[low] = data[high];

		while(low <high && data[low] < key)
		{
			low++;
		}
		data[high] = data[low];
	}
	data[low] = key;
	return low;
}

void QSort(int data[],int low,int high)
{
	int pivot;

	if(low <high)
	{
		pivot = Partition(data,low,high);
		QSort(data,low,pivot-1);
		QSort(data,pivot+1,high);
	}
}

//快速排序
void QuickSort(int data[],int len)
{
	QSort(data,0,len-1);
}

//****************************SortTest.c********************************************
#include "Sort.h"

void travel(int a[],int n)
{
	for(int i=0;i < n;i++)
	{
		printf("%d ",a[i]);
	}
	printf("\n");
}

int main()
{
	int a[] = {2,6,8,5,4,10,1,3,7,9};
	travel(a,10);

	//冒泡排序
	//BubbleSort(a,10);

	//简单选择排序
	//SelectSort(a,10);

	//直接插入排序
	//InsertSort(a,10);

	//希尔排序
	//ShellSort(a,10);

	//堆排序
	//HeapSort(a,10);

	//归并排序
	//MergeSort(a,10);

	//快速排序
	QuickSort(a,10);
	travel(a,10);
}
x

273

1

//****************************Sort.h********************************************

2

#ifndef SORT_H

3

#define SORT_H

4



5


#include <stdio.h>


6


#include <stdlib.h>


7


#include <stdbool.h>


8




9


//冒泡排序


10


void BubbleSort(int data[],int len);


11




12


//简单选择排序


13


void SelectSort(int data[],int len);


14




15


//直接插入排序


16


void InsertSort(int data[],int len);


17




18


//希尔排序


19


void ShellSort(int data[],int len);


20




21


//堆排序


22


void HeapSort(int data[],int len);


23




24


//归并排序


25


void MergeSort(int data[],int len);


26




27


//快速排序


28


void QuickSort(int data[],int len);


29




30




31


#endif  //SORT_H


32




33




34


//****************************Sort.c********************************************


35


#include "Sort.h"


36




37


void swap(int a[],int i,int j)


38


{


39


    int tmp = a[i];


40


    a[i] = a[j];


41


    a[j] = tmp;


42


}


43




44


//冒泡排序


45


void BubbleSort(int data[],int len)


46


{


47


    int i,j;


48


    bool flag;


49


    for(i=0;i < len-1;i++)


50


    {


51


        flag = false;


52


        for(j = len-1;j >i;j--)


53


        {


54


            if(data[j] < data[j-1])


55


            {


56


                swap(data,j,j-1);


57


            }


58




59


        }


60


        if(!flag) //标志位未被置位，序列已经有序


61


        {


62


            break;


63


        }


64


    }


65


}


66




67


//简单选择排序


68


void SelectSort(int data[],int len)


69


{


70


    int i,j,min;


71


    for(i=0;i < len;i++)


72


    {


73


        min = i;


74


        for(j=i+1;j < len;j++)


75


        {


76


            if(data[j] < data[min])


77


            {


78


                min = j;


79


            }


80


        }


81


        if(min != i)


82


        


83


        {


84


            swap(data,i,min);


85


        }


86


    }


87




88


}


89




90


//直接插入排序


91


void InsertSort(int data[],int len)


92


{


93


    int i,j;


94




95


    for(i=1;i < len;i++)


96


    {


97


        if(data[i] < data[i-1])


98


        {


99


            int tmp = data[i];


100


            for(j= i-1;j >= 0 && data[j] > tmp;j--)


101


            {


102


                data[j+1] = data[j];


103


            }


104


            data[j+1] = tmp;


105


        }


106


    


107


    }


108


}


109




110


//希尔排序


111


void ShellSort(int data[],int len)


112


{


113


    int increment = len;


114


    int i,j;


115


    


116


    do


117


    {


118


        increment = increment/3+1;


119


        


120


        for(i=increment+1;i < len;i++)


121


        {


122


            if(data[i] < data[i-increment])


123


            {


124


                int tmp = data[i];


125


                


126


                for(j= i-increment;j >= 0 && data[j] > tmp ;j-=increment)


127


                {


128


                    data[j+increment] = data[j];


129


                }


130


                data[j+increment] = tmp;


131


            }


132


        }


133


    


134


    }


135


    while(increment>1);


136


}


137




138


void HeapAdjust(int data[],int s,int m)


139


{


140


    int i,tmp;


141


    tmp = data[s];


142


    for(i=2*s;i <= m;i*=2)


143


    {


144


        if(i<m && data[i] < data[i+1])


145


        {


146


            ++i;


147


        }


148




149


        if(tmp >= data[i])


150


        {


151


            break;


152


        }


153


        data[s] = data[i];


154


        s = i;


155


    }


156


    data[s] = tmp;


157


}


158




159




160


//堆排序


161


void HeapSort(int data[],int len)


162


{


163


    int i;


164


    for(i=len/2;i >= 0;i--)


165


    {


166


        HeapAdjust(data,i,len-1);


167


    }


168


    


169


    


170


    for(i=len-1;i > 0;i--)


171


    {


172


        swap(data,0,i);


173


        HeapAdjust(data,0,i-1);


174


    }


175


}


176




177




178


void Merge(int data[],int tmp[],int s,int m,int t)


179


{


180


    int j,k,l;


181




182


    for(j=m+1,k=s;j<=t && s<=m;k++)


183


    {


184


        if(data[s] < data[j])


185


        {


186


            tmp[k] = data[s++];


187


        }


188


        else


189


        {


190


            tmp[k] = data[j++];


191


        }


192


    }


193


    if(s <= m)


194


    {


195


        for(l=0;l <= m-s;l++)


196


        {


197


            tmp[k+l] = data[s+l];


198


        }


199


    }


200




201


    if(j <= t)


202


    {


203


        for(l=0;l <= t-j;l++)


204


        {


205


            tmp[k+l] = data[j+l];


206


        }


207


    }


208


}


209




210


void MSort(int data[],int tmp[],int s,int t)


211


{


212


    int tmp1[1000];


213


    int m;


214


    if(s == t)


215


    {


216


        tmp[s] = data[s];


217


    }


218


    else


219


    {


220


        m = (s+t)/2;


221


        MSort(data,tmp1,s,m);


222


        MSort(data,tmp1,m+1,t);


223


        Merge(tmp1,tmp,s,m,t);


224


    }


225


}


226


//归并排序


227


void MergeSort(int data[],int len)


228


{


229


    MSort(data,data,0,len-1);


230


}


231




232




233


int Partition(int data[],int low,int high)


234


{


235


    int key = data[low];


236




237


    while(low < high)


238


    {   


239


        while(low<high && data[high] > key)


240


        {


241


            high--;


242


        }


243


        data[low] = data[high];


244




245


        while(low <high && data[low] < key)


246


        {


247


            low++;


248


        }


249


        data[high] = data[low];


250


    }


251


    data[low] = key;


252


    return low;


253


}


254




255


void QSort(int data[],int low,int high)


256


{


257


    int pivot;


258




259


    if(low <high)


260


    {


261


        pivot = Partition(data,low,high);


262


        QSort(data,low,pivot-1);


263


        QSort(data,pivot+1,high);


264


    }


265


}


266




267


//快速排序


268


void QuickSort(int data[],int len)


269


{


270


    QSort(data,0,len-1);


271


}


272




273


//****************************SortTest.c********************************************


274


#include "Sort.h"


275




276


void travel(int a[],int n)


277


{


278


    for(int i=0;i < n;i++)


279


    {


280


        printf("%d ",a[i]);


281


    }


282


    printf("\n");


283


}


284




285


int main()


286


{


287


    int a[] = {2,6,8,5,4,10,1,3,7,9};


288


    travel(a,10);


289




290


    //冒泡排序


291


    //BubbleSort(a,10);


292


    


293


    //简单选择排序


294


    //SelectSort(a,10);


295




296




297


    //直接插入排序


298


    //InsertSort(a,10);


299


    


300


    //希尔排序


301


    //ShellSort(a,10);


302




303


    //堆排序


304


    //HeapSort(a,10);


305


    


306


    //归并排序


307


    //MergeSort(a,10);


308


    


309




310


    //快速排序


311


    QuickSort(a,10);


312


    travel(a,10);


313


}


附件列表




原文地址：https://www.cnblogs.com/LyndonMario/p/9326372.html
				


				
时间： 2024-11-05 16:26:11 

		


		


	

	
	

		


		
Chapter 9 (排序)的相关文章


						

		

			

                chapter 15  排序
			

		

		

									

				几种排序方法:冒泡 希尔  插入  快排  堆排  归并 sort.h #ifndef _SORT_H_ #define _SORT_H_ void insert_sort(int*, int); void bubble_sort(int*, int); void shell_sort(int *, int); void quick_sort(int*, int, int); void heap_sort(int*, int); void merge_sort(int *, int *, int			

		

	

						

		

			

                《算法导论》 — Chapter 7 高速排序
			

		

		

									

				序 高速排序(QuickSort)也是一种排序算法,对包括n个数组的输入数组.最坏情况执行时间为O(n^2). 尽管这个最坏情况执行时间比較差.可是高速排序一般是用于排序的最佳有用选择.这是由于其平均性能相当好.期望的执行时间为O(nlgn).且O(nlgn)中隐含的常数因子非常小.另外它还能够进行就地排序在虚拟环境中也能非常好的工作. GitHub chapter 7 程序代码下载 原理 高速排序也和合并排序一样,基于分治法,分为分解.解决.合并三个步骤. 分解:数组array[low-hig			

		

	

				

		

			

                UVA - 10305 - Ordering Tasks    （拓扑排序！）
			

		

		

									

				UVA - 10305 Ordering Tasks Time Limit: 3000MS Memory Limit: Unknown 64bit IO Format: %lld & %llu Submit Status Description Problem F Ordering Tasks Input: standard input Output: standard output Time Limit: 1 second Memory Limit: 32 MB John has n task			

		

	

				

		

			

                排序算法可视化
			

		

		

									

				参考1)  <Algorithms_4th> chapter 2 sorting 参考2)   Sorting algorithms, wiki 1  selection sort 选择排序 首先,整个序列一次比较,选择最小值,置于第一位: 然后,剩余序列再次比较,选择最小值,置于第二位; 以此类推. Java 实例: public class Selection { public static void sort(Comparable[] a) { // Sort a[] into incr			

		

	

				

		

			

                UVA - 10905 - Children&#39;s Game     （简单排序）
			

		

		

									

				UVA - 10905 Children's Game Time Limit: 3000MS   Memory Limit: Unknown   64bit IO Format: %lld & %llu Submit Status Description 4thIIUCInter-University Programming Contest, 2005 A Children's Game Input: standard input Output: standard output Problems			

		

	

				

		

			

                算法——计数排序与快速排序
			

		

		

									

				计数排序是一种算法复杂度 O(n) 的排序方法,适合于小范围集合的排序.比如100万学生参加高考,我们想对这100万学生的数学成绩(假设分数为0到100)做个排序.我们如何设计一个 最高效的排序算法.本文不光给出计数排序算法的传统写法,还将一步步深入讨论算法的优化,直到时间复杂度和空间复杂度最优. 先看看计数排序的定义 Counting sort (sometimes referred to as ultra sort or math sort[1]) is a sorting algorith			

		

	

				

		

			

                Chapter five Depth First Search（深度优先搜索）
			

		

		

									

				组合搜索问题 Combination 问题模型:求出所有满足条件的"组合".判断条件:组合中的元素是顺序无关的.时间复杂度:与 2^n 相关. 1.Chapter one 第2题 subsets(子集) 2.Chapter one 第3题 subsets-ii(子集II) 3.combination-sum(数字组合) 给出一组候选数字(C)和目标数字(T),找到C中所有的组合,使找出的数字和为T.C中的数字可以无限制重复被选取.所有的数字(包括目标数字)均为正整数.元素组合(a1, 			

		

	

				

		

			

                Chapter 1 Securing Your Server and Network(8):停止未使用的服务
			

		

		

									

				原文出处:http://blog.csdn.net/dba_huangzj/article/details/38263043,专题目录:http://blog.csdn.net/dba_huangzj/article/details/37906349 未经作者同意,任何人不得以"原创"形式发布,也不得已用于商业用途,本人不负责任何法律责任. 前一篇:http://blog.csdn.net/dba_huangzj/article/details/38227187 前言: 如果完全安装S			

		

	

				

		

			

                菜鸟笔记 -- Chapter 3.1 计算机的基础
			

		

		

									

				3.1 计算机的基础知识 每次想写些什么的时候,发现总是避不过计算机这块,在菜鸟笔记 Chapter 1 计算机从0讲起简单介绍一下计算机硬件,以后计划在线程和并发中详细介绍一下计算机的运行原理.这里我们还是先简单介绍一下计算机. 3.1.1 计算机 计算机(Computer)全称:电子计算机,俗称电脑.是一种能够按照程序运行,自动.高速处理海量数据的现代化智能电子设备.由硬件和软件所组成,没有安装任何软件的计算机称为裸机.常见的形式有台式计算机.笔记本计算机.大型计算机等. 计算机的应用已渗透