JAVA实现选 4000 择排序、冒泡排序、插入排序、归并排序、希尔排序、堆排序和快速排序
2018-12-19 15:09
519 查看
相关的Java代码:
[code]package com.sort_algorithm; import java.util.Arrays; public class SortSummarize { public static void main(String[] args) { int[] a = { 9, 8, 7, 6, 5, 1, 3, 0, 10, -1, 99, -10 }; int[] b = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 16 }; // 将a的地址也就是引用给了b,使b的引用发生了改变。此时打印,其实打印的是同一个地址下的数组, // 此时a、b都指向a的值,原来的b数组会因为没有被引用到,被JVM的GC回收 b = a; // 将b的地址也就是引用给了a,使a的引用发生了改变。此时打印,其实打印的是同一个地址下的数组, // 此时a、b都指向b的值,原来的a数组会因为没有被引用到,被JVM的GC回收 // a = b; print("选择排序 ", selectSort(a)); print("冒泡排序 ", bubbleSort(b)); print("插入排序 ", insertSort(b)); print("归并排序 ", mergeSort(b)); print("希尔排序 ", shellSort(b)); print("堆排序 ", heapSort(b)); print("快速排序 ", quickSort(b)); } /** * 冒泡排序算法:每次将最小的一个数”浮“上去 最好情况O(n),即数组本身有序 最坏情况O(n^2) */ public static int[] bubbleSort(int[] a) { a = Arrays.copyOf(a, a.length); int count = 0; boolean terminated = false; for (int i = 0; i < a.length - 1 && !terminated; i++) { terminated = true; for (int j = a.length - 2; j >= i; j--) { count++; if (a[j] > a[j + 1]) { swap(a, j + 1, j); terminated = false; } } } System.out.println("冒泡排序比较次数: " + count); return a; } /** * 选择排序:每次选出待排序中最小的一个 */ public static int[] selectSort(int[] a) { a = Arrays.copyOf(a, a.length); int count = 0; for (int i = 0; i < a.length - 1; i++) { int min = a[i]; int minIndex = i; for (int j = i + 1; j < a.length; j++) { count++; if (a[j] < min) { minIndex = j; min = a[j]; } } swap(a, i, minIndex); } System.out.println("选择排序比较次数: " + count); return a; } public static int[] insertSort(int[] a) { a = Arrays.copyOf(a, a.length); int count = 0; for (int i = 1; i < a.length; i++) {// i之前有序,i指向待排序的元素 if (a[i] < a[i - 1]) { int temp = a[i]; int j = i - 1;// j指向当前元素的前一个 for (; j >= 0 && a[j] > temp; j--) { count++; a[j + 1] = a[j]; } a[j + 1] = temp; } } System.out.println("插入排序比较次数: " + count); return a; } private static void swap(int[] a, int i, int j) { if (i == j) return; int temp = a[i]; a[i] = a[j]; a[j] = temp; } /** * 希尔排序 * * @param a * @return */ public static int[] shellSort(int[] a) { a = Arrays.copyOf(a, a.length); int count = 0; int increment = a.length; do { increment = increment / 3 + 1; for (int i = increment; i < a.length; i = i + increment) { if (a[i] < a[i - increment]) { int temp = a[i]; int j = i - increment; for (; j >= 0 && a[j] > temp; j -= increment) { count++; a[j + increment] = a[j]; } a[j + increment] = temp; } } } while (increment > 1); System.out.println("希尔排序比较次数: " + count); return a; } /** * 堆排序 * * @param a * @return */ public static int[] heapSort(int[] a) { a = Arrays.copyOf(a, a.length); int length = a.length; for (int i = length / 2 - 1; i >= 0; i--)// 2*i+1<=length-1,最后一个有左孩子的节点 heapAdjust(a, i, length); for (int i = length - 1; i >= 0; i--) { swap(a, 0, i); heapAdjust(a, 0, i);// } return a; } // 每次将以i为root的子树满足最大堆特性;i指向待调整的节点 private static void heapAdjust(int[] a, int i, int length) { int temp = a[i]; for (int j = 2 * i + 1; j < length; j = 2 * i + 1) {// 刚开始时指向左孩子 if (j + 1 < length && a[j + 1] > a[j])// 如果有做右孩子,且右孩子比左孩子大 j++;// j指向左右孩子中值较大的一个 if (temp >= a[j]) break; a[i] = a[j]; i = j; } a[i] = temp; } public static int[] mergeSort(int[] a) { a = Arrays.copyOf(a, a.length); int[] aux = new int[a.length]; mergeSort(a, aux, 0, a.length - 1); return a; } private static void mergeSort(int[] a, int[] aux, int lo, int high) { if (lo >= high) return; int mid = (lo + high) / 2; mergeSort(a, aux, lo, mid); mergeSort(a, aux, mid + 1, high); merge(a, aux, lo, mid, high); } private static void merge(int[] a, int aux[], int lo, int mid, int high) { for (int i = lo; i <= high; i++) { aux[i] = a[i]; } int lo_h = mid + 1; for (int i = lo; i <= high; i++) { if (lo > mid) a[i] = aux[lo_h++]; else if (lo_h > high) a[i] = aux[lo++]; else { if (aux[lo] <= aux[lo_h]) a[i] = aux[lo++]; else a[i] = aux[lo_h++]; } } } /** * 快速排序 * * @param a * @return */ public static int[] quickSort(int[] a) { a = Arrays.copyOf(a, a.length); quickSort(a, 0, a.length - 1); return a; } private static void quickSort(int[] a, int low, int high) { if (low >= high) return; int partition = partition(a, low, high); quickSort(a, low, partition - 1); quickSort(a, partition + 1, high); } private static int partition(int[] a, int low, int high) { int tempt = a[low]; while (low < high) { while (low < high && a[high] >= tempt) high--; // swap(a,low,high); a[low] = a[high]; while (low < high && a[low] <= tempt) low++; // swap(a,low,high); a[high] = a[low]; } a[low] = tempt; return low; } private static void print(String str, int[] a) { System.out.println(str); for (int i = 0; i < a.length; i++) System.out.print(a[i] + " "); System.out.println("\n"); } /** * 下面是链表的快速排序 * * @param str * @param a */ public static ListNode quickSort(ListNode begin, ListNode end) { // 判断为空,判断是不是只有一个节点 if (begin == null || end == null || begin == end) return begin; // 从第一个节点和第一个节点的后面一个几点 // begin指向的是当前遍历到的最后一个<= nMidValue的节点 ListNode first = begin; ListNode second = begin.next; int nMidValue = begin.val; // 结束条件,second到最后了 while (second != end.next && second != null) {// 结束条件 // 一直往后寻找<=nMidValue的节点,然后与fir的后继节点交换 if (second.val < nMidValue) { first = first.next; // 判断一下,避免后面的数比第一个数小,不用换的局面 if (first != second) { int temp = first.val; first.val = second.val; second.val = temp; } } second = second.next; } // 判断,有些情况是不用换的,提升性能 if (begin != first) { int temp = begin.val; begin.val = first.val; first.val = temp; } // 前部分递归 quickSort(begin, first); // 后部分递归 quickSort(first.next, end); return begin; } /** * 链表的归并排序 */ public ListNode sortList1(ListNode head) { if (head == null || head.next == null) return head; quickSort(null, null); return mergeSort(head); } private ListNode mergeSort(ListNode head) { if (head == null || head.next == null) return head; ListNode mid = getMid(head); ListNode second = mid.next; mid.next = null; ListNode left = mergeSort(head); ListNode right = mergeSort(second); return merge(right, left); } private ListNode merge(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(0); ListNode cur = dummy; while (l1 != null && l2 != null) { if (l1.val <= l2.val) { cur.next = l1; l1 = l1.next; } else { cur.next = l2; l2 = l2.next; } cur = cur.next; } if (l1 != null) cur.next = l1; else cur.next = l2; return dummy.next; } private ListNode getMid(ListNode head) { if (head == null || head.next == null) return head; ListNode slow = head; ListNode faster = head.next; while (faster != null && faster.next != null) { slow = slow.next; faster = faster.next.next; } return slow; } }
ListNode类:
[code]package com.sort_algorithm; public class ListNode { int val; ListNode next; public ListNode(int x) { val = x; next = null; } }
阅读更多
相关文章推荐
- 几种常用的排序算法的分析及java实现(希尔排序,堆排序,归并排序,快速排序,选择排序,插入排序,冒泡排序)
- 元素排序几种常用的排序算法的分析及java实现(希尔排序,堆排序,归并排序,快速排序,选择排序,插入排序,冒泡排序)
- 几种常用的排序算法的分析及java实现(希尔排序,堆排序,归并排序,快速排序,选择排序,插入排序,冒泡排序)
- 冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序java实现
- 插入排序,希尔排序,堆排序,归并排序,快速排序Java实现
- 插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——JAVA实现
- 各种排序算法实现——基数排序、归并排序、插入排序、冒泡排序、选择排序、快速排序、堆排序、希尔排序
- 几种常见排序算法之Java实现(插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序)
- java实现七种排序 (插入排序, 希尔排序, 插入排序, 快速排序, 简单选择排序, 堆排序, 归并排序)
- 【程序员笔试面试必会——排序①】Python实现 冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序
- 牛客网Java刷题知识点之插入排序(直接插入排序和希尔排序)、选择排序(直接选择排序和堆排序)、冒泡排序、快速排序、归并排序和基数排序(博主推荐)
- 插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现
- 排序方法了解一下(冒泡排序、选择排序、堆排序、插入排序、希尔排序、归并排序、快速排序、基数排序)
- Java实现快速排序、归并排序、堆排序和希尔排序
- 七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)
- 冒泡排序,插入排序,快速排序,归并排序,堆排序,选择排序,希尔排序
- 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法, 冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
- 笔试面试最常涉及到的12种排序算法(包括插入排序、二分插入排序、希尔排序、选择排序、冒泡排序、鸡尾酒排序、快速排序、堆排序、归并排序、桶排序、计数排序和基数排序)进行了详解。每一种算法都有基本介绍、算
- 七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)
- 七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)