说明:观看B站视频记录笔记(马士兵说)
数据结构绪论
什么是数据结构
- Data Structure
- 存储数据的不同方式(顺序表、链表)
什么是算法
- 同一问题的不同解决方法
- 算法往往是针对特定的数据结构(数组和链表的插入方法)
如何测算算法的优劣
- 时间测算
java
中记录算法开始的时间before=System.currentTimeMillis(),算法结束时记录一个时间,然后相减,一次算法可能不好比较,用循环来凑。比如循环10000
次。- 计算算法时间差
- 幅度不够循环来凑
- 空间测算
用到的额外空间
Big O
- 时间 -问题(数据)规模
- 不考虑必须要做的操作
循环、赋初值、程序初始化… - 不考虑常数项
- 不考虑低次项
作业:
回答:O(1)、O(N)、O(N)、O(N)
- 不考虑必须要做的操作
排序
常见排序:
插排、堆排、快排、归并四种必须记
选泡插, 快归堆希统计基, 恩方恩老恩一三, 对恩加K恩乘K, 不稳稳稳不稳稳, 不稳不稳稳稳稳!
选择排序
最简单但是最没用的排序算法,也有优化空间
如何计算时间和空间复杂度
算法的验证-随机谁生成器、对数器
写算法程序的哲学
package mashibing_class.sorts;
public class SeletcionSort {
/*
* 如何写程序:
* 1、由简单到复杂
* 1. 验证一步走一步
* 2. 多打印中间结果
* 2、先局部后整体
* 没思路时先细分
* 3、先粗糙后精细
* 1. 变量更名
* 2.语句合并
* 3.边界处理
* */
public static void main(String[] args) {
int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
for(int i =0;i<arr.length-1;i++){
int minPos=i;
for (int j=i+1;j<arr.length;j++){
// minPos = arr[j] < arr[minPos] ? j : minPos;
if (arr[j]<arr[minPos])
minPos=j;
}
swap(arr,i,minPos);
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static void swap(int []arr,int i,int j){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
/*
* 选择排序还可以优化,可以一次循环找到一个最小值和最大值,最小值放到最前面,最大值放到最后面。循环次数少一半。
* */
}
对数器
package mashibing_class.sorts;
import java.util.Arrays;
import java.util.Random;
public class DataChecker {
/*
* 验证算法:对数器
* 如何验算算法是否正确?
* 1. 肉眼观察
* 2. 产生足够多的随机样本
* 3. 用确定正确的算法计算样本结果
* 4. 对比被验证算法的结果
* */
static int[] generateRandomArray() {
Random r = new Random();
int[] arr = new int[10000];
for (int i = 0; i < arr.length; i++) {
arr[i] = r.nextInt(10000);
}
return arr;
}
static void check() {
int[] arr = generateRandomArray();
int[] arr2 = new int[arr.length];
System.arraycopy(arr, 0, arr2, 0, arr.length);//数组拷贝一份
Arrays.sort(arr);
SeletcionSort.sort(arr2);
boolean same = true;
for (int i = 0; i < arr2.length; i++) {
// same = arr[i] != arr2[i] ? false : same;
if (arr[i]!=arr2[i]) same=false;
}
System.out.println(same == true ? "right" : "wrong");
SeletcionSort.printResult(arr2);
}
public static void main(String[] args) {
check();
}
}
选择排序作业
冒泡排序
package mashibing_class.sorts;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {9, 3, 1, 4, 6, 8, 7, 5, 2};
sort(arr);
//sort2(arr);
printResult(arr);
}
static void sort(int[] arr) {
// for (int i = 0; i <arr.length-1;i++)
// //最大冒到尾部
// for (int j=0;j<arr.length-i-1;j++){
// if (arr[j]>arr[j+1])
// swap(arr,j,j+1);
// }
for (int i=0;i<arr.length-1;i++)
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) swap(arr, j, j - 1);
}
}
static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static void printResult(int[] arr) {
for (int i=0;i<arr.length;i++)
System.out.print(arr[i]+" ");
}
static void sort2(int[]arr){
for(int i=arr.length-1;i>0;i--)
findMax(arr,i);
}
static void findMax(int[]arr,int n){
//前n个数求最大值
for(int i=0;i<n;i++)
if (arr[i]>arr[i+1]) swap(arr,i,i+1);
}
}
冒泡排序最好的时间复杂度是O(n),以上算法分析均是O(n^2),因此冒泡还有优化代码
。
答:加入判断数组是否已经有序,直接遍历一次,不交换即是O(n)
插入排序(简单排序中最后一种排序)
对于基本有序的数组最好用
稳定
package mashibing_class.sorts;
public class InsertSort {
public static void main(String[] args) {
int[] arr = {9, 3, 1, 4, 6, 8, 7, 5, 2};
sort(arr);
printResult(arr);
}
static void sort(int[] arr) {
//从index=1开始比较前面一个数大小,index之前都有序
//arr[index]<arr[index-1],arr[index-1]往后挪;index--,直到arr[index]>=arr[index-1]
int i, j;
for (i = 1; i < arr.length; i++) {
int insertNum = arr[i];
// System.out.println("i: " + i + " inserNum: " + insertNum);
for (j = i; j > 0; j--)
if (insertNum < arr[j - 1])
arr[j] = arr[j - 1];
else break;
// System.out.println("j="+j);
arr[j] = insertNum;
}
// 马老师代码
// for (int m=1;m<arr.length;m++)
// for (int n=m;n>0;n--)
// if (arr[n]<arr[n-1])
// swap(arr,n,n-1);
}
static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static void printResult(int[] arr) {
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i] + " ");
}
}
插入排序作业
插入排序比冒泡快一半,一般也比选择排序好
简单排序算法总结
- 冒泡
基本不用,太慢;最好O(n),最差(n^2). - 选择
基本不用,不稳 - 插入
样本小且基本有序的时候效率比较高
希尔排序
更加高级的排序,希尔排序是插入排序的一个改进版
package mashibing_class.sorts;
public class ShellSort {
public static void main(String[] args) {
//间隔大时,移动次数少
//间隔小时,移动距离短
//因此比插入排序好
/*
* 希尔排序
* 1.选择一个间隔,每一个组排好序
* 2.选择更小的间隔,每个组排好序
* 3.直到间隔为1,插入排序(此时基本有序,插入排序效率高)
* */
int[] arr = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
// sort(arr);
sort(arr);
printResult(arr);
}
static void sort(int[] arr) {
// int gap = 4;
// for (int gap = 4; gap > 0; gap /= 2)
for (int gap = arr.length >> 1; gap > 0; gap /= 2)
//普通插入排序-->有间隔排序
for (int i = gap; i < arr.length; i++) {
for (int j = i; j > gap - 1; j -= gap) {
if (arr[j] < arr[j - gap])
swap(arr, j, j - gap);
}
}
}
static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static void printResult(int[] arr) {
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i] + " ");
}
}
Knuth序列
写程序时,不熟悉可以先试试固定间隔gap,然后二分(希尔思想)===》进一步改进的序列Knuth序列
。
- h=1 最小为1
- h=3*h+1 后面的序列
1,4,13…
static void sort(int[] arr) {
// int gap = 4;
// for (int gap = 4; gap > 0; gap /= 2)
// for (int gap = arr.length >> 1; gap > 0; gap /= 2)
int h = 1;
while (h <= arr.length / 3) {
h = h * 3 + 1;
}
//普通插入排序-->有间隔排序
for (int gap=h;gap>0;gap=(gap-1)/3)
for (int i = gap; i < arr.length; i++) {
for (int j = i; j > gap - 1; j -= gap) {
if (arr[j] < arr[j - gap])
swap(arr, j, j - gap);
}
}
}
希尔排序复杂度
时间复杂度 最好O(n^1.3)
空间复杂度O(1)
希尔排序作业
归并排序
递归
package mashibing_class.sorts;
public class Recursion {
public static void main(String[] args) {
//递归
System.out.println();
}
static long f(int n) {
if (n < 1)
return -1;
if (n == 1)
return 1;
return n + f(n - 1);
}
}
归并排序
static void merge(int[] arr) {
int mid = arr.length >> 1;
int i = 0, j = mid + 1;
int[] helpArray = new int[arr.length];
int k = 0;
while (i <= mid && j < =arr.length) {
// if (arr[i] <= arr[j])
// helpArray[k++] = arr[i++];
// else helpArray[k++] = arr[j++];
helpArray[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
}
while (i <= mid) helpArray[k++] = arr[i++];
while (j < arr.length) helpArray[k++] = arr[j++];
System.out.println("\nmerge后:");
printResult(helpArray);
System.out.println();
}
package mashibing_class.sorts;
public class MergeSort {
//TIM Sort
//Java 内置排序
public static void main(String[] args) {
int[] arr = {1, 4, 6, 7, 10, 11, 3, 5, 8, 9};
// int[] arr = {1,4,7,8,3,6,9};
System.out.println("merge前:");
printResult(arr);
// sort(arr);
sort(arr,0,arr.length);
System.out.println("\nmerge后:");
printResult(arr);
}
static void sort(int[] arr,int left,int right) {
// merge(arr);
// merge2(arr,0,arr.length>>1,arr.length);
//base case
if (left==right) return;
//分成两半,
int mid=left+(right-left)/2;//防止越界
// 左边排序,
sort(arr,left,mid);
// 右边排序
sort(arr,mid+1,right);
merge2(arr,left,mid,right);
}
static void merge(int[] arr) {
int mid = arr.length >> 1;
int i = 0, j = mid + 1;
int[] helpArray = new int[arr.length];
int k = 0;
while (i <= mid && j < arr.length) {
// if (arr[i] <= arr[j])
// helpArray[k++] = arr[i++];
// else helpArray[k++] = arr[j++];
helpArray[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
}
while (i <= mid) helpArray[k++] = arr[i++];
while (j < arr.length) helpArray[k++] = arr[j++];
System.out.println("\nmerge后:");
printResult(helpArray);
System.out.println();
}
static void merge2(int[]arr,int left,int mid,int right){
//上面merge不够灵活
int []helpArray=new int[right-left];
int i=left,j=mid+1,k=0;
while (i<=mid&&j<right)
helpArray[k++]=arr[i]<arr[j]?arr[i++]:arr[j++];
while (i<=mid) helpArray[k++]=arr[i++];
while (j<right) helpArray[k++]=arr[j++];
// System.out.println("\nmerge后:");
// printResult(helpArray);
// System.out.println();
for (int m=0;m<helpArray.length;m++){
arr[left+m]=helpArray[m];
}
}
static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
static void printResult(int[] arr) {
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i] + " ");
}
}
java对象排序
- 对象排序一般要求稳定(TimSort改进的排序)
快速排序
package mashibing_class.sorts;
public class QuickSort {
public static void main(String[] args) {
int[] arr = {9, 3, 1, 4, 10, 6, 8, 7, 5, 11};
System.out.println("排序前:");
printArray(arr);
sort(arr, 0, arr.length - 1);
System.out.println("\n排序后:");
printArray(arr);
}
static void sort(int[] arr, int left, int right) {
if (left > right) return;
int mid = partition(arr,left,right);
// System.out.println("mid"+mid);;
sort(arr,left,mid-1);
sort(arr,mid+1,right);
}
static int partition(int[] arr, int left, int right) {
// int pivot = arr[mid];
int pivot=arr[right];
int rightBound=right;
// System.out.println("\nrightBound:"+rightBound);
// System.out.println("pivot:" + pivot);
while (left < right) {
while (left < right && arr[left] <= pivot) left++;
while (left < right && arr[right] >= pivot) right--;
if (left<right)
swap(arr, left, right);
// System.out.println("left:"+left+" right:"+right);
}
// System.out.println(arr[left]+" "+arr[rightBound]);
swap(arr,left,rightBound);
return left;
}
static void swap(int[] arr, int i, int j) {
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
//异或运算交换两个数
// arr[i] = arr[i] ^ arr[j];
// arr[j] = arr[i] ^ arr[j];
// arr[i] = arr[j] ^ arr[i];
}
static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i] + " ");
}
}
双轴快排
选两个数,第一个数比第二数小。分为三个区域,小于第一个区域的数,介于中间的区域,大于第二个数的区域
less,mid,more
计数排序
- 非比较排序
- 桶思想的一种
算法思想
- 量大但是范围小
- 某大型企业数万名员工年龄排序
- 如何快速得知高考名次(腾讯面试)
package mashibing_class.sorts;
import java.util.Arrays;
public class CountSort {
public static void main(String[] args) {
int[] arr = {2, 4, 2, 3, 7, 1, 1, 0, 0, 5, 6, 9, 8, 5, 7, 4, 0, 9};
int[] result = sort(arr);
System.out.println(Arrays.toString(result));
}
static int[] sort(int[] arr) {
int[] result = new int[arr.length];
int[] count = new int[10];
for (int i = 0; i < arr.length; i++) {
count[arr[i]]++;
}
System.out.println(Arrays.toString(count));
for (int i = 0, j = 0; i < count.length && j < result.length; i++) {
while ((count[i]--)>0)
result[j++]=i;
}
return result;
}
}
现在程序有两个小bug:
- 范围不是从零开始
- 稳定性,现在是不稳定的。(用累加数组进行排序)
static int[] sort(int[] arr) {
int[] result = new int[arr.length];
int[] count = new int[10];
int[] reverseCount = new int[10];
for (int i = 0; i < arr.length; i++) {
count[arr[i]]++;
}
System.out.println(Arrays.toString(count));
//累加数组
for (int j = 1; j < count.length; j++) {
count[j] = count[j] + count[j - 1];
}
System.out.println(Arrays.toString(count));
for (int k = arr.length-1; k >= 0; k--) {
result[--count[arr[k]]]=arr[k];
}
return result;
}
总结:
- 计数排序是非比较排序
- 适用于特定问题,也就是对源数据有要求
- O(n+k)
基数排序
- 非比较排序
- 桶思想的一种
- 多关键字排序
package mashibing_class.sorts;
import java.util.Arrays;
public class RadixSort {
public static void main(String[] args) {
int[] arr = {421, 240, 115, 532, 305, 430, 124};
//判断最高位数
int levels = 0;
for (int i = 0; i < arr.length; i++) {
levels = 0;
for (int temp = arr[i]; temp > 0; temp /= 10)
levels++;
}
System.out.println(levels);
int[] result = sort(arr, levels);
System.out.println(Arrays.toString(result));
}
static int[] sort(int[] arr, int levels) {
int[] result = new int[arr.length];
int[] count = new int[10];
for (int level = 0; level < levels; level++) {
int division = (int) Math.pow(10, level);
System.out.println(division);
for (int i = 0; i < arr.length; i++) {
int num = arr[i] / division % 10;
System.out.print(num + " ");
count[num]++;
}
System.out.println();
System.out.println(Arrays.toString(count));
for (int j = 1; j < count.length; j++)
count[j] = count[j] + count[j - 1];
for (int k = arr.length - 1; k >= 0; k--) {
int num = arr[k] / division % 10;
System.out.println("num:" + num);
result[--count[num]] = arr[k];
}
System.arraycopy(result, 0, arr, 0, arr.length);
// System.out.println(Arrays.toString(arr));
Arrays.fill(count, 0);//count数组置为0
}
return result;
}
}
总结:
- 本质是一种多关键字排序
- 有低位优先和高位优先两种
- LSD MSD(Least Significant Digit first) (Most)
- MSD属于分治的思想
- 百度百科的程序有问题
- 空间复杂度变高
桶排序
桶排序的算法思想:
- 求出待排序列最小和最大数据,作差,求出桶的范围。
- 然后遍历整个序列,放入各范围桶。
- 每个桶进行排序。
省了时间,空间就省不了,省了空间,时间就省不了