【算法与数据结构】冒泡、插入、归并、堆排序、快速排序的Java实现代码
2015-03-29 10:53
866 查看
详细过程就不表了,看代码吧
import java.util.Arrays; public class Sort { static int swapTimes=0; public static void main(String[] args) { int[] numbers = { 7, 6, 5, 3, 1, 8, 9, 7, 1, 2 ,5}; //*** BubbleSort Test *** //bubbleSort(numbers); //*** InsertSort Test *** //insertSort(numbers); //*** MergeSort Test *** //mergeSort(numbers); //*** HeapSort Test *** //heapSort(numbers); //*** QuickSort Test *** quickSort(numbers); System.out.println("result:"+Arrays.toString(numbers)); } /* * 插入排序 */ public static void insertSort(int[] numbers) { System.out.println("InsertSort:"+Arrays.toString(numbers)); if (numbers == null) { System.out.println("Invalid input!"); return; } for (int i = 1; i < numbers.length; i++) { int temp=numbers[i]; int j=i-1; for (; j >= 0&&numbers[j]>temp; j--) { //这个数大于比较数,就把这个数右移 numbers[j + 1] = numbers[j]; System.out.println(Arrays.toString(numbers)+"---temp="+temp); } numbers[j+1]=temp; //把比较数赋值到正确位置 System.out.println(Arrays.toString(numbers)); } } /* * 冒泡排序 */ public static void bubbleSort(int[] numbers) { System.out.println("BubbleSort:"); if (numbers == null) { System.out.println("Invalid input!"); return; } for (int i = numbers.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { if (numbers[j] > numbers[j + 1]) { swap(numbers, j, j + 1); } } } System.out.println("result:"); } /* * 归并排序 */ public static void mergeSort(int[] numbers){ if(numbers==null){ System.out.println("Invalid input!"); return; } mergeSort(numbers,0,numbers.length-1); } private static void mergeSort(int[] numbers, int start, int end) { if(start>=end){ return; } int mid=(start+end)>>1; mergeSort(numbers, start, mid); mergeSort(numbers, mid+1, end); merge(numbers,start,mid,end); System.out.println(Arrays.toString(numbers)+"---mid="+mid); } /* * 合并两个有序数组 */ private static void merge(int[] numbers, int start, int mid, int end) { int leftLength=mid-start+1; int rightLength=end-mid; int[] leftNumbers=new int[leftLength]; int[] rightNumbers=new int[rightLength]; for (int i = 0; i < leftLength; i++) {//将左边的元素赋给left数组 leftNumbers[i]=numbers[start+i]; } for (int j = 0; j < rightLength; j++) {//同理 rightNumbers[j]=numbers[mid+j+1]; } int pLeft=0; int pRight=0; for(int index=start;index<=end;index++){//开始merge左右数组 if(pLeft==leftLength){ //当left数组合并完了,就直接赋值right数组 numbers[index]=rightNumbers[pRight++]; }else if(pRight==rightLength){ numbers[index]=leftNumbers[pLeft++]; }else{ //左右数组都没赋值完,就要比较大小 if(leftNumbers[pLeft]<=rightNumbers[pRight]){ numbers[index]=leftNumbers[pLeft++]; }else{ numbers[index]=rightNumbers[pRight++]; } } } } /* * 堆排序 */ public static void heapSort(int[] numbers){ if(numbers==null){ System.out.println("Invalid input!"); return; } int[] heap=buildHeap(numbers); //构造小顶堆 System.out.println("build Heap:"+Arrays.toString(heap)); int index=0; while(!isHeapEmpty(heap)){ //注意,这里不能在前面的index++,因为会先算左括号内的++,造成传入的index+1 numbers[index]=popHeapTop(heap,index++); } } //将堆顶元素pop出来 private static int popHeapTop(int[] heap,int index) { int temp=heap[0]; int end=heap.length-1-index; heap[0]=heap[end]; //将最后一个数移至堆顶 heap[end]=Integer.MAX_VALUE; adjustHeap(heap, 0); //调整堆 System.out.println("current Heap:"+Arrays.toString(heap)); return temp; } private static boolean isHeapEmpty(int[] heap) { if(heap[0]==Integer.MAX_VALUE){ return true; } return false; } /* * 构造小顶堆 */ private static int[] buildHeap(int[] numbers) { int[] heap=new int[numbers.length]; for(int i=0;i<heap.length;i++){ heap[i]=numbers[i]; } for(int j=(heap.length>>1)-1;j>=0;j--){ //从有孩子的结点开始,从底向上维护堆 adjustHeap(heap,j); } return heap; } /* * 维护堆 */ private static void adjustHeap(int[] heap, int j) { int left=j<<1; int right=(j<<1)+1; int largest=j; if(left<heap.length //该左孩子下标必须在数组内 &&heap[left]!=Integer.MAX_VALUE //该元素必须未被覆盖 &&heap[j]<heap[left]){ largest=left; } if(right<heap.length &&heap[right]!=Integer.MAX_VALUE &&heap[largest]<heap[right]){ largest=right; } if(largest!=j){ swap(heap, j, largest); adjustHeap(heap, largest); //继续往下调整 } } /* * 快速排序 */ public static void quickSort(int[] numbers){ if(numbers==null){ System.out.println("Invalid input!"); return; } System.out.println("QuickSort:"); quickSort(numbers,0,numbers.length-1); } private static void quickSort(int[] numbers, int start, int end) { if(start<end){ int mid=patition(numbers,start,end); quickSort(numbers, start, mid-1); quickSort(numbers, mid+1, end); } } /* * 选一个数,将小于它的数放在左边,大于它的放在右边 */ private static int patition(int[] numbers, int start, int end) { int small=start-1; int index=start; int temp=numbers[end]; //选择数组最后一个元素作为比较数 while(index<=end){ if(numbers[index]<temp){ small++; if(index!=small){ swap(numbers, small, index); } } index++; } swap(numbers, small+1, end); return small+1; } /* * 交换数组的两个元素 */ private static void swap(int[] numbers, int a, int b) { int temp = numbers[a]; numbers[a] = numbers[b]; numbers[b] = temp; System.out.println("current numbers:" + //记录交换次数 ""+Arrays.toString(numbers)+"----swap times:"+(++swapTimes)); } }
相关文章推荐
- 冒泡、插入、归并、堆排序、快速排序的Java实现代码
- Java-十种内部排序实现(选择,冒泡,插入,希尔,堆,归并,快速,基数,计数,桶)及代码下载
- Java实现七大算法(插入\希尔\选择\堆排\冒泡\快排\归并)
- Java实现的排序算法及比较 [冒泡,选择,插入,归并,希尔,快排]
- c++实现数据结构中的各种排序方法:直接插入、选择,归并、冒泡、快速、堆排序、shell排序
- 排序算法复习(Java实现):插入,冒泡,选择,Shell,快速排序, 归并排序,堆排序,桶式排序,基数排序
- java排序算法代码实现(冒泡、选择、插入)
- 一步步学习数据结构和算法之快速排序效率分析及java实现
- 排序算法复习(Java实现)(一): 插入,冒泡,选择,Shell,快速排序
- 《冒泡,选择,插入,归并,希尔,快速》排序算法java实现一览
- T-SQL实现数据结构中的冒泡算法和快速排序
- 自己动手实现数据结构——排序算法1(冒泡、插入、归并、简单选择)(C++实现)
- 一步步学习数据结构和算法之直接插入排序效率分析及java实现
- 一步步学习数据结构和算法之堆排序效率分析及java实现
- 基础排序算法,java实现(快速,冒泡,选择,堆排序,插入)
- 排序算法复习(Java实现)(一): 插入,冒泡,选择,Shell,快速排序
- 排序算法复习(Java实现)(三): 插入,冒泡,选择,Shell,快速排序
- 浅谈冒泡,插入,选择,快速排序等思想和代码实现
- 插入排序、选择排序、归并排序、堆排序、快速排序的JAVA实现
- Java实现数据排序(冒泡、选择、插入、快速排序)---方法持续更新中