冒泡排序：
1 //冒泡排序 2 //时间复杂度为O(N^2)，空间复杂度为O（N） 3 public class BubbleSort { 4 public static void bubbleSort(int[] arr) { 5 if (arr.length == 0 || arr.length == 1) { 6 return; 7 } else { 8 // 随着每轮比较的进行，都有一个大数沉到后面排好序，因此外层的循环长度应该递减 9 for (int end = arr.length - 1; end > 0; end--) { 10 for (int i = 0; i < end; i++) { 11 if (arr[i] > arr[i + 1]) { 12 swap(arr, i, i + 1); 13 } 14 } 15 } 16 } 17 18 } 19 20 static void swap(int[] arr, int i, int j) { 21 // 不利用第三个变量交换两变量的位置。1.a和同一个数异或运算两次得到a本身 2.异或运算满足交换律 22 arr[j] = arr[j] ^ arr[i]; 23 arr[i] = arr[j] ^ arr[i]; 24 arr[j] = arr[j] ^ arr[i]; 25 } 26 27 public static void main(String[] args) { 28 int[] a = {2, 1, 7, 10, 3, 9, 5, 4, 6, 8}; 29 bubbleSort(a); 30 for(int i:a) 31 System.out.print(i+","); 32 } 33 }
插入排序：
1 //插入排序 2 //复杂度和数据状况有关系，如果本来数组的有序性就比较好则复杂度低 3 public class InsertSort { 4 public static void insertSort(int[] arr) { 5 if (arr == null || arr.length < 2) { 6 return; 7 } else { 8 for (int i = 1; i < arr.length; i++) { 9 //如果数组的有序性比较好，如1，2，3，4，5，则arr[j + 1] < arr[j]这个条件可以使得比较提前终止， 10 //如果数组刚好是逆序的，如5，4，3，2，1，则需要从j一直比较到i=0； 11 for (int j = i - 1; j >= 0 && arr[j + 1] < arr[j]; j--) { 12 swap(arr, j, j + 1); 13 } 14 } 15 } 16 } 17 18 static void swap(int[] arr, int i, int j) { 19 arr[j] = arr[j] ^ arr[i]; 20 arr[i] = arr[j] ^ arr[i]; 21 arr[j] = arr[j] ^ arr[i]; 22 } 23 24 public static void main(String[] args) { 25 int[] a = {2, 1, 7, 10, 3, 9, 5, 4, 6, 8}; 26 insertSort(a); 27 for (int i : a) 28 System.out.print(i + ","); 29 } 30 }
选择排序：
1 //选择排序 2 //时间复杂度为O(N^2),空间复杂度为O(1) 3 public class SelectionSort { 4 public static void selectionSort(int[] arr) { 5 if (arr == null || arr.length < 2) { 6 return; 7 } else { 8 // 每轮都从未排序的数列中取出一个数，将其与后面所有未排序的数作比较，得到这些未排序数列里面的最小数，将它换到已排好序数列的后面，并扩大已排好序数列的范围。 9 for (int i = 0; i < arr.length - 1; i++) { 10 int minIndex = i; 11 // i = 0作为第一个已排序列 12 for (int j = i + 1; j < arr.length; j++) { 13 minIndex = arr[j] < arr[minIndex] ? j : minIndex; 14 } 15 swap(arr, i, minIndex); 16 } 17 } 18 } 19 20 static void swap(int[] arr, int i, int j) { 21 // 此处不能用异或来完成交换，因为如果i=j, 两个相同的数异或等于0，“arr[j] = arr[j] ^ arr[i]”会将arr[i]和arr[j]同时置为0，这样就丢失了所有信息。 22 // 如果i和j不相等，但a[i]==a[j]是可以完成异或交换功能的，因为0和任何数异或等于其本身 23 // arr[j] = arr[j] ^ arr[i]; 24 // arr[i] = arr[j] ^ arr[i]; 25 // arr[j] = arr[j] ^ arr[i]; 26 int tmp = arr[i]; 27 arr[i] = arr[j]; 28 arr[j] = tmp; 29 } 30 31 public static void main(String[] args) { 32 int[] a = {2, 1, 7, 10, 3, 9, 5, 4, 6, 8}; 33 selectionSort(a); 34 for (int i : a) 35 System.out.print(i + ","); 36 } 37 }
归并排序：
1 //归并排序 2 //时间复杂度O（NlogN）,空间复杂度O（N） 3 //分治+外排的方法 4 public class MergeSort { 5 public static void mergeSort(int[] arr) { 6 if (arr == null || arr.length < 2) 7 return; 8 else 9 sortProcess(arr, 0, arr.length - 1); 10 } 11 12 private static void sortProcess(int[] arr, int L, int R) { 13 if (L == R) 14 return; 15 else { 16 int mid = L + ((R - L) >> 1); 17 // 根据Master公式求其时间复杂度： 18 sortProcess(arr, L, mid);//T(N/2) 19 sortProcess(arr, mid + 1, R);//T(N/2) 20 merge(arr, L, mid, R);//O(N) 21 // 根据Master公式，其时间复杂度为T(N) = 2T(N/2)+O(N) = N*logN 22 } 23 } 24 25 //融合两个有序数组，使之成为一个更大的有序数组的方法，叫做外排 26 private static void merge(int[] arr, int l, int mid, int r) { 27 // 空间复杂度O(体现在需要一个大小为数据量N的辅助数组help上) 28 int[] help = new int[r - l + 1]; 29 int i = 0; 30 int p1 = l; 31 int p2 = mid + 1; 32 while (p1 <= mid && p2 <= r) 33 help[i++] = arr[p1]<=arr[p2]?arr[p1++]:arr[p2++]; 34 // 两个必有且只有一个越界 35 while(p1<=mid) 36 help[i++] = arr[p1++]; 37 while(p2<=r) 38 help[i++] = arr[p2++]; 39 40 i = 0; 41 while(l<=r) 42 arr[l++] = help[i++]; 43 } 44 45 public static void main(String[] args) { 46 int[] a = {2, 1, 7, 10, 3, 9, 5, 4, 6, 8}; 47 mergeSort(a); 48 for(int i:a) 49 System.out.print(i+","); 50 } 51 }
快速排序:
import java.util.Arrays; //快排 //时间复杂度最好为O(NlogN). 数组逆序的时候最差，时间复杂度为O(N^2),可以通过随机快排的方式使得其长期时间复杂度期望为O（N*logN） //空间复杂度最好为O（logN）,数组逆序的时候最差，空间复杂度为O(N)，额外空间主要是每次partition函数返回的二元数组造成的。 //通过随机快排的方式使得其长期时间复杂度期望为O（NlogN） //所有递归函数都可以改为非递归版本，因为递归的本质行为是系统在帮我们压栈。改为非递归就是改成我们自己来压栈 // 在工程上是不允许递归行为存在的，因为递归过深可能会导致系统栈爆满，系统不稳定。因此工程上的快排都是非递归版本实现的。 //库函数都是高度优化过的 public class QuickSort { static void quickSort(int[] arr, int L, int R) { if (L < R) { // 随机快排， 每次将中间随机一个数和数列最后一个元素交换位置，防止逆序数列产生差的结果 swap(arr, L + (int) (Math.random() * (R - L + 1)), R); int[] p = partition(arr, L, R); quickSort(arr, L, p[0] - 1); quickSort(arr, p[1] + 1, R); } } //分隔函数，此函数以arr[R]上的元素为标准，把arr上L到R的元素调整成大于arr[R]的都放他左边，小于arr[R]的都放他右边 //由于数组中可能有多个等于分隔标准的元素，这个函数的返回值时调整完毕时，这若干个等于分隔标准的元素的左边界下标和有边界下标。 //当只有一个等于分隔标准的元素存在时，左边界 = 有边界 = 该元素下标 static int[] partition(int[] arr, int L, int R) { int less = L - 1;//less表示小于分隔标准arr[R]的元素构成的区域的右边界 int more = R;//more表示大于分隔标准arr[R]的元素构成的区域的左边界 int cur = L; int base = arr[R]; // 以arr[R]作为基准，有了随机快排，这里的arr[R]被重新洗牌 // 这里一次性处理了大于基准等于基准和小于基准的三种情况，速度比传统快排要快--属于三路快排 while (cur < more) { if (arr[cur] < base) { // cur++,因为换到cur位置上的一定是比基准arr[R]小的数，直接将其扩到less范围去，且cur指向下一位置 swap(arr, ++less, cur++); } else if (arr[cur] > base) { //交换到cur位置上的数大小位置，交换过去的数一定大于基准arr[R]， 故more--,将其扩到more区域， 但cur位置不变 //因为从--more交换过来的元素大小不确定，还需要判断 swap(arr, --more, cur); } else { //当前位置和基准arr[R]相等，不扩到less区域和more区域，放在相等区域 cur++; } } //最后将基准交换到more区域的下一位置 swap(arr, more, R); // 返回相等区域下标,注意此时more位置上是交换过来的基准值，不用加1 return new int[]{less + 1, more}; } static void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } public static void main(String[] args) { int a[] = {49, 38, 65, 97, 76, 13, 27, 49}; quickSort(a, 0, a.length - 1); System.out.println(Arrays.toString(a)); } }
堆排序：
import java.util.Arrays; /* *堆就是用数组实现的二叉树，所有它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。 * 堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式。 在最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这个属性对堆中 的每一个节点都成立。 建堆和调整的过程都要遵循堆的这个属性 * */ //堆排序 //堆是完全二叉树 //二叉树的底层可以用线性的结构来储存，也就是说可以用数组来储存一个二叉树，通过数组中下标的关系来表示这个堆。 //设完全二叉树的一个节点在数组中的下标为i, 可以用简单二叉树来助记: 父节点1的左孩子是3-->2i+1, 右孩子是4-->2i+2; //则其父节点的下标应该为(i-1)/2,其左孩子节点应该是2*i+1, 其右孩子节点应该为2*i+2 //特例法: 0 的左孩子是1，右孩子是2: 0 = (1-1)/2 = (2-1)/2; 2*0+1 = 0; 2*0+2=2; public class HeapSort { //先建堆(使用heapInsert将数组所有元素排成堆) //再输出，每次输出堆顶元素(把堆顶和堆尾交换)，再使用heapify调整堆顶元素使之重新符合大根堆 static void heapSort(int[] arr) { if (arr == null || arr.length < 2) return; else //堆插入 for (int i = 0; i < arr.length; i++) heapInsert(arr, i); //输出元素 int heapSize = arr.length;//堆的大小等于数组的长度 //交换堆顶和最后一个元素 swap(arr, 0, --heapSize); while (heapSize > 0) { heapify(arr, 0, heapSize); swap(arr, 0, --heapSize); } } //本函数的作用将数组中位置为index的元素插入到堆中正确位置（对大根堆的任意节点，它都小于它的父节点） // --index位置的数不能比它的父节点大，如果比父节点大就交换它和父节点的位置 static void heapInsert(int[] arr, int index) { while (arr[(index - 1) / 2] < arr[index]) {//如果index=0, -1/2=0是根节点 swap(arr, index, (index - 1) / 2); index = (index - 1) / 2; } } //如果堆中有某个元素变小了（变得比它的字节点小了，因此不符合大根堆的性质了），就要将这个元素下沉以保持大根堆的属性 //本函数的作用是当index位置上的元素变小了，就要调整它的位置保持大根堆。 static void heapify(int[] arr, int index, int heapSize) { int left = index * 2 + 1;//在用数组存储的堆中，节点i的左孩子节点是2*i+1, 右节点是2*i+2; //这里heapSize是最后一个元素，做堆排的时候，因为是从堆顶交换来的最大值，所以重新heapify要把它排除在外； while (left < heapSize) { int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left; largest = arr[index] > arr[largest] ? index : largest; if (largest == index) break; swap(arr, largest, index); index = largest; left = index * 2 + 1; } } static void swap(int[] arr, int i, int j) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; } public static void main(String[] args) { int a[] = {49, 38, 65, 97, 76, 13, 27, 49}; heapSort(a); System.out.println(Arrays.toString(a)); } }
希尔排序：
基数排序：