数据结构之排序算法

1、交换排序

排序思想：根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置，基于交换排序的算法主要有冒泡和快排

1.1冒泡排序java实现

冒泡排序算法的基本思想是：假设待排序表长为n，从后往前（或从前往后）两两比较相邻元素的值，若为逆序（即A[i-1]>A[i]），则交换它们，直到序列比较完。我们称它为一趟冒泡，结果将最小的元素交换到待排序列的第一个位置（关键字最小的元素如气泡一般逐渐往上“漂浮”，直至“水面”，这就是冒泡排序名字的由来）。下一趟冒泡时，前一趟确定的最小元素不在参与比较，待排序列减少一个元素，每趟冒泡的结果把序列中的最小元素放到了序列的最终位置，......，这样最多做n-1趟冒泡就能把所有元素排好序。

时间复杂度：最坏O（n^2）,最好O(n^2);

稳定性：稳定排序

package exchangeSort;

public class BubbleSort {

/**

* 冒泡排序

* @param param

*/

public BubbleSort(int[]param){

for(int i=0;i<param.length;i++){

boolean flag =false;

for(int j=param.length-1;j>i;j--){

if(param[j-1]>param[j]){

int temp = param[j];

param[j] = param[j-1];

param[j-1]=temp;

flag =  true;

}

}

if(flag ==false)return;

}

 }

public static void main(String[] args) {

int[] param = {0,87,45,78,32,17,65,53,9};

System.out.print("排序前:");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

BubbleSort bubbleSort =new BubbleSort(param);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

1.2快速排序java实现

快速排序是对冒泡排序的一种改进。其基本思想是基于分治法的：在待排序表L[1...n]中任取一个元素pivot作为基准，通过一趟排序将待排序表划分为独立的两部分L[1...k-1]和L[k+1...n],使得L[1...k-1]中所有元素小于pivot，L[k+1...n]中所有元素大于或等于pivot，则pivot放在最终位置L(k)上，这个过程称为一趟快速排序。而后分别递归地调用快速排序算法进行排序。

时间复杂度：最坏情况下:O(n^2),平均情况下：O(nlog2n)

稳定性：不稳定

package exchangeSort;

public class QuickSort {

/**

* 快速排序

* @param p

* @param low

* @param high

*/

public void quickSort(int[] p,int low,int high){

if(low<high){

int pivotpos = partition(p,low,high);

quickSort(p,low,pivotpos-1);

quickSort(p,pivotpos+1,high);

}

}

int partition(int[] p,int low,int high){

int pivot =p[low];

while(low<high){

while(low<high&&p[high]>=pivot) --high;

p[low]=p[high];

while(low<high&&p[low]<=pivot) ++low;

p[high]=p[low];

}

p[low] =pivot;

return low;

     }

public static void main(String[] args) {

int[] param = {0,87,45,78,32,17,65,53,9};

QuickSort quickSort =new QuickSort();

System.out.print("排序前:");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

quickSort.quickSort(param, 0,param.length-1);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

2、插入排序

插入排序是一种简单直观的排序方法，其基本思想在于将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中，直到全部插入完成，应用其思想的主要有三种排序算法：直接插入排序、折半插入排序、希尔排序

2.1直接插入排序和折半插入排序的java实现

直接插入排序的时间复杂度: O(n^2);

折半插入排序的时间复杂度: O(n^2);

稳定性: 稳定排序

package insertSort;

public class InsertSort {

public InsertSort(){}

/**

* 直接插入排序

* @param param

*/

public InsertSort(int[] param){

int j=0;

for(int i=2;i<param.length;i++){

if(param[i]<param[i-1]){

param[0] =param[i];

for(j=i-1;param[0]<param[j];j--)param[j+1] =param[j];

param[j+1] =param[0];

}

}

}

/**

* 折半插入排序

* @param param

* @param n

*/

public void insertSort(int[]param){

int j=0,low,high,mid;

for(int i=2;i<param.length;i++){

param[0] =param[i];

low = 1;high =i-1;

while(low<=high){

mid = (low+high)/2;

if(param[mid]>param[0])high =mid-1;

else low = mid+1;

}

for(j=i-1;j>=high+1;--j)param[j+1]=param[j];

param[high+1]=param[0];

}

}

public static void main(String[]args) {

int[] param = {0,87,45,78,32,17,65,53,9};

InsertSort insertSort_2 =new InsertSort();

System.out.print("排序前：");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

InsertSort insertSort_1 =new InsertSort(param);

//insertSort_2.insertSort(param);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

2.2希尔排序java实现

算法思想：先将待排序表分割成若干个形如L[i,i+d,i+2d,..i+kd]的特殊子表，分别进行直接插入排序，当整个表中的元素已呈基本有序时，在对全记录进行一次直接插入排序。

算法时间复杂度：由于希尔排序的时间复杂度依赖于增量序列的函数，数学上尚未解决的难题，所以平均时间复杂度约为O(n^1.3)，最坏约为O(n^2)

稳定性:不稳定

package insertSort;

public class ShellSort {

/**

* 希尔排序

* @param p

* @param n

*/

public ShellSort(int[]p,intn){

int dk,i,j;

for(dk=n/2;dk>=1;dk=dk/2){

for(i=dk+1;i<=n;++i){

if(p[i]<p[i-dk]){

p[0]=p[i];

for(j=i-dk;j>0&&p[0]<p[j];j-=dk)p[j+dk]=p[j];

p[j+dk] =p[0];

}

}

}

}

public staticvoid main(String[] args) {

int[] param = {0,87,45,78,32,17,65,53,9};

System.out.print("排序前:");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

ShellSort insertSort =new ShellSort(param,param.length-1);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

3.归并排序

算法思想： 归并的意思是将两个或者两个以上的有序表组合成一个新的有序表，假如待排序的记录表中含有n个记录，每个子表长度为1.然后两两归并，得到n/2向下取整个长度为2或者为1的有序表；然后再两两归并，......如此重复，直到合成一个长度为n的有序表为止，这种排序称为2-路归并排序

3.1、2-路归并排序java实现

时间复杂度: 最坏O(n^2) 平均O(n*log2n)

算法稳定性: 稳定

package mergeSort;

public class MergeSort {

public void mergeSort(int[] p,int low,int high){

if(low<high){

int mid = (low+high)/2;

mergeSort(p,low,mid);

mergeSort(p,mid+1,high);

meger(p,low,mid,high);

}

}

public void meger(int[] p,int low,int mid,int high){

int[] temp =new int[p.length+1];

int i,j,k;

for(k=low;k<=high;k++)temp[k] = p[k];

for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){

if(temp[i]<temp[j])p[k]=temp[i++];

else p[k]=temp[j++];

}

while(i<=mid)p[k++]=temp[i++];

while(j<=high)p[k++]=temp[j++];

}

public static void main(String[] args) {

int[] param = {0,87,45,78,32,17,65,53,9};

MergeSort mergeSort =new MergeSort();

System.out.print("排序前：");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

mergeSort.mergeSort(param, 0,param.length-1);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

4.选择排序

算法思想： 每一趟（例如第i趟）在后面n-i+1（i=1，2，...n-1）个待排序的元素中选取关键字最小的元素，作为有序子序列的第i个元素，直到第n-1趟做完，待排序元素只剩下一个，就不用在选了，主要有简单选择排序和堆排序

4.1简单选择排序java实现

算法思想： 假设排序表为L[1...n],第i趟排序即从L[i...n]中选择关键字最小的元素与L(i)交换，每一趟排序可以确定一个元素的最终位置，这样经过n-1趟排序就可以使得整个排序表有序；

时间复杂度: O(n^2);

稳定性: 不稳定

package selectSort;

public class SelectSort {

/**

* 简单选择排序

* @param p

* @param n

*/

public void selectSort(int[]p,intn){

int i,j,min;

for(i=0;i<n-1;i++){

min = i;

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

if(p[j]<p[min])min =j;

if(min!=i){

int temp = p[i];

p[i] =p[min];

p[min] =temp;

}

}

}

public staticvoid main(String[]args) {

int[] param = {0,87,45,78,32,17,65,53,9};

SelectSort selectSort =new SelectSort();

System.out.print("排序前：");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

selectSort.selectSort(param,param.length);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}

4.2堆排序java实现

算法思想： 堆排序是一种树形选择排序方法，他的特点是：在排序过程中，将L[1...n]看成一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在关系，在当前无序区中选择关键字最大或者最小的元素。

堆的定义如下：n个关键字序列L[1...n]称为堆，当且仅当改序列满足：

1、L(i)<=L(2i)&&L(i)<=L(2i+1)  2、L(i)>=L(2i)&&L(i)>=L(2i+1) (1<=i<=n/2)

满足第一种情况的称为小顶堆，满足第二种情况的称为大顶堆 

堆排序的关键是构造初始堆，对初始序列建堆，就是一个反复筛选的过程，n个节点的完全二叉树，最后一个节点是第n/2向下取整个节点的孩子，对第n/2向下取整个节点为根的子树筛选（对于大根堆：若根节点的关键字小于左右子女中关键字较大者，则交换），使该子树成为堆。之后向前依次对各个节点（n/2-1～1）为根的子树进行筛选，看该节点值是否大于其左右子节点的值，若不是，则将左右子节点中较大者与之交换，交换后可能会破坏下一级的堆，于是继续采用上述方法构造下一级的堆，直到以该节点为根的子树构造成堆位置。反复利用上述调整堆的方法建堆，直到根节点；

算法时间复杂度： O(n*log2n);

稳定性： 不稳定;

package selectSort;

public class HeapSort {

/**

* 堆排序

* @param p

* @param n

*/

public void heapSort(int[] p,int n){

buildMaxHeap(p,n);

for(int i=n;i>1;i--){

int temp = p[i];

p[i] =p[1];

p[1] = temp;

adjustDown(p,1,i-1);

}

}

//建立大根堆

public void buildMaxHeap(int[] p,int n){

for(int i=n/2;i>0;i--){

adjustDown(p,i,n);

}

}

//向下调整堆

public void adjustDown(int[] p,int k,int n){

p[0] = p[k];

for(int i=2*k;i<=n;i*=2){

if(i<n&&p[i]<p[i+1])i++;

if(p[0]>=p[i])break;

else{

p[k] =p[i];

k=i;

}

}

p[k] =p[0];

}

//向上调整堆

public void adjustUp(int[] p,int k){

p[0] = p[k];

int i=k/2;

while(i>0&&p[i]<p[0]){

p[k] =p[i];

k=i;

i=k/2;

}

p[k] =p[0];

}

public static void main(String[] args) {

int[] param = {0,53,17,78,9,45,65,87,32};

HeapSort heapSort =new HeapSort();

System.out.print("排序前：");

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

System.out.println("");

System.out.print("排序后:");

heapSort.heapSort(param,param.length-1);

for(int i=1;i<param.length;i++){

System.out.print(param[i]+" ");

}

}

}