排序综合

冒泡排序：

设数组长度为N，

1、比较相邻前后两个数据，数组为[0，N-1]，则要比较N-1次

2、循环一次后，最大或者最小的数在数组最后面，这样比较数组[0，N-2]，重复上述步骤即可

综上其就是两个for循环

第一个for循环表示：要排序的数值个数-1

第二个for循环表示：将无序数组进行排序，即比较相邻的两个数值

以下为代码：

// sort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


void Swap(int &a, int &b)
{
   int temp = a;
   a = b;
   b = temp;
}

void BubbleSort1(int a[], int n)
{
	int i,j;

	for (i = 0; i < n - 1; i++)
	{
		for (j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j+1])
			{
				Swap(a[j], a[j+1]);
			}
		}
	}

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

//改进
void BubbleSort2(int a[], int n)
{
	int i, j = n - 1;
	bool flag = true;            //设置标志，如果这一趟发生交换，则为true，否则为false

	while(flag)
	{
		flag = false;
		for(i = 0; i < j; i++)
			if (a[i] > a[i+1])
			{
				Swap(a[i], a[i+1]);;
				flag = true;
			}
		j--;
	}
	
	for (int i = 0; i < n; i++)
	{
		printf("%d\t", a[i]);
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

	BubbleSort2(score, 8);

	return 0;
}

直接插入排序：

设数组为a[0，n-1]；

1、取i = 1,2......n-1，每设置一次i的值，即将数组a[0，i-1]进行排序。

2、这样a[0，n-1]可以分为两个部分，a[0，i-1]为排好序的，而a[i，n-1]为无序。

3、i++直到n-1，即1步骤，即可。

以下是代码：

void InsertSort1(int a[], int n)
{
	int i,j,k;
	for (i = 1; i < n; i++)  //将下标1到n-1进行直接插入排序
	{
		for (j = i-1; j >=0; j--)  //当下标为i时，将a[i]排在a[0，i-1]上
		{
			if(a[j] < a[i])
				break;
		}

		if ( j != i-1 )          //如果j不在i的前一位，即表示将a[i]查到a[0，i-1]之间
		{
			int temp = a[i];
			for(k = i - 1; k > j; k--)
				a[k+1]=a[k];
			a[k+1] = temp;
		}
	}
}

//改进直接插入排序
void Insertsort2(int a[], int n)
{
	int i,j;
	for (i = 1; i < n; i++)
		if (a[i] < a[i-1])
		{
			int temp = a[i];
			for (j = i - 1; j >= 0 && a[j] > temp; j--)
			{
				a[j+1] = a[j];
			}
			a[j+1] = temp;
		}
	
	
}

希尔排序：

1、将无序数组分割成若干个子序列，子序列的长度（gap = n/2）是相隔特定的增量子序列，将各子序列进行直接插入排序；

2、在排序一次后，将数组再次分割若干子序列，子序列的长度（gap /= 2）是相隔特定的增量子序列，将各子序列进行直接插入排序；

3、重复上述过程，直到gap = 0时，数组排序完成。

以下为代码：

void shellSort1(int a[], int n)
{
	int i,j,gap; //gap为步长
	for (gap = n/2; gap > 0; gap /= 2) // 设置步长
		for (i = 0; i < gap; i++)      //按组排序
		{
			for (j = i + gap; j < n; j += gap)
			{
				if (a[j] < a[j-gap])  //如果后面的比前面的小
				{
					int temp = a[j];
					int k = j-gap;

					while (k >= 0 && a[k] > temp)
					{
						a[k+gap] = a[k];
						k -= gap;
					}
					a[k+gap] = temp;
				}
			}
		}

}

//改进希尔排序
void shellSort2(int a[], int n)
{
	int j,gap;
	for(gap = n/2; gap > 0; gap /= 2)
		for(j = gap; j < n; j++)   //从数组第gap个元素开始
			if (a[j] < a[j-gap])
			{
				int temp = a[j];
				int k = j-gap;

				while (k >= 0 && a[k] > temp)
				{
					a[k + gap] = a[k];
					k -= gap;
				}

				a[k+gap] = temp;
			}

}

归并排序：

先分，在组合，这里是递归算法

代码如下：

void mergeArray(int a[], int first, int mid, int last, int temp[])
{
	int i = first, j = mid + 1, k = 0;
	int m = mid, n = last;

	while (i <= m && j <= n)
	{
		if(a[i] < a[j])
			temp[k++] = a[i++];
		else
			temp[k++] = a[j++];
	}

	while(i <= m)
		temp[k++] = a[i++];

	while(j <= n)
		temp[k++] = a[j++];

	for (i = 0; i < k; i++)
	{
		a[first + i] = temp[i];

	}
}


void mergesort(int a[], int first, int last, int temp[])
{
	if (first < last)
	{
		int mid = (first + last)/2;
		mergesort(a, first, mid, temp);
		mergesort(a, mid + 1, last, temp);
		mergeArray(a, first, mid, last, temp);
	}
}

bool MergeSort(int a[], int n)
{
	int* pTempArray = new int[n];
	if(pTempArray == NULL)
		return false;
	mergesort(a, 0, n-1, pTempArray);
	delete[] pTempArray;
	return true;


}

快速排序：

1、在数组取一个数作为基数

2、在L在往前查找比基数小的数，然后将此坑与基数的坑对换。

3、在R往后查找比基数大的数，然后将此坑与基数的坑对换。

4、知道LR相等时，将基数放置在L或者R处。

以下为代码：

void quickSort(int a[], int L, int R)
{
	if( L < R )
	{
		int 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);
	}
}

---------------------------------------------------------------------------

java实现：

package com.example.sorts;

public class sorts {
	
	//冒泡排序
	public static void bubbleSort(int[] arr){
		int i, j;
		int len = arr.length;
		int temp;
		for(i = 0; i < len - 1; i++)
			for(j = 0; j < len - 1 - i; j++){
				if(arr[j] > arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
	}
	
	//直接插入排序
	public static void insertSort(int[] arr){
		int i, j;
		int len = arr.length;
		int temp;
		for(i = 1; i < len; i++)
			if(arr[i] < arr[i-1]){
				temp = arr[i];
				for(j = i - 1; j >= 0 && arr[j] > temp; j--)
					arr[j+1] = arr[j];
				arr[j+1] = temp;	
			}
	}
	
	//希尔排序
	public static void shellSort(int[] arr){
		int i, j;
		int gap; //间隔
		int len = arr.length;
		int temp;
		for(gap = len/2; gap > 0; gap /= 2)
			for(i = gap; i < len; i++)
				if(arr[i] < arr[i-gap]){
					temp = arr[i];
					for(j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
						arr[j+gap] = arr[j];
					arr[j+gap] = temp;
				}
	}
	
	//直接选择排序
	public static void selectSort(int[] arr){
		int i, j;
		int len = arr.length;
		int temp;
		int nMinIndex;
		for(i = 0; i < len; i++){
			nMinIndex = i;
			for(j = i + 1 ; j < len ; j++)
				if(arr[nMinIndex] > arr[j])
					nMinIndex = j;
			temp = arr[nMinIndex];
			arr[nMinIndex] = arr[i];
			arr[i] = temp;
		}
	}
	
	
	//归并排序
	public static void mergeSort(int[] arr, int low, int high){
		int mid = (low + high)/2;
		if(low < high){
		mergeSort(arr, low, mid);
		mergeSort(arr, mid+1, high);
		merge(arr, low, mid, high);
		}
	}
	
	public static void merge(int[] arr, int low, int mid, int high){
		int[] temp = new int[high-low+1];
		int i = low;  //数组1的起始点
		int j = mid+1; //数组2的起始点
		int k = 0;
		
		while(i <= mid && j <= high){
			if(arr[i] < arr[j]){
				temp[k++] = arr[i++];
			}else{
				temp[k++] = arr[j++];
			}
		}
		
		while(i <= mid){
			temp[k++] = arr[i++];
		}
		
		while(j <= high){
			temp[k++] = arr[j++];
		}
		
		for(int m = 0; m < temp.length; m++)
			arr[low+m] = temp[m];
	}
	
	//快速排序
	public static void quickSort(int[] arr, int L, int R){
		if(L < R){
			int i = L, j = R;
			//选定基数
			int x = arr[i];
			while(i < j){
				
				while(i < j && arr[j] >= x)
					j--;
				if(i < j)
					arr[i++] = arr[j];
				
				while(i < j && arr[i] < x)
					i++;
				if(i < j)
					arr[j--] = arr[i];	
			}
			arr[i] = x;
			quickSort(arr, L, i-1);
			quickSort(arr, i+1, R);
		}
	}
	
	//堆排序
	
	public static void MinHeapSort(int[] arr, int n){
        int temp;
		//建立最小堆
		MakeMinHeap(arr, n);
		for(int i = n - 1; i >= 0; i--){
			temp = arr[i];
			arr[i] = arr[0];
			arr[0] = temp;
			MinHeapFixdown(arr, 0, i);
		}
	}
	
	public static void MinHeapFixdown(int[] arr, int i, int n){  //i表示节点，n表示节点数
		int j; //子节点
		int temp = arr[i];//将父节点值保存到temp
		j = 2*i + 1;
		
		while(j < n){
			if(j + 1 < n && arr[j+1] < arr[j])
				j++;
			if(temp <= arr[j])
				break;
			arr[i] = arr[j];
			i = j;    //将子节点设置为父节点
			j = 2*i + 1; //得到父节点的子节点
		}
		arr[i] = temp;
	}
	//建立最小堆
	public static void MakeMinHeap(int[] arr, int n){
		for(int i = n/2 - 1; i >= 0; i--)
			MinHeapFixdown(arr, i, n);
	}
	
	public static void main(String[] args){

		int[] arrI = {9, 12, 17, 30, 50, 20, 60, 65, 4, 49};
		MinHeapSort(arrI, 10);
		
		for(int k : arrI)
			System.out.print(k+" ");
	}

}