几种排序算法java版

package com.datastructure.sort;
 
public class BubbleSort {
    public staticfinal int LENGTH=9;
    /* 冒泡排序
     * 比较LENGTH-1趟
     * 第一趟把最大的放到最后
     * 第二趟把次大的放在倒数第二
     * 第三趟把三大的放在倒数第三
     * ...
     * 第LENGTH-1趟把LENGTH-1大放在倒数LENGTH-1
     *
     *
     * 边界确定
     * LENGTH=1时不用比较
     * LENGHT=2时比较一次（一趟）
     * */
    public static void main(String[] args) {
       int a[]={9,1,5,8,3,7,4,6,2};
       sort(a);
    }
    public staticvoid sort(int a[]){
       for(int i=0;i<LENGTH-1;i++){
           for(int j=0;j<LENGTH-i-1;j++){
              if(a[j]>a[j+1]){
                  int tmp;
                  tmp=a[j];
                  a[j]=a[j+1];
                  a[j+1]=tmp;
              }
           }
       }
       for(inti=0;i<LENGTH;i++)
           System.out.println(a[i]);
    }
}
 

 
package com.datastructure.sort;
 
public class InsertSort {
    public static final int LENGTH=9;
    /* 插入排序
     * 跟冒泡排序相同，顶层循环要LENGTH-1趟,只不过下标从1到LENGTH
     * 每次操作的是新拿来的元素跟已排好序的元素比较后插入
     * */
    public static void main(String[] args){
       int a[]={4,1,9,5,8,3,7,6,2};
       int b[]={3,2,1};
       sort(a);
       sort(b,0,2);
    }
    public static void sort(int a[]){
       int j=0;
       for(inti=1;i<LENGTH;i++){
           int insert=a[i];
           for(j=i;j>0;j--){
              if(insert<a[j-1]){
                  a[j]=a[j-1];
              }else{
                  break;
              }
           }
           a[j]=insert;
       }
       for(inti=0;i<LENGTH;i++)
           System.out.println(a[i]);
    }
    public static void sort(int a[],int left,int right){
       int j=0;
       for(int i=left+1;i<right-left+1;i++){
           int insert=a[i];
           for(j=i;j>left;j--){
              if(insert<a[j-1]){
                  a[j]=a[j-1];
              }else{
                  break;
              }
           }
           a[j]=insert;
       }
       for(inti=0;i<right-left+1;i++)
           System.out.println(a[i]);
       System.out.println();
    }
}
 

 
package com.datastructure.sort;
 
public class MergeSort {
    public static int LENGTH = 9;
    /* 归并排序
     * 把数组分成LENGTH个小数组，即每个小数组只有一位数，那么这个小数组自身就是排好了的
     * 接着对每两个一位数组进行排序
     * 接着对每两个两位数组进行排序，可能是2||1
     * 最后可得到排好的数组
     *
     * */
    public static void main(String[] args) {
       int a[]= { 4, 1, 5, 8, 9, 3, 7, 6, 2 };
       sort(a);
       pri(a);
    }
    //多开辟了一个与a等长数组
    public static void sort(int[] a) {
       int tmpA[]= new int[LENGTH];
       Msort(a,tmpA, 0, LENGTH - 1);
    }
 
    private static void Msort(int a[], int tmpA[], int left, int right) {
       int center;
       if(left < right) {//实际执行点不好看
           center =(left + right) / 2;
           Msort(a,tmpA, left, center);//已经排好左边的了
           Msort(a,tmpA, center + 1, right);//已经排好右边的了
           merge(a,tmpA, left, center + 1, right);//对排好了的左右子数组进行排序
       }else
           return;//就是说只有一个元素了，这是递归的出口，可以把else删除
    }
 
    private staticvoid merge(int a[], int tmpA[], int lPos, intrPos, int rightEnd) {
       int i,  numElements, tmpPos;
       final int leftEnd;
       leftEnd =rPos - 1;//左数组的右边界
       tmpPos =lPos;
       numElements =rightEnd - lPos + 1;//局部数组的个数
       while(lPos <= leftEnd && rPos <= rightEnd) {
           if(a[lPos] <= a[rPos]) {//等于号应该可以不要
              tmpA[tmpPos++]= a[lPos++];
           } else{
              tmpA[tmpPos++]= a[rPos++];
           }
       }
       while(lPos <= leftEnd) {//等于号是因为lPos比实际的多移动了一位
           tmpA[tmpPos++]= a[lPos++];
       }
       while(rPos <= rightEnd) {
           tmpA[tmpPos++]= a[rPos++];
       }
       //这只是数组的一小部分
       for (i= 0; i < numElements; i++){
           a[rightEnd]= tmpA[rightEnd];
           rightEnd--;
       }
    }
 
    private static void pri(int a[]) {
       for (inti = 0; i < a.length; i++)
           System.out.println(a[i]);
       System.out.println();
    }
}
 

 
 
package com.datastructure.sort;
 
public class SelectSort {
    public staticfinal int LENGTH=9;
    /* 选择排序
     * 跟冒泡排序相同，顶层循环要LENGTH-1趟
     * 每次找到后面比已排序的最后一个还要小的的一个，如果没有就返回已排序的最小的一个
     * 选择排序跟插入排序的区别在于插入排序操作的是已排好序的部分，选择排序操作的是未排好序的部分
     * */
    public static void main(String[] args) {
       int a[]={4,1,9,5,8,3,7,6,2};
       sort(a);
    }
    public static void sort(int a[]){
       for(inti=0;i<LENGTH-1;i++){
           int key;//key代表的就是最小
           key=i;
           for(int j=i+1;j<LENGTH;j++){
              if(a[j]<a[key]){
                  key=j;
              }
           }
           if(i!=key){
              inttmp;
              tmp=a[i];
              a[i]=a[key];
              a[key]=tmp;
           }
       }
       for(inti=0;i<LENGTH;i++)
           System.out.println(a[i]);
    }
}
 

 
 
package com.datastructure.sort;
 
public class ShellSort {
    public static final int LENGTH = 9;
    /* 希尔排序
     * 就是插入排序的升级，插入排序顶层循环步长是1，希尔排序是increament，increament会从LENGTH/2变为1，遍历这个increament
     * 现在的i初始值是increament，终值不变
     * 现在的j初始值不变，终值是>=increament，其实也是不变的
     * 其他完全一样
     *
     *
     * */
    public static void main(String[] args) {
       int a[]= { 4, 1, 9, 5, 8, 3, 7, 6,2};
       sort(a);
    }
 
    public static void sort(int a[]) {
       int j= 0;
       int increament= 0;
       for(increament = LENGTH / 2; increament > 0; increament =increament /2) {// 再对increament的进行插入排序
           for(int i = increament; i < LENGTH; i++) {
              intinsert = a[i];
              for(j = i; j >= increament; j = j - increament) {
                  if(insert < a[j - increament]) {
                     a[j]= a[j - increament];
                  } else{
                     break;
                  }
              }
              a[j] =insert;
           }
       }
       for (int i = 0; i < LENGTH; i++)
           System.out.println(a[i]);
    }
}

 
 
package com.datastructure.sort;
 
public class HeapSort {
    public static final int LENGTH = 9;
 
    /*
     * 堆排序是选择排序的一种
     * 使用了大顶堆的数据结构
     * 首先构建一个大顶堆，大顶堆的长度为LENGTH
     * 第一步将顶元素与最后一个元素交换，然后对0到LENGTH-1数组进行下滤操作
     * 第二步将对元素与倒数第二个元素交换，然后对0到LENGTH-2数组进行下滤操作
     * 第三步将对元素与倒数第三个元素交换，然后对0到LENGTH-3数组进行下滤操作
     * ....
     */
    public static void main(String[] args) {
       int a[]= { 4, 1, 5, 8, 9, 3, 7, 6, 2 };
       sort(a);
    }
 
    public static void sort(int a[]) {
       int i;
       for (i= LENGTH / 2; i >= 0; i--)// 建立一个堆
           percDown(a,i, LENGTH);
       for (i= LENGTH - 1; i > 0; i--) {// 用堆排序
           int tmp;
           tmp =a[0];
           a[0] =a[i];
           a[i] =tmp;
           percDown(a,0, i);// i在这里代表的是长度
       }
       pri(a);
    }
 
    /*
     * 从i往后，与子孙中最大的一个交换
     * 堆的性质有用的仅仅有父元素小于任意子元素
     */
    private static void percDown(int a[], int i, final intLENGTH) {// 下滤，大顶堆
       int Child= 0;
       int tmp;
       for(tmp = a[i]; leftChild(i) < LENGTH; i = Child) {
           Child = leftChild(i);
           if(Child != LENGTH - 1 && a[Child + 1] > a[Child]) // child不是最后一个,右儿子大于左儿子
              Child++;//在儿子之中找个大的
           if(tmp < a[Child])
              a[i] =a[Child];
           else
              break;
       }
       a[i] = tmp;//这里就是交换两个值
    }
 
    private static int leftChild(int i) {
       return2 * i + 1;
    }
 
    private static void pri(int a[]) {
       for (int i = 0; i < a.length; i++)
           System.out.println(a[i]);
       System.out.println();
    }
}
 
 

public class QuickSort {
	static void quicksort(int n[], int left, int right) {
		int index;// dp是index
		if (left >= right)
			return;
		index = partition(n, left, right);
		quicksort(n, left, index - 1);
		quicksort(n, index + 1, right);
	}

	static int partition(int n[], int left, int right) {
		int pivot = n[left];
		while (left < right) {
			while (left < right && n[right] >= pivot)
				right--;
			if (left < right)
				n[left++] = n[right];
			while (left < right && n[left] < pivot)
				left++;
			if (left < right)
				n[right--] = n[left];
		}
		n[left] = pivot;
		return left;
	}

	static int AdjustArray(int s[], int l, int r) {// 返回调整后基准数的位置
		int i = l, j = r;
		int x = s[i]; // s[l]即s[i]就是第一个坑
		while (i < j) {
			while (i < j && s[j] >= x)// 从右向左找小于x的数来填s[i]
				j--;
			if (i < j) {
				s[i] = s[j]; // 将s[j]填到s[i]中，s[j]就形成了一个新的坑
				i++;
			}
			while (i < j && s[i] < x)// 从左向右找大于或等于x的数来填s[j]
				i++;
			if (i < j) {// 避免i==j，等于了有很大问题
				s[j] = s[i]; // 将s[i]填到s[j]中，s[i]就形成了一个新的坑
				j--;
			}
		}
		// 退出时，i等于j。将x填到这个坑中。
		s[i] = x;
		return i;
	}

	public static void main(String[] args) {
		int[] array = { 4, 5, 6, 4, 2, 9, 1, 3, 7, 9, 8 };
		quicksort(array, 0, 10);
		for (int i = 0; i < 10; i++) {
			System.out.println(array[i]);
		}
	}

}