java排序算法整理
排序算法的分类如下：
插入排序（直接插入排序、折半插入排序、希尔排序）；
交换排序（冒泡泡排序、快速排序）；
选择排序（直接选择排序、堆排序）；
归并排序；
基数排序。
1、插入排序：
插入排序的基本思想是将整个记录序列划分成两部分：（有序区）[无序区] ，从无序区中取第一个记录，插入到有序区的正确位置，使有序区仍然保持有序；插入算法的关键是：如何确定插入位置。
（1）直接插入排序：
算法思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的正确位置，使之成为新的有序表，重复n-1次可完成排序过程。
[java] view plaincopyprint?
public class InsertSort {
public static void main(String[] args) {
int [] array = {6,3,2,7,1,4,5};
int temp;
for (int i = 1; i < array.length; i++) { //无序区元素
for (int j = 0; j < i; j++) { //有序区元素
if (array[j] > array[i]) { //从无序区中取出第i个元素，与有序区中的元素进行比较选择插入的位置进行交换
temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
}
第一趟结束：{ 3 6 [ 2 7 1 4 5 ] } //从无序区中取出3与有序区的6进行比较，3<6,所以两者交换
第二趟结束：{ 2 3 6 [ 7 1 4 5 ] } //从无序区中取出2与有序区的[3,6]分别进行比较，2<3 => 2和3交换，3<6 => 3和6交换
第三趟结束：{ 2 3 6 7 [ 1 4 5 ] } //从无序区中取出7与有序区的[2,3,6]分别进行比较，7>2不交换，7>3不交换，7>6不交换
第四趟结束：{ 1 2 3 6 7 [ 4 5 ] } //从无序区中取出1与有序区的[2,3,6,7]分别进行比较，1<2 => 1和2交换，2<3 => 2和3交换，3<6 => 3和6交换，6<7=> 6和7交换
第五趟结束：{ 1 2 3 4 6 7 [ 5 ] } //从无序区中取出4与有序区的[1,2,3,6,7]分别进行比较，4>1不交换，4>2不交换，4>3不交换，4<6 => 4和6交换，6<7=> 6和7交换
第六趟结束：{ 1 2 3 4 5 6 7 } //从无序区中取出5与有序区的[1,2,3,4,6,7]分别进行比较，5>1不交换，5>2不交换，5>3不交换，5>4不交换，5<6 => 5和6交换，6<7=> 6和7交换
public class InsertSort {
public static void main(String[] args) {
int [] array = {6,3,2,7,1,4,5};
int temp;
int index;
for(int i = 1 ; i < array.length ; i++) //从无序区中取出第i个数来准备插入到有序区中
{
if(array[i]< array[i-1]) //先将取出的数与有序区最后一个数进行比较，如果小于，则开始移动插入。
{
temp = array[i]; //先将要插入的数赋值到一个临时变量中，否则元素后移会被覆盖
index = i;
，
while( index >= 1 && temp < array[index-1]) //边移动边观察是否已插入到正确位置，即要插入的数是否已大于前一个数
{
array[index] = array[index-1]; //其它元素后移
index--; //继续向前查找正确位置，直到移动到数组首位。
}
array[index] = temp; //将取出的数插入到正确的位置。
}
}
}
}
第一趟结束：{ 3 6 [ 2 7 1 4 5 ] } //从无序区中取出6与有序区中的[ 3 ]进行比较，6>3不交换
第二趟结束：{ 2 3 6 [ 7 1 4 5 ] } //从无序区中取出2与有序区中的[ 3 ,6 ]进行比较，2<6 => temp = 2,6往后移一格 => 2<3 => 3往后移一格 => 已经移到开头了,把2放在开头
第三趟结束：{ 2 3 6 7 [ 1 4 5 ] } //从无序区中取出7与有序区中的[ 2,3 ,6 ]进行比较，7>6不交换，7>3不交换，7>2不交换
第四趟结束：{ 1 2 3 6 7 [ 4 5 ] } //从无序区中取出1与有序区中的[ 2,3 ,6 ,7]进行比较，1<7 =>temp =7,7往后移一格=> 1<6 =>6往后移一格 => 1<3 => 3往后移一格 => 1<2 => 1往后移一格 => 已经移到开头了，把1放在开头
第五趟结束：{ 1 2 3 4 6 7 [ 5 ] } //从无序区中取出4与有序区中的[ 1,2,3 ,6 ,7]进行比较，4<7=> temp = 4,7往后移一格 => 4< 6 =>6往后移一格 =>4 >3 => 将4放在该位置上
第六趟结束：{ 1 2 3 4 5 6 7 }
2、交换排序：
（1）冒泡排序：
算法思想：这种排序方法是通过相邻元素之间的比较与交换，使值较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就象水底下的气泡一样逐渐向上冒。故称为冒泡排序法。
1）从无序区左边开始，依次对相邻记录进行两两比较，不满足顺序要求的进行交换；
2）每趟结束等同于从无序列中选出最大的数(从大到小排列)或最小的数(从小到大排列)填在无序区的末尾。
3）每趟结束无序区范围-1，直到无序区范围为1；
public class BubbleSort {
public static void main(String[] args) {
int [] array = {6,3,2,7,1,4,5};
int temp;
boolean flag; //标注此趟是否有进行交换
for(int i = 1 ; i < array.length; i++)
{
flag = false;
for(int j = 0 ; j < array.length - i ; j++)
{
if(array[j]>array[j+1])
{
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
if(!flag) //如果该趟没进行过交换则表明排序已完成
break;
}
}
}
第一趟结束：{ [ 3 2 6 1 4 5 ] 7 } //分别两两比较，6>3 => 6和3交换，6>2 => 6和2交换，6<7不交换，7>1 => 7和1交换，7 >4 => 7和4交换， 7 > 5 => 7和5交换
第二趟结束：{ [ 2 3 1 4 5 ] 6 7 } //分别两两比较，3>2 => 3和2交换，3<6不交换，6>1 => 6和1交换，6 >4 => 6和4交换， 6 > 5 => 6和5交换
第三趟结束: { [ 2 1 3 4 ] 5 6 7 } // 2<3不交换，3>1 => 3和1交换，3<4不交换，4<5不交换
第四趟结束: { [ 1 2 3 ] 4 5 6 7 }
[ ]表示无序区范围;
3、选择排序：
（1）直接选择排序：
算法思想：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕。
1）使用index标注无序区中最大或最小的数值的下标位置，每趟都选出了无序区中最大或最小的数的Index下标，并将它与无序区的最后一个元素进行交换。
2）这是冒泡排序的改进版本，减少了交换的次数；
public class SelectSort { //正序排列
public static void main(String[] args) {
int [] array = {6,3,2,7,1,4,5};
int index; //用于标注最大或最小数的下标
int temp; //用于交换的中间媒介
for(int i=1; i < array.length; i++)
{
index = 0;
for(int j = 1 ; j <= array.length - i ; j++)
{
if(array[j] > array[index]) //将无序区中的每个元素与Index标注的元素值进行比对
{
index = j; //如果大于则用Index记录该值下标
}
}
if(index!= array.length - i) //判断index位置是否是无序区末尾
{
temp = array[index]; //否的话将Index所在数值与无序区末尾的数值进行交换
array[index] = array[array.length - i];
array[array.length - i] = temp;
}
}
}
}