排序算法总结

[b]一张图表达排序算法的稳定性：[/b]



[b]关于希尔排序：[/b]

这是对直接插入排序的改进，按照直接插入排序来理解会很容易。

[b]关于堆排序：[/b]

首先个式子很重要：



我觉得研究堆排序，最直接的方法就是按层把树结构转化为数组。许多关于完全二叉树的算法这样想都会简单很多。





堆排序的算法就是：

构成大定队function（）

循环中:堆顶记录和最后一个交换function()

重新构成大顶堆function()

构建大顶堆过程就是从n/2开始，到1，每个都与其左右子节点相比较，找到比自己大的且最大的子节点并交换。因为是从树的，下到上，所以最后构建的是大顶堆。

总结：堆排序是不稳定的。

由于初始构建堆所需比较次数较多，所以它不需要带排序序列length比较小的情况。

完全二叉树的深度log(2)n + 1……最后得出其时间复杂度O(nlogn)

[b]归并排序：[/b]

归并排序在数学上还是用到了完全二叉树。O(nlogn)。归并排序是一种比较占内存但高效稳定的排序法。

[b]

[/b]

[b]关于快速排序：[/b]

如果用递归来做，很简单。就是不断找那个中枢，小于它的在一边，大于它的在一边。然后两边再分别找中枢。

快速排序的性能取决于递归树的深度。在最优情况下，是O（nlogn)(依然是完全二叉树的深度决定的)。最坏情况是O(n²)。平均情况O（nlogn)。数学归纳我也看不懂，先记住结论吧。

这个demo代码是去年写的。结构不好，测试代码和8个排序算法的function全部写在一起了。那几句测试用的代码其实写一遍就可以了，但去年的我写了8次。我的天。完全没有java该有的味道。懒于再重写了，这里重点是总结排序算法。实现代码什么的能看就行。

package day07;
import java.util.Arrays;
import java.util.Random;
public class SortDemo {
public static void main(String[] args) {
Random ran = new Random();
int[] arr = new int[10];
for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));

System.out.println("直接插入排序：");
InsertSort(arr,10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("二分排序：");
InsertSort2(arr,10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("希尔排序：");
ShellSort(arr,10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("简单选择排序：");
SelectSort(arr, 10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

int[] arr1 = new int[11];
for(int i = 1; i < arr1.length; i++)
{
arr1[i] = ran.nextInt(1000);
}
for(int i = 1; i <= 10; i++)
{
System.out.print(arr1[i] + "\t");
}
System.out.print("\n");
System.out.println("堆排序：");
HeapSort(arr1,10);
for(int i = 1; i <= 10; i++)
{
System.out.print(arr1[i] + "\t");
}
System.out.print("\n");
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("冒泡排序：");
BubbleSort(arr,10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("快速排序：");
QuickSort(arr,0,9);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");

for(int i = 0; i < arr.length; i++)
{
arr[i] = ran.nextInt(1000);
}
System.out.println(Arrays.toString(arr));
System.out.println("归并排序：");
MergeSort(arr,10);
System.out.println(Arrays.toString(arr));
System.out.println("**********************************");
}
/*******************************insert sort**************************/
public static void InsertSort(int[] R, int n)
{
int i,j,tmp;
for(i = 1; i < n; i++)
{
tmp = R[i];
j = i - 1;
while(j >=0 && tmp < R[j])
{
R[j + 1] = R[j];
j--;
}
R[j + 1] = tmp;
}
}

public static void InsertSort2(int[] R, int n)
{
int i,j;
int tmp;
int low,mid,high;
for(i = 1; i < n; i++)
{
low = 0;
high = i - 1;
tmp = R[i];
while(low <= high)
{
mid = (low + high)/2;
if(R[mid] < tmp)
low = mid + 1;
else
high = mid - 1;
}
for(j = i - 1; j >= high + 1; j--)
R[j + 1] = R[j];
R[high + 1] = tmp;
}
}
/*****************************shell sort*****************************/
public static void ShellSort(int R[], int n)
{
int i,j,tmp,d;
d = n / 2;
while(d > 0){
for(i = d; i < n; i++)
{
tmp  = R[i];
j = i - d;
while(j >= 0 && tmp < R[j])
{
R[j + d] = R[j];
j-=d;
}
R[j + d] = tmp;
}
d = d/2;
}
}
/******************************select sort****************************/
public static void SelectSort(int R[], int n)
{
int i, k, j, tmp;
for(i = 0; i < n - 1; i++)
{
k = i;
for(j = i + 1; j < n; j++)
{
if(R[k] > R[j] )
k = j;
}
if(k != i)
{
tmp = R[i];
R[i] = R[k];
R[k] = tmp;
}
}
}
/****************************Heap sort********************************/
public static void Sift(int R[], int low, int high)
{
int i = low;
int j = 2 * low;
int tmp = R[i];
while(j <= high)
{
if(j < high && R[j + 1] > R[j])
j++;
if(tmp < R[j])
{
R[i] = R[j];
i = j;
j = 2 * i;
}
else
break;
}
R[i] = tmp;
}

public static void HeapSort(int R[], int n)
{
int i,tmp;
for(i = n / 2; i >= 1; i--)
Sift(R, i, n);
for(i = n; i >= 2; i--)
{
tmp = R[1];
R[1] = R[i];
R[i] = tmp;
Sift(R, 1, i - 1);
}
}
/****************************bubble sort******************************/
public static void BubbleSort(int R[], int n)
{
int i,j,tmp;
for(i = 0; i < n - 1; i++)
{
for(j = 0; j < n - i - 1; j++)
{
if(R[j] > R[j + 1])
{
tmp = R[j];
R[j] = R[j + 1];
R[j + 1] = tmp;
}
}
}
}
/*****************************quick sort*****************************/
public static void QuickSort(int R[],int s, int t)
{
int i = s, j = t;
int tmp;
if(s < t)
{
tmp = R[s];
while(i != j)
{
while(j > i && R[j] > tmp)
j--;
R[i] = R[j];
while(j > i && R[i] < tmp)
i++;
R[j] = R[i];
}
R[i] = tmp;
QuickSort(R, s, i - 1);
QuickSort(R, i + 1, t);
}
}
/******************************merge sort******************************/
public static void MergeSort(int[]R,int n)
{
int length;
for(length = 1; length < n; length = 2 * length)
MergePass(R,length,n);
}
public static void MergePass(int[] R,int length, int n)
{
int i;
for(i = 0; i + 2 * length - 1 < n; i = i + 2 * length)
Merge(R, i, i + length - 1, i + 2 * length - 1);
if(i + length - 1 < n)
Merge(R, i, i + length - 1,n - 1);
}
public static void Merge(int[] R, int low, int mid, int high)
{
int[] R1 = new int[high - low + 1];
int i = low, j = mid + 1,k = 0;
while(i <= mid && j <= high)
if(R[i] < R[j])
{
R1[k] = R[i];
i++;
k++;
}
else
{
R1[k] = R[j];
j++;
k++;
}
while(i <= mid)
{
R1[k] = R[i];
i++;
k++;
}
while(j <= high)
{
R1[k] = R[j];
j++;
k++;
}
for(k = 0,i =low; i <= high; k++,i++)
R[i] = R1[k];
}
/************************************************************************/
}