java的简单排序算法

java的简单排序算法

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。

　　内排序有可以分为以下几类：

　　(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

　　(2)、选择排序：简单选择排序、堆排序。

　　(3)、交换排序：冒泡排序、快速排序。

　　(4)、归并排序

　　(5)、基数排序

冒泡排序：

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

　　冒泡排序的示例：

 


1、冒泡排序的算法实现如下:【排序后，数组从小到大排列】：

　/**
* 冒泡排序
* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
* 针对所有的元素重复以上的步骤，除了最后一个。
* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
* @param numbers 需要排序的整型数组
*/
public static void bubbleSort(int[] numbers)
{
int temp = 0;
int size = numbers.length;
for(int i = 0 ; i < size-1; i ++)
{
for(int j = 0 ;j < size-1-i ; j++)
{
if(numbers[j] > numbers[j+1])  //交换两数位置
{
temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}
}

2、简单选择排序

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

 


实现代码：

public class ChoiceSort {

public static void _choiceSort(Integer[] a) {
if (a == null || a.length <= 0) {
return;
}
for (int i = 0; i < a.length; i++) {
int min = i; /* 将当前下标定义为最小值下标 */

for (int j = i + 1; j < a.length; j++) {
if (a[min] > a[j]) { /* 如果有小于当前最小值的关键字 */
min = j; /* 将此关键字的下标赋值给min */
}
}
if (i != min) {/* 若min不等于i，说明找到最小值，交换 */
int tmp = a[min];
a[min] = a[i];
a[i] = tmp;
}
}
}
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] list={49,38,65,97,76,13,27,14,10};
//快速排序
/* QuicSort qs=new QuicSort();
qs.quick(list);*/
//冒泡排序
/* BubbleSort bs=new BubbleSort();
bs.bubble(list);*/
//选择排序
ChoiceSort._choiceSort(list);

for(int i=0;i<list.length;i++){
System.out.print(list[i]+" ");
}
System.out.println();
}

3.直接插入排序

思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置，直到全部插入排序完为止。
•关键问题：在前面已经排好序的序列中找到合适的插入位置。
•方法：
–直接插入排序
–二分插入排序
–希尔排序
①直接插入排序（从后向前找到合适位置后插入）

　　1、基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

　　2、实例

　　


实现代码：

package com.sort;

public class 直接插入排序 {

public static void main(String[] args) {
int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1};
System.out.println("排序之前：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
//直接插入排序
for (int i = 1; i < a.length; i++) {
//待插入元素
int temp = a[i];
int j;
/*for (j = i-1; j>=0 && a[j]>temp; j--) {
//将大于temp的往后移动一位
a[j+1] = a[j];
}*/
for (j = i-1; j>=0; j--) {
//将大于temp的往后移动一位
if(a[j]>temp){
a[j+1] = a[j];
}else{
break;
}
}
a[j+1] = temp;
}
System.out.println();
System.out.println("排序之后：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}

}

4.快速排序

思路：

   1、选取一个元素作为基准元素，通常选择第一个元素或最后一个元素。

   2、经过一轮排序后，将比基准元素小的放在元素放在左边，形成左序列，将比基准元素小的元素放在右边，形成右数列。

   3、再用同样的方法递归地排序划分的两部分。对左序列和又序列做1、2步操作

　　2、实例



实现代码:

package com.sort;

//不稳定
public class 快速排序 {
public static void main(String[] args) {
int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,8};
System.out.println("排序之前：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
//快速排序
quick(a);
System.out.println();
System.out.println("排序之后：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}

private static void quick(int[] a) {
if(a.length>0){
quickSort(a,0,a.length-1);
}
}

private static void quickSort(int[] a, int low, int high) {
if(low<high){ //如果不加这个判断递归会无法退出导致堆栈溢出异常
int middle = getMiddle(a,low,high);
quickSort(a, 0, middle-1);
quickSort(a, middle+1, high);
}
}

private static int getMiddle(int[] a, int low, int high) {
int temp = a[low];//基准元素
while(low<high){
//找到比基准元素小的元素位置
while(low<high && a[high]>=temp){
high--;
}
a[low] = a[high];
while(low<high && a[low]<=temp){
low++;
}
a[high] = a[low];
}
a[low] = temp;
return low;
}
}

5.归并排序:

1、基本思想:归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
　　2、实例



　　3、java代码实现

package com.sort;
2
3 //稳定
4 public class 归并排序 {
5     public static void main(String[] args) {
6         int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,8};
7         System.out.println("排序之前：");
8         for (int i = 0; i < a.length; i++) {
9             System.out.print(a[i]+" ");
10         }
11         //归并排序
12         mergeSort(a,0,a.length-1);
13         System.out.println();
14         System.out.println("排序之后：");
15         for (int i = 0; i < a.length; i++) {
16             System.out.print(a[i]+" ");
17         }
18     }
19
20     private static void mergeSort(int[] a, int left, int right) {
21         if(left<right){
22             int middle = (left+right)/2;
23             //对左边进行递归
24             mergeSort(a, left, middle);
25             //对右边进行递归
26             mergeSort(a, middle+1, right);
27             //合并
28             merge(a,left,middle,right);
29         }
30     }
31
32     private static void merge(int[] a, int left, int middle, int right) {
33         int[] tmpArr = new int[a.length];
34         int mid = middle+1; //右边的起始位置
35         int tmp = left;
36         int third = left;
37         while(left<=middle && mid<=right){
38             //从两个数组中选取较小的数放入中间数组
39             if(a[left]<=a[mid]){
40                 tmpArr[third++] = a[left++];
41             }else{
42                 tmpArr[third++] = a[mid++];
43             }
44         }
45         //将剩余的部分放入中间数组
46         while(left<=middle){
47             tmpArr[third++] = a[left++];
48         }
49         while(mid<=right){
50             tmpArr[third++] = a[mid++];
51         }
52         //将中间数组复制回原数组
53         while(tmp<=right){
54             a[tmp] = tmpArr[tmp++];
55         }
56     }
57 }