数据结构中的三种排序（java）

由于马上要参加一个笔试，又拿出了满是灰尘的数据结构课本，想把基本的数据类型和算法给看一看，由于找工作是java方面，所以有意把排序的算法用java写一下，水平很是一般，希望自己能够一步一个脚印，踏实走下去，如果能给大家一些启发就更好了。 代码全部测试过，如有瑕疵，请批评指正。

首先介绍引自百度---插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

插入排序的基本操作是：将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

稳定的定义：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

我的理解是：

1.把需要排序的数分成两份，第一份是有序的，第二份无序。

2.最开始可以把第一个数看成是有序，每次从第二份无序数中按顺序取一个数。

3.把取得数跟有序数中的最后一个比较，如果前者小于后者，找合适位置插入。

4.循环步骤三，则排序结束。

java实现 （数据使用严蔚敏版 数据结构）

public void InsertSort(int []s){
int j;
for (int i = 1; i <s.length; i++) {  //从i=1开始，即认为数组第一个数为有序组
if (s[i]<s[i-1]) {
int temp=s[i];
//从有序数组中从后往前开始匹配，找合适的位置
for ( j = i-1; j >=0&&temp<s[j]; j--) {
s[j+1]=s[j];//后移，给array1[i]留出插入位置
}
//插入
s[j+1]=temp;
}
}
for(int i=0;i<s.length;i++){
System.out.print(s[i]+" ");
}
}

编写测试方法

public static void main(String[] args) {
// TODO Auto-generated method stub
InsertSort insertSort=new InsertSort();
int array []={49,38,65,97,76,13,27,49};//数组赋值
insertSort.InsertSort(array);
}

打印结果是：13 27 38 49 49 65 76 97 

第二种 冒泡排序：

冒泡排序算法的运作如下：（从后往前）

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

是稳定排序。

我的理解：这个比较好理解，因为很形象，就像气泡从水底浮上来一样，每经过一轮排序，会出现一个最大的数，直到所有的数排序完成。

java实现

public void BubbleSort(int []s)
{
for (int i = s.length-1;i>0; i--) {
for (int j = 0; j < i; j++) {
if (s[j]>s[j+1]) { //前一个大于后一个
int temp=s[j];//交换位置
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+" ");
}
}

主函数测试

public static void main(String[] args) {
// TODO Auto-generated method stub
BubbleSort bubbleSort=new BubbleSort();
int array []={49,38,65,97,76,13,27,49};
bubbleSort.BubbleSort(array);
}

打印结果是：13 27 38 49 49 65 76 97 

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

是不稳定的排序。

我的理解：采取分治思想，什么意思呢？就是首先把数据分成两部分，取一个中间值（枢轴），中间值左边的每个数都比右边的每个数小，然后对于左边的数，再取中间数，这样循环，最终把整个数组排成有序。这里引用一个动态图片来说明，很清楚。



java实现

public class QuickSort {

public static void main(String[] args) {
// TODO Auto-generated method stub
int []s={49,38,65,97,76,13,27};
QuickSort qs=new QuickSort();
qs.QuickSort(s, 0, s.length-1);
//打印
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+" ");
}
}
//递归 排序
public void QuickSort(int []s,int low,int high)
{
if (low<high) {
int middle=getMiddle(s, low, high);
//通过迭代来对每一部分排序
QuickSort(s, low, middle-1);
QuickSort(s, middle+1, high);
}
}
//取得无序数组的中值
public int getMiddle(int []s,int low,int high)
{
//取第一个数作为中值
int temp=s[low];
while(low<high)
{
//从后往前查找，当其值小于temp，把它交换到前边
while(low<high&&s[high]>temp) high--;
s[low]=s[high];

////从前往后查找，当其值大于temp，把它交换到后边
while(low<high&& s[low]<temp) low++;
s[high]=s[low];
}
//把中值放到应该的位置
s[low]=temp;
return low;
}

}

打印结果：13 27 38 49 65 76 97 

最后一种 选择排序

选择排序的解释：对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量k来记住他的位置，接着第二次比较，前面“后一个元素”现变成了“前一个元素”，继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最小的那个数的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值，这样就找到整个数组中最小的数了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。

我的理解：以上说的很明白，总体上说，第一次遍历找到最小的数，第二次遍历找到第二小的数，以此类推。

java实现

public class SelectSort {

public static void main(String[] args) {
// TODO Auto-generated method stub
SelectSort selectSort=new SelectSort();
selectSort.SelectSort();
}
public v
4000
oid SelectSort()
{
int temp;//存放每次循环中最小的数值
int []s={100,52,68,59,57};
//最小数值的 位置
int position=0;
for (int i = 0; i <s.length; i++) {

position=i;
temp=s[i];
//当发现有比s[i]小的，交换位置
for (int j = i+1; j < s.length; j++) {
if (s[j]<temp) {
temp=s[j];
position=j;
}
}
//交换位置
s[position]=s[i];
s[i]=temp;
}
//打印
for (int i = 0; i < s.length; i++) {
System.out.print(s[i]+" ");
}
}
}

打印结果：52 57 59 68 100 

至此，这三类排序算法介绍完毕。