几种常见的排序算法（java实现）

/**
*
* 各种排序算法
*1、排序：直接插入排序
* --依次将每个元素插入到前面已经排好的序列当中
*2、排序：冒泡排序
* --从列表的第一个数（0）字到倒数第二个（i=n-2）{i--}数字，逐个检查，
* 若某一位上的数字大于他的下一位，则交换
*3、排序：选择排序
* --每次都在未排序的序列中选取一个最小或者最大的元素，放在最终的位置
*4、排序：折半插入排序
* --直接插入法的改进，通过二分搜索的方式找出需要插入的位置，在将后面的
* 元素全部向后移动一位
*5、排序：shell排序
* --以n/2的步长分组直接插入排序，逐步减少步长，直到步长为1
*6、排序：快速排序
* --a.递归实现
* --b.非递归实现
*7、归并排序
* --利用分治的思想
*8、堆排序
* --将数组转化为二叉树，在转化为堆。
*/

package Paixu;
public
class Paixu {
/**
* @param args
*/
public
static void main(String[] args) {
// TODO Auto-generatedmethod stub
int arr[]={5,4,3,2,1};
int arr1[]=new
int[5];

//直接插入排序
Zhijie zhijie=new Zhijie();
zhijie.zhijie(arr);
//冒泡排序
Maopao mp=new Maopao();
mp.maopao(arr);
// 选择排序
Xuanze xz=new Xuanze();
xz.xuanze(arr);
//快速排序法
quicksort qs=new quicksort();
qs.data=arr;
qs.sort(0, arr.length-1);
qs.display();
//归并排序
guibing gb=new guibing();
gb.mergesort(arr, 0,arr.length-1, arr1);
//堆排序
Dui dui=new Dui();
dui.Sort(arr);
//折半插入排序法
Charu_youhua cry=new Charu_youhua();
cry.binaryInsertSort(arr);
//shell排序
Shell_Sort ss=new Shell_Sort();
ss.ShellSort(arr);
}
}

//直接插入排序方法
class Zhijie{
public
void zhijie(int arr[]){
for (int i = 1; i <arr.length; i++) {
//判断这个元素是否需要交换
int exchange=arr[i];

for (int j =i-1; j >=0; j--) {

if(exchange<arr[j]){

arr[j+1]=arr[j];
}
arr[j]=exchange;
}
}
}
}

//冒泡排序
class Maopao{
public
void maopao(int arr[]){
//外层，定义需要多少躺比较
int tmp=0;
for (int i = 0; i <arr.length-1; i++) {

for (int j = 0; j < arr.length-i-1; j++) {
if(arr[j]>arr[j+1]){
tmp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=tmp;
}
}
}
}
}

//选择排序
class Xuanze{

public
void xuanze(int arr[]){
//定义需要寻找多少次
for (int i = 0; i < arr.length-1; i++) {

int minIndex=i;
int tmp=0;
for (int j = i+1; j <arr.length; j++) {
while(arr[minIndex]>arr[j]){
minIndex=j;
}
tmp=arr[i];
arr[i]=arr[minIndex];
arr[minIndex]=tmp;
}
}
}
}
//折半插入排序

class Charu_youhua{

public
void binaryInsertSort(int[] array){
for(int i = 1; i < array.length; i++){
int temp = array[i];
int low = 0;
int high = i - 1;

while(low <= high){
int mid = (low + high)/ 2;
if(temp < array[mid]){
high = mid -1;
}else{
low = mid +1;
}
}
for(int j = i; j >= low + 1; j--){
array[j] = array[j -1];
}
array[low] = temp;
}
}
}

//shell排序
class Shell_Sort{
public
void ShellSort(int[] array) {

int k=array.length/2;
//如果分组长度小于1时，结束循环
while(k>=1){
int j=0;

while(true){

//对各个分组进行插入排序
for(int i=j;i<array.length;i=i+k){
//j=0时分组1
排序 j=1时分组2排序
int temp = array[i];
int t=i-k;
//查找适当位置,进行插入数据
while(t>=0&&array[t]>temp){
array[t+k]=array[t];
t=t-k;
}
array[t+k]=temp;
}
j++;
//j%k==0表明起始元素前面第一次已经出现过.
if(j%k==0)
//列表只能有k个分组
break;
}
k--;//分组的密度越来越细
}
//return ;
}
}

//快速排序
class quicksort
{
public
int data[];

private
int partition(int sortArray[],int low,int hight)
{
int key = sortArray[low];

while(low<hight)
{
while(low<hight &&sortArray[hight]>=key)
hight--;
sortArray[low] = sortArray[hight];

while(low<hight && sortArray[low]<=key)
low++;
sortArray[hight] = sortArray[low];
}
sortArray[low] = key;
return low;
}

public
void sort(int low,int hight)
{
if(low<hight)
{
int result = partition(data,low,hight);
sort(low,result-1);
sort(result+1,hight);
}
}
public
void display()
{
for(int i=0;i<data.length;i++)
{
System.out.print(data[i]);
System.out.print(" ");
}
}
}

//归并排序
class guibing{
public
int[] mergesort(int[] num,
int s, int t,
int[] num1) {

int m;
int[] num2 =
new int[t + 1];
if (s == t)
num1[s] = num[s];

else {
m = (s + t) / 2;
mergesort(num, s, m,num2);//左半部分递归调用
mergesort(num, m + 1,t, num2);//右半部分递归调用
merg(num2, s, m, t,num1);//
由num2去归并，返回的值放到num1中,num1赋新值，其实就是更新num2,然后让num2再去归并，返回新的num1
}
return num1;
}
//有序表的合并
public
void merg(int[] num,
int l, int m,
int n, int[] num1) {
System.out.print("l=" + l +
" m=" + m + " n=" + n);
System.out.println();
int i, j, k;
i = l;
j = m + 1;
k = l;
while (i <= m&& j <= n) {
if (num[i] <num[j])
num1[k++] =num[i++];
else {
num1[k++] =num[j++];
}
}

while (i <= m) {
num1[k++] = num[i++];
}
while (j <= n) {
num1[k++] = num[j++];
}

}
}
//堆排序

class Dui{
public
void Sort(int[] arr){
int n=arr.length;
int tmp=0;
for (int i = n/2; i>0;i--) {
Adjust(arr,i-1,n);
}
for (int i =n-2 ; i >=0;i--) {
tmp=arr[i+1];
arr[i+1]=arr[0];
arr[0]=tmp;
Adjust(arr,0,i+1);
}
}
public
void Adjust(int[] arr,int i,
int n){
int j=0;
int tmp=0;
tmp=arr[i];
j=2*i+1;
while(j<=n-1){
if(j<n-1&&arr[j]<arr[j+1]){
j++;}
if (tmp>=arr[j]) {
break;}
arr[(j-1)/2]=arr[j];
j=2*j+1;
}
arr[(j-1)/2]=tmp;
}
}