冒泡排序
稳定性：稳定
- 思路：
每次找到最大的放到最后
public class BubbleSort {
public static int[] bubble(int[] nums){
if(nums == null || nums.length = 2){
return nums;
}
for (int end = nums.length-1; end > 0; end--) {
for (int j = 0; j < end; j++) {
if(nums[j] > nums[j+1]){
swap(nums, j, j+1);
}
}
}
return nums;
}
//交换两个数
public static void swap(int[] arr, int a, int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//冒泡排序
public static void main(String[] args) {
int[] sum = new int[] {4,3,3,2,1};
System.out.println(Arrays.toString(bubble(sum)));
}
}
选择排序
O(N^2)
稳定性：不稳定排序
- 思路：
每次找到最小的放到第一个位置，位置++
第一轮：从0~N-1中选择最小的放到数组的0号位置
第二轮：从1~N-1中选择最小的放到数组的1号位置
…
public class SelectionSort {
//选择排序
public static int[] selectionSort(int[] sum) {
if(sum == null || sum.length < 2){
return sum;
}
for (int i = 0; i < sum.length - 1; i++) {
int minIndex = i;
for (int j = i+1; j < sum.length; j++) {
minIndex = sum[j] < sum[minIndex] ? j : minIndex;
}
swap(sum, i, minIndex);
}
return sum;
}
private static void swap(int[] arr, int a, int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void main(String[] args) {
//选择排序
int[] sum = new int[] {3,2,1,4};
selectionSort(sum);
for(int i = 0;i<sum.length;i++) {
System.out.print(sum[i]);
}
}
}
插入排序
与数据状况有关系
最好情况：时间复杂度：O(N) eg:12345
最坏情况：时间复杂度：O(N^2) eg:54321
稳定性：稳定
空间O（1）
- 思路：
每次排好前N个数，相当于手里面有N张排好序的扑克牌，现在抓到一张新的牌，插入到前面已经排好序的数组中
public class InsertionSortTest {
public static void insertSort(int[] arr){
//假设i前面的已经排好序了，现在要把i位置这个数插入到前面中并且保证前面的数再次排好序
//i从1开始意思是0~0的位置已经排好序了
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >=0 && arr[j] > arr[j + 1] ; j--) {
swap(arr, j, j+1);
}
}
}
public static void swap(int[] arr, int a, int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void main(String[] args) {
int[] a = new int[]{4,2,6,1,3};
InsertionSortTest.insertSort(a);
for (int i : a) {
System.out.print(i);
}
}
}
如何计算时间复杂度
- 先看一个例子：如何求出一个数组的最大的数
我们采用递归的方法
求出数组左边的最大值，在求出右边的最大值，再判断就好，每个左边可以再被分解，递归处理下去
public static int getMax(int[] arr, int L, int R){
if(L == R){
return arr[L];
}
int mid = (L + R) >> 1;
int leftMax = getMax(arr, L, mid);
int rightMax = getMax(arr, mid + 1, R);
return Math.max(leftMax, rightMax);
}
主定理方法：
在我们的这个题中，T（N） = 2*T（N / 2）+ O(1)
那么log(2, 2) > d = 0 ->时间复杂度为：O(N^log(2, 2)) = O(N)
归并排序
- 思路：
数组分成两部分，分别对这两部分排好序，然后再用一个辅助数组，依次把两个数组的最小值放入辅助数组中，最后再把辅助数组的值传回给原数组。
时间复杂度O(N * logN)
空间复杂度O(N)
public class MergeSort {
public static void mergeSort(int[] arr){
if(arr == null || arr.length < 2){
return;
}
mergePrcess(arr, 0, arr.length - 1);
}
public static void mergePrcess(int[] arr, int L, int R){
if(L == R){
return;
}
int mid = L + ((R - L) >> 1);
mergePrcess(arr, L, mid);
mergePrcess(arr, mid + 1, R);
merge(arr, L, mid, R);
}
public static void merge(int[] arr, int L, int mid, int R){
int i = 0;
int p1 = L;
int p2 = mid + 1;
int[] help = new int[R - L + 1];
while (p1 <= mid && p2 <= R) {
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= mid){
help[i++] = arr[p1++];
}
while (p2 <= R){
help[i++] = arr[p2++];
}
for (int j = 0; j < help.length; j++) {
arr[L + j] = help[j];
}
}
public static void main(String[] args) {
int[] arrays = {1,3,4,2,5};
MergeSort.mergeSort(arrays);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);
}
}
}
归并排序案例- 小和问题
- 小和问题
- 在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组 的小和。
- 例子： [1,3,4,2,5] 1左边比1小的数，没有；
- 3左边比3小的数，1； 4左边比4小的数，1、3；
- 2左边比2小的数，1； 5左边比5小的数，1、3、4、2；
- 所以小和为1+1+3+1+1+3+4+2=16
在merge 的过程中看是否左边的数比右边的数小，小的话，这个范围的小和就是所有左边当前的值* 右边值之后的个数
public class SmallSum {
public static int smallSum(int[] arr){
if(arr == null || arr.length < 2){
return 0;
}
return mergeSort(arr, 0, arr.length -1);
}
public static int mergeSort(int[] arr, int L, int R){
if(L == R){
return 0;
}
int mid = L + ((R - L) >> 1);
// int mid = (L + R)/2;
return mergeSort(arr, L, mid) + mergeSort(arr, mid + 1, R) + merge(arr, L, mid, R);
}
public static int merge(int[] arr, int L, int mid, int R){
int i = 0;
int p1 = L;
int p2 = mid + 1;
int[] help = new int[R - L + 1];
int res = 0;
while (p1 <= mid && p2 <= R) {
res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
help[i++] = arr[p1] > arr[p2] ? arr[p2++] : arr[p1++];
}
while (p1 <= mid){
help[i++] = arr[p1++];
}
while (p2 <= R){
help[i++] = arr[p2++];
}
for (int j = 0; j < help.length; j++) {
arr[L + j] = help[j];
}
return res;
}
public static void main(String[] args) {
int[] arr = new int[]{1,3,4,2,5};
System.out.println(SmallSum.smallSum(arr));
}
}
快速排序
时间： O（N log N）
空间：O（log N）
稳定性：不稳定
public class QuickSort {
public static void quickSort(int[] arr, int L, int R){
if(L < R){
// swap(arr, L + (int)(Math.random() * (R - L + 1)), R);//加上这行就是随机快排时间复杂度为O（n*logn）
int[] p = partition(arr, L, R);
quickSort(arr, L, p[0] - 1);
quickSort(arr, p[1] + 1, R);
}
}
public static int[] partition(int[] arr, int L, int R){
int cur = L;
int less = L - 1;
int more = R;
while (cur < more){
if(arr[cur] > arr[R]){
swap(arr, cur, --more);
} else if(arr[cur] < arr[R]){
swap(arr, cur++, ++less);
}else{
cur++;
}
}
swap(arr, R, more);
return new int[]{less + 1, more};
}
public static void swap(int[] arr, int i, int j){
int tem = arr[i];
arr[i] = arr[j];
arr[j] = tem;
}
public static void main(String[] args) {
int[] a = new int[]{3, 5, 7, 8, 5, 5, 9, 10, 4, 3};
QuickSort.quickSort(a, 0, a.length - 1);
for (int i:a) {
System.out.print(i);
}
}
}
荷兰国旗问题
问题描述：给一个数组 与一个num 要求 在数组中【<num | =num | >num】排成这个样子
public class 荷兰国旗 {
public static int[] partition(int[] arr, int L, int R, int num){
int less = L - 1;
int more= R + 1;
int cur = L;
while (cur < more){
if(arr[cur] < num){
swap(arr, cur++, ++less);
}else if(arr[cur] > num){
swap(arr, cur, --more);
}else{
cur++;
}
}
return new int[]{less + 1, more - 1};
}
public static void swap(int[] arr, int i, int j){
int tem = arr[i];
arr[i] = arr[j];
arr[j] = tem;
}
public static void main(String[] args) {
int[] a = new int[]{2, 4,1, 5, 7, 3, 4};
荷兰国旗.partition(a, 0, a.length - 1, 4);
for (int i:a) {
System.out.print(i);
}
}
}
堆排序
时间复杂度O（N logN）
空间O（logN）
建立堆的时间复杂度O(logN) 其实就是与二叉树的高度有关
稳定性： 不稳定
- 首先知道什么是堆
堆是一颗完全二叉树
堆的数据结构：在任意一个子树中，子树的最大值就是这个子树的头节点，这个堆叫做大根堆，也就是这个树的最大值是根节点，小根堆相反
堆有两种操作，一种是建立堆，我们基于数组来创建：
/**
* 给一个数组 创建堆
* @param arr
* @param index
*/
public static void heapInsert(int[] arr, int index){
while (arr[index] > arr[(index - 1) / 2]){
swap(arr, index, (index - 1) / 2);
index = (index - 1) / 2;
}
}
另外一种就是 把堆顶的元素变小，需要动态调整堆的结构
/**
* 当堆内元素的大小变小的时候需要调整堆的结构的时候
* @param arr 给的数组
* @param index 变化的元素位置
* @param size 现在保持堆结构的元素个数
*/
public static void heapify(int[] arr, int index, int size){
int left = 2 * index +1;
while (left < size){
//找到左右两颗子树的最大值
int largest = left +1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
//比较index 与largest 位置上的元素大小
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index){
break;
}
swap(arr, largest, index);
index = largest;
left = 2 * index + 1;
}
}
- 堆排序
利用堆顶是最大值的特点，每次把堆顶元素与最后一个元素交换，这样就拿到一个最大的值，再次调整0~size-1的堆结构
public static void heapSort(int[] arr){
if(arr == null || arr.length == 0){
return;
}
for (int i = 0; i < arr.length; i++) {
//建堆的过程
heapInsert(arr, i);
}
//此时堆的个数就是数组的大小
int size = arr.length;
swap(arr, 0, --size);
while (size > 0){
heapify(arr, 0, size);
swap(arr, 0, --size);
}
}
桶排序 计数排序 基数排序
- 非基于比较的排序 与被比较的数据有关
- 时间复杂度O(N) 空间复杂度O(N)
- 都是稳定排序
扫一扫
209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
