数据结构（2）

冒泡排序：

1.比较相邻的两个元素。如果前一个元素比后一个元素大，则交换两者位置。

2.对每一对相邻元素做相同工作，从第一对元素到最后一对元素，最后的一个元素就是最大的元素。

for(int i=a.length-1;i>0;i--){for (int j = 0; j <i; j++) {
if (greater(a[j],a[j+1])){
exch(a,j,j+1);
}
}
}

 时间复杂度为(n^2)

选择排序：

1.每次遍历过程中，都是假定第一个索引处的元素为最小值，和其他索引处的值依次进行比较，如果当前索引大于其他索引处的值，则认为这个索引为最小值，找出其索引

2.交换两个元素

for (int i=0;i<=a.length-2;i++){
//假定本次遍历，最小值所在的索引是i
int minIndex=i;
for (int j=i+1;j<a.length;j++){
if (greater(a[minIndex],a[j])){
//跟换最小值所在的索引
minIndex=j;
}
}
//交换i索引处和minIndex索引处的值
exch(a,i,minIndex);
}

 时间复杂度为O(n^2)

插入排序：

1.将所有元素分为两组，已排序和未排序。

2.把未排序中的第一个元素，向已排序中插入

3.倒叙遍历已排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那就将待插入元素放到这个位置，其余元素向后一位。

 

for (int i=1;i<a.length;i++){
//当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
for (int j=i;j>0;j--){
if (greater(a[j-1],a[j])){
//交换元素
exch(a,j-1,j);
}else {
//找到了该元素，结束
break;
}
}

 时间复杂度为O(n^2)

哈希排序：

1.选定一个增长量h，按照增长量作为分组的依据，对数据进行分组

2.对分好的每一组进行插入排序

3.减少增长量，直至为1，重复第二步

 

int N = a.length;
//确定增长量h的最大值
int h=1;
while(h<N/2){
h=h*2+1;
}
//当增长量h小于1，排序结束
while(h>=1){
//找到待插入的元素
for (int i=h;i<N;i++){
//a[i]就是待插入的元素
//把a[i]插入到a[i-h],a[i-2h],a[i-3h]...序列中
for (int j=i;j>=h;j-=h){
//a[j]就是待插入元素，依次和a[j-h],a[j-2h],a[j-3h]进行比较，如果a[j]小，那么
交换位置，如果不小于，a[j]大，则插入完成。
if (greater(a[j-h],a[j])){
exch(a,j,j-h);
}else{
break;
}
}
}
h/=2;
}

在处理大批量数据时，希尔排序的性能确实高于插入排序。

归并排序：

在方法内部调用方法本身就是递归。

1.尽可能将一组 数据拆分为两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。将两个元素进行比较，放到辅助队列，将辅助队列进行替换原来的队列。

2.将相邻的两个子组进行合并为一个有序的大组

3.重复步骤2，直到只有一个大组。

归并排序代码实现：
//排序代码
public class Merge {
private static Comparable[] assist;//归并所需要的辅助数组
/*
对数组a中的元素进行排序
*/
public static void sort(Comparable[] a) {
assist = new Comparable[a.length];
int lo = 0;
int hi = a.length-1;
sort(a, lo, hi);
}
/*
对数组a中从lo到hi的元素进行排序
*/
private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) {
return;
}
int mid = lo + (hi - lo) / 2;
//对lo到mid之间的元素进行排序；
sort(a, lo, mid);
//对mid+1到hi之间的元素进行排序；
sort(a, mid+1, hi);
//对lo到mid这组数据和mid到hi这组数据进行归并
merge(a, lo, mid, hi);
}
/*
对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
*/
private static void merge(Comparable[] a, int lo, int mid, int hi) {
//lo到mid这组数据和mid+1到hi这组数据归并到辅助数组assist对应的索引处
int i = lo;//定义一个指针，指向assist数组中开始填充数据的索引
int p1 = lo;//定义一个指针，指向第一组数据的第一个元素
int p2 = mid + 1;//定义一个指针，指向第二组数据的第一个元素
//比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
while (p1 <= mid && p2 <= hi) {
if (less(a[p1], a[p2])) {
assist[i++] = a[p1++];
} else {
assist[i++] = a[p2++];
}
}
//上面的循环结束后，如果退出循环的条件是p1<=mid，则证明左边小组中的数据已经归并完毕，如果退
出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕；
//所以需要把未填充完毕的数据继续填充到assist中,//下面两个循环，只会执行其中的一个
while(p1<=mid){
assist[i++]=a[p1++];
}
while(p2<=hi){
assist[i++]=a[p2++];
}
//到现在为止，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
for (int index=lo;index<=hi;index++){
a[index]=assist[index];
}
}

缺点;需要申请额外的数组空间，空间复杂度上升，以空间换时间。

快速排序：

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 1.初次设定第一个元素为分界值，从右向左找小于分界值的元素，从左往右找大于分界值的元素，替换两个元素，直到两个指针重叠。以此元素为分界值，通过分界值将数组分为两部分

2.大于等于分界值放到右边数组右边，小于等于放到左边

3.左右两边数据独立排序。对于左侧数组取一个分界值，分为两部分，左侧数据较小，右侧数据较大。右侧数据也是类似处理。

4.重复上述过程，递归处理。递归处理完左侧和右侧数据，排完序后，整个数组的排序就完成了。

 

public static void sort(Comparable[] a) {
int lo = 0;
int hi = a.length - 1;
sort(a, lo,hi);
}
private static void sort(Comparable[] a, int lo, int hi) {
if (hi<=lo){
return;
}
//对a数组中，从lo到hi的元素进行切分
int partition = partition(a, lo, hi);
//对左边分组中的元素进行排序
//对右边分组中的元素进行排序
sort(a,lo,partition-1);
sort(a,partition+1,hi);
}
public static int partition(Comparable[] a, int lo, int hi) {
Comparable key=a[lo];//把最左边的元素当做基准值
int left=lo;//定义一个左侧指针，初始指向最左边的元素
int right=hi+1;//定义一个右侧指针，初始指向左右侧的元素下一个位置
//进行切分
while(true){
//先从右往左扫描，找到一个比基准值小的元素
while(less(key,a[--right])){//循环停止，证明找到了一个比基准值小的元素
if (right==lo){
break;//已经扫描到最左边了，无需继续扫描
}
}
//再从左往右扫描，找一个比基准值大的元素
while(less(a[++left],key)){//循环停止，证明找到了一个比基准值大的元素
if (left==hi){
break;//已经扫描到了最右边了，无需继续扫描
}
}
if (left>=right){
//扫描完了所有元素，结束循环
break;
}else{
//交换left和right索引处的元素
exch(a,left,right);
}
}
//交换最后rigth索引处和基准值所在的索引处的值
exch(a,lo,right);
return right;//right就是切分的界限
}

归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序。

快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。