常见排序算法

记录几个常见的排序算法。
冒泡排序算法思路：

第一步，比较相邻元素的大小

第二步，符合条件的元素交换位置，最值交换到右边

第三步，重复以上两个步骤直至没有元素需要比较

算法如下：
public void bubbleSort(int[] array) {
for(int i=0; i<array.length-1; i++) {
for(int j=0; j<array.length-1-i; j++)
if(array[j]>array[j+1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}

    }
}

选择排序的思路：
第一步，将第一个元素依次与其他元素比较，符合条件就交换位置，这样第一轮比较结果最值出现在左边
第二步，将第二个元素依次与其他元素比较，符合条件就交换位置，这样第二轮比较结果是第二个最值出现在左边
第三步，将剩下元素依次重复上述步骤，直至剩下一个元素为止
算法如下：
for(int i=0; i<a.length-1; i++)
for(int j=i+1; j<a.length; j++) {
if(a[i]>a[j]) {
a[i]=a[i]+a[j];
a[j]=a[i]-a[j];
a[i]=a[i]-a[j];
}
}
}

快速排序算法的思路：
以数组为例：

1. 第一步，从数组中任选一个元素做为基数

2. 第二步，分别从数组的两头开始，把大于基准的元素放在基准的右边，把小于基准的元素放在基准的左边

3. 第三步，把基准左边和右边的子集，不断重复第一步和第二步操作，就是进行递归，直到子元素剩下一个元素为止
   算法如下：
   public class Sort {

   public int getSortIndex(int[] a, int left, int right) {
   int temp = a[left];
   while(left < right) {
   while(left<right && a[right]>=temp) {
   right--;
   }
   a[left]=a[right];
   while(left<right && a[left]<=temp) {
   left++;
   }
   a[right]=a[left];
   }
   a[left]=temp;
   return left;
   }

   public void quickSort(int[] a, int left, int right) {
   if (left < right) {
   int index = this.getSortIndex(a, left, right);
   this.quickSort(a, left, index-1);
   this.quickSort(a, index+1, right);
   }

   }

   public void sort(int[] a) {
   if (a!=null && a.length >0) {
   this.quickSort(a, 0, a.length-1);
   }
   }

特点：
对于大量数据进行快速排序算法，速度较快，但是快速排序不稳定
对于少量数据不如选择排序和冒泡排序算法稳定有效
冒泡排序比较次数较多，很少使用，少量数据使用选择排序较多。