简述程序中各大排序

简述程序中各大排序

正所谓算法是程序设计的的灵魂。那数据结构就是编程的思维，编程的灵魂.
先说一下排序是什么,看图说话:

1、排序分为四大类：插入排序、交换排序、选择排序、归并排序。
根据稳定性排序:

根据记录所在位置:

入门排序:
冒泡排序:是在相邻的两个元素间进行两两比较，如果顺序相反则进行交换，知道所有元素有序排列的排序算法。

现在给大家一个来思考，给你10个质量不同的塑料小球，让你从轻到重依次分开，不用能用称重的方法解决，你能想到用什么办法吗？
(1) 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
(2) 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
(3) 针对所有的元素重复以上的步骤，除了最后一个。
(4) 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class SortDemo {
	public static void main(String[] args) {
		int[] arr = { 6, 2, 4, 1, 5, 9 };
		int t;
		int i, j; // i是外层循环 j是内层循环
		for (i = 1; i < 6; i++) {
			for (j = 0; j < 6 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					t = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = t;
				}
			}

		}
		for (int j2 = 0; j2 < arr.length; j2++) {
			System.out.print(j2+"\t");
		}
	}
}

简单选择排序:

插入排序:

直接插入法:

/* Note:Your choice is C IDE */
#include "stdio.h"
#define  N  8
void main()
{
   int i,j,tem,a[N]={ 13,6,3,31,9,27,5,11};
   for(i=1;i<N;i++){
   	tem=a[i];
   	if(tem<a[i-1]){
   		j=i-1;
   		while(tem<a[j]&&j>=0){
   			a[j+1]=a[j];
   			j--;
   		}
   		a[j+1]=tem;  		
   		}   	
   }
   for(i=0;i<N;i++){
   	printf("%d\t",a[i]);
   	}
}

希尔排序1:

/*
 希尔排序  缩小增量排序----->通俗的讲就是改进后的直接插入排序

增加了k  增量序列  分组的组数

k=MAX/2 增量k的值是越来越小

先分小组,分别对每个组内进行直接插入排序

然后在k=k/2 分组

直到组数为1截止  进行最终的一趟直接插入排序结束
 */
#include "stdio.h"
#define MAX 11
void main()
{
    int a[MAX]={6,3,8,1,7,4,9,12,52,54,2};
    int i;//控制循环趟数 以及 待排序元素的下标
    int j;//控制有序数组的下标
    int temp;//存放 待排序元素 temp数据类型 与数组类型一致
    int k;//增量 k代表把元素分为几组
     //希尔排序开始
    for(k=MAX/2;k>=1;k=k/2) // 缩小增量排序 继续分组  继续进行直接插入排序 
    {
    	//直接插入排序开始
    	for(i=k;i<MAX;i++)
    	{
    		 temp=a[i];//待排序元素
    		 if(temp<a[i-k])
    		 {   		 	
    		 	  for(j=i-k;a[j]>temp&&j>=0;j=j-k)//i-k有序数组最后一个元素的下标
    		 	  {
    		 	  	a[j+k]=a[j];
    		 	  }
    		 	  //当我们结束第二层for循环时候,结束时j=j-k
    		 	  a[j+k]=temp;    		 	
    		 }  		
    	}
    	//直接插入排序结束
    	   	
    }
    //希尔排序结束
     printf("希尔排序结果:\n");   
    for(i=0;i<MAX;i++)
    {
    	printf("%d\t",a[i]);
    }
}

希尔法2:

/* Note:Your choice is C IDE */
#include "stdio.h"
void main()
{
     int arr[]={1,12,41,4,5,7,14,18,16,17,54,47};
    int k,num,tem;
    int i,j;
    num=sizeof(arr)/sizeof(arr[0]);
    for(k=num/2;k>0;k/=2)
    {
    	for(i=k;i<num;i+=k)//6  3  1
    	{
    		tem=arr[i];
    		j=i-k;
    		while(tem<arr[j]&&j>0)
    		{
    			arr[j+k]=arr[j];
    			j=j-k;
    		}
    		arr[j+k]=tem;
    		
    	}    	
    }
    for(i=0;i<num;i++)
    {
    	printf("%d\t",arr[i]);
    	}
}

交换类排序:

快速排序:

/* Note:Your choice is C IDE */
#include "stdio.h"
int partition(int arr[],int start,int end)
{
	int key,tem,t;
	t=start;
	key=arr[start];
	while(start<end)
	{
		while(start<end&&arr[end]>key)//当临近结束时start在左
		{
			end--;
		}
	/*	arr[start]=arr[end];*/
		while(start<end&&arr[start]<=key)
		{
			start++;
		}
	/*	arr[end]=arr[start];*/                                                 
		tem=arr[start];
		arr[start]=arr[end];
		arr[end]=tem;
	}
	tem=arr[start];
	arr[start]=arr[t];
	arr[t]=tem;
	/*arr[start]=key;*/
	return start;
}
void quickSort(int arr[],int start,int end)
{
	int mid;
	if(start<end)
	{
		mid=partition(arr,start,end);
		quickSort(arr,start,mid-1);
		quickSort(arr,mid+1,end);
		}
}
void main()
{    
    int arr[]={5,45,1,4,2,3,6,9,8,7,44,7};
    int num,i;
    num=sizeof(arr)/sizeof(arr[0]);
    quickSort(arr,0,num-1);
    for(i=0;i<num;i++)
    {
    	printf("%d\t",arr[i]);
    	}
}

插入排序：直接插入排序 时间复杂度：O（n2） 稳定排序
希尔排序 时间复杂度：O（n3/2） 不稳定排序
交换排序：冒泡排序 时间复杂度：O（n2） 稳定排序
快速排序 时间复杂度：O（nlog2n） 不稳定排序
选择排序：简单选择排序 时间复杂度：O（n2） 不稳定排序

各种排序的特点总结：

1. 直接插入排序可能发生：在最后一趟排序开始之前，所有记录都不在最终位置上。
2. 不稳定排序都是存在不相邻元素之间的交换，快速排序、简单选择排序、希尔排序。
3. 冒泡排序（指改进后的）在一趟排序中若不存在记录交换说明已经有序，则停止排序。
   n个记录最少需要n-1次比较；最坏情况比较n*（n-1）/2。
4. 简单选择排序：比较次数与记录初始位置无关。