java排序方法
public class Sort {
private static int[] data = new int[] {100,33,1,25,13,56,14,21,6,17,1};
public static void main(String[] args) {
shellSort();
System.out.println(Arrays.toString(data));
}
/**
* 简单选择排序 每一次取得最小值 然后进行交换
*/
public static void select_sort() {
int min = 0;
int length = data.length;
for(int i=0;i data[j]) {
min = j;
}
}
if(i != min) {
int temValue = data[min];
data[min] = data[i];
data[i] = temValue;
}
}
}
/**
* 直接插入排序 如果后面的数 小于前面的数 就开始就行比较 然后赋值
*
*/
public static void insertSort() {
int length = data.length;
int j =0;
int temp = 0;
for(int i=1;i=0&&data[j]>temp;j--) {
data[j+1] = data[j];
}
data[j+1] = temp;
}
}
}
/**
* 希尔排序 每次通过增量来进行排序 每次比较的值都是 a[0] a[0+d] ,a[1] a[1+d] ...进行比较 ，最后一次 increment =1 就是插入排序了
*/
public static void shellSort() {
int length = data.length;
int temp = 0;
int j = 0;
for(int increment = length /2;increment > 0; increment /=2) {
System.out.println("increment:"+increment);
for(int i=increment;i=0; j -=increment) {
if(temp < data[j]) {
data[j+increment] = data[j];
}else {
break;
}
}
data[j+increment] = temp;
}
}
}
}
堆排序
public class HeapSort {
private static void heapSort(int[] arr) {
int len = arr.length -1;
//int i = (len-1)/2 得到节点 这个是根据 完全二叉树的性质来决定的
//int i = (len-1)/2 ; i >=0; i -- 这个意思寻找没一个节点的父节点
//通过左节点 右节点 父节点 3个互相比较 最大的为父节点
for(int i = (len-1)/2 ; i >=0; i --){ //堆构造
heapAdjust(arr,i,len);
}
System.out.println("\n排序之后：");
for(int element : arr){
System.out.print(element+" ");
}
while (len >=0){
swap(arr,0,len--); //将堆顶元素与尾节点交换后，长度减1，尾元素最大 每次替换后的元素 不会再参加排序
heapAdjust(arr,0,len); //再次对堆进行调整
}
}
public static void heapAdjust(int[] arr,int i,int len){
int left,right,j ;
//根据完全二叉树的性质 来算出 左右节点 因为完全二茶树 按照层序编号 如果没有左节点 就肯定没有右节点
while((left = 2*i+1) <= len){ //判断当前父节点有无左节点（即有无孩子节点，left为左节点）
right = left + 1; //右节点
j = left; //j"指针指向左节点"
if(right <= len && arr[left] < arr[right]) //右节点大于左节点
j ++; //当前把"指针"指向右节点
if(arr[i] < arr[j]) //将父节点与孩子节点交换（如果上面if为真，则arr[j]为右节点，如果为假arr[j]则为左节点）
swap(arr,i,j);
else //说明比孩子节点都大，直接跳出循环语句
break;
i = j; //哪一个节点换了 就把该节点 当做父节点 如何保证 左节点 右节点 父节点 最大的为父节点
}
}
public static void swap(int[] arr,int i,int len){
int temp = arr[i];
arr[i] = arr[len];
arr[len] = temp;
}
public static void main(String[] args) {
int array[] = {20,50,20,40,70,10,80,30,60,30};
System.out.println("排序之前：");
for(int element : array){
System.out.print(element+" ");
}
heapSort(array);
System.out.println("\n排序之后：");
for(int element : array){
System.out.print(element+" ");
}
}
}
归并排序
public class MyMergeSort {
public static void main(String[] args) {
int []arr = {9,8,7,15,23,4,120,2,1,23,43,67,434};
sort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void sort(int[] data,int start,int end) {
if(start < end) {
int mid = (start + end) /2;
sort(data,start,mid);//用递归进行分组
sort(data,mid+1,end);//用递归进行分组
//每次比较直 然后进行排序
merge(data,start,mid,mid+1,end);
}
}
public static void merge(int[] data,int start1,int end1,int start2,int end2) {
int[] tem1 = new int[data.length];
int j = 0;
int begin = start1;
int end = end2;
//把2遍的值进行一一比较 因为一开始是1个值 和1个值 进行比较 所以比较的2个数组是有序的
while(start1 <= end1 && start2 <= end2) {
if(data[start1] > data[start2]) {
tem1[j++] = data[start2++];
}else {
tem1[j++] = data[start1++];
}
}
//因为数组有序，如果 还有数据 依次添加
while(start1 <= end1) {
tem1[j++] = data[start1++];
}
//因为数组有序，如果 还有数据 依次添加
while(start2 <= end2) {
tem1[j++] = data[start2++];
}
//进行赋值
j = 0;
for(int i=begin ;i<=end;i++) {
data[i] = tem1[j++];
}
}
}快速排序
public class MyQuickSort {
public static void main(String[] args) {
int i;
int a[] = { 30, 40, 60, 10, 20, 50,33,45,28,23,50,0,1,1,0,100,23,45,87 };
System.out.printf("before sort:");
for (i = 0; i < a.length; i++)
System.out.printf("%d ", a[i]);
System.out.printf("\n");
sort(a, 0, a.length - 1);
System.out.printf("after sort:");
for (i = 0; i < a.length; i++)
System.out.printf("%d ", a[i]);
System.out.printf("\n");
}
public static void sort(int[] data,int start,int end) {
if(start < end) {
int left = start;
int right = end;
int compareValue = data[start];
while(left < right) {
//从左边寻找小于compareValue1的值
while(right > left && data[right] > compareValue ) {
right--;
}
if(right > left) {
//和左边的数据进行交换
data[left++] = data[right];
}
//在右边寻找大于compareValue的值
while(left < right && data[left] < compareValue) {
left++;
}
if(left < right) {
//和右边的数据 进行交换 ，如果没有进行交换数据 那么data[right]一开始的数据 就重复了
//在上面的条件left < right可以看出 此时 left = right的
//所以下面data[right] = compareValue 用来赋值 保证数据的正确性
data[right--] = data[left];
}
}
data[right] = compareValue;
sort( data, start, right-1) ;
sort( data, right+1, end) ;
}
}
}