常见排序算法总结Java版

1、交换排序----冒泡排序：（稳定）

核心思想：重复走访序列，比较相邻数据，顺序错误就交换，一次排序后将选出最大的或最小的数。

两层循环，外循环控制剩余的未排序的数的个数，内循环进行排序。

//冒泡排序

public
static voidbubbleSort(int[]in){

//控制未排序个数

for(inti=0;i<in.length;i++)
{

//将已经排好的数去除，共i个

//注意下标越界

for(intj=0;j<in.length-i-1;j++)
{

//进行交换

if(in[j]>in[j+1]){

int
temp = in[j];

in[j]=in[j+1];

in[j+1]=temp;

}

}

}

}

2、插入排序----直接插入排序（稳定）

核心思想：向已经排好序的序列中插入数据。

两层循环，外层循环表示剩余要进行排序的数据，内层循环表示将数据插入到之前排好序的序列中，两两比较，进行交换。

//直接插入排序

public
static voidinsertSort(int[]in) {

//后面将要排序的数据

for(inti=1;i<in.length;i++)
{

//前向排序，插入前面已经排好的序列

for(intj=i;j>0;j--)
{

if(in[j]<in[j-1]){

//交换数据

int
temp = in[j];

in[j]=in[j-1];

in[j-1]=temp;

}

}

}

}

3、选择排序----简单选择排序（不稳定）

核心思想：每次循环遍历，找到最小的值，并记录下标，与之前排好序的末尾交换。

两层循环，外循环控制要进行排序的个数，内循环选择最小的数据，并记录下标，以便进行交换。

//简单选择排序

public
static void selectSort(int[]in){

for(inti=0;i<in.length-1;i++)
{

int
min = in[i];

int
index = i;

//找到最小值，并记录下标

for(intj=i+1;j<in.length;j++)
{

if(min>in[j]) {

min =
in[j];

index =
j;

}

}

int
temp = in[i];

in[i] =min;

in[index] =temp;

}

}

4、交换排序----快速排序

核心思想：递归，

通过一趟排序，将数据分成两部分，一部分都比关键值小，一部分都比关键值大，然后对前后两部分分别进行递归，注意递归结束条件：left>right

//快速排序

public
static void quickSort(int[]in,intleft,intright)
{

//递归终止条件

if(left>right)

return;

int
i = left;

int
j = right;

int
temp = in[left];//保存基准数

while(i!=j) {

//顺序很重要，要先找右边的

while(in[j]>=temp&&i<j)
{

j--;

}

//再找左边的，注意等号

while(in[i]<=temp&&i<j)
{

i++;

}

//找到符合的就交换

if(i<j) {

int
t = in[j];

in[j] =in[i];

in[i] =t;

}

}

//最终将基准数归位

in[left] =in[i];

in[i] =temp;

//递归求两边的

quickSort(in,left,i-1);

quickSort(in,i+1,right);

}

5、选择排序----堆排序（不稳定）

核心思想：建立大根堆或小根堆，有两个区：有序区，和无序区。堆是一颗完全二叉树。

无序区就是建立的堆，有序区就是每次从对顶取出的有序数列。

以数组存储堆，将堆顶元素与末尾元素交换，堆的性质就被破坏，需要调整。

public
static void main(String[]
args) {

int[]
a ={4,2,1,6,8,7,9,5,3};

heapSort(a);

for(inti=0;i<a.length;i++)
{

System.out.print(a[i]+",");

}

}

public
static void heapSort(int[]a) {

buildHeap(a);//建堆

for(inti=a.length-1;i>=0;i--)
{

int
temp = a[0];

a[0] =
a[i];

a[i] =temp;

//重新调整堆

heapAdjust(a, 0,
i);

}

}

private
static voidbuildHeap(int[]a) {

//从最后一个非叶子节点开始建堆

int
len = a.length;

for(inti=len/2-1;i>=0;i--)
{

heapAdjust(a,
i, len);

}

}

public
static voidheapAdjust(int[]a,intfather,
intlength) {

int
lchild = 2*father+1;

int
rchild = 2*father+2;

int
large = father;

if(lchild<length&&a[lchild]>a[large])
{

large =
lchild;

}

if(rchild<length&&a[rchild]>a[large])
{

large =
rchild;

}

if(large!=father) {

int
temp = a[father];

a[father] =a[large];

a[large] =temp;

//递归调用

heapAdjust(a,
large, length);

}

/*int left =2*father+1;// 左孩子的下标（如果存在的话）

int right =2*father+2;// 左孩子的下标（如果存在的话）

int largest = 0;//寻找3个节点中最大值节点的下标

if(left<length &&a[left]>a[father])

largest = left;

else

largest = father;

if(right<length &&a[right]>a[largest])

largest = right;

if(largest!=father){

inttemp = a[father];

a[father] = a[largest];

a[largest] = temp;

heapAdjust(a,largest,length);

} */

}