java排序算法整理

 排序算法的分类如下： 

• 插入排序（直接插入排序、折半插入排序、希尔排序）； 
• 交换排序（冒泡泡排序、快速排序）； 
• 选择排序（直接选择排序、堆排序）； 
• 归并排序；
• 基数排序。
  

1、插入排序：

插入排序的基本思想是将整个记录序列划分成两部分：（有序区）[无序区] ，从无序区中取第一个记录，插入到有序区的正确位置，使有序区仍然保持有序；插入算法的关键是：如何确定插入位置。

（1）直接插入排序：

算法思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的正确位置，使之成为新的有序表，重复n-1次可完成排序过程。

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;
			}
		}
       }
}