TestDemo.java
/**
* Created with IntelliJ IDEA.
* Description:
* User: zhuzhuzhuchao
* Date: 2022-01-01
* Time: 15:27
*/
public class TestDemo {
// Calculator
public static void main(String[] args) {
Calculator calculator = new Calculator();
calculator.setNum1(1);
calculator.setNum2(2);
System.out.println(calculator.add());
}
// 交换对象
public static void main(String[] args) {
MyValue myValue1 = new MyValue();
myValue1.val = 10;
MyValue myValue2 = new MyValue();
myValue2.val = 20;
swap(myValue1,myValue2);
System.out.println(myValue1.val+" "+ myValue2.val);
}
public static void swap(MyValue myV1,MyValue myV2) {
// myV1 myV2是引用
int tmp = myV1.val;
myV1.val = myV2.val;
myV2.val = tmp;
}
// 时间复杂度 空间复杂度
// 时间效率（时间复杂度）：算法中的基本操作的执行次数，为算法的时间复杂度
// 大O渐进表示法：1.用常数1取代运行时间中所有加法常数
// 2.在修改后的运行次数函数中，只保留最高阶项
// 3.如果最1高阶项存在且不是1，则去除与这个项目相乘的常数
// 平时讨论时间复杂度都是最坏情况
// 写成O(N)
// binarySearch时间复杂度O(log2(N))
// 递归的时间复杂度：递归的次数*每次递归执行的次数
// fibonacci：
// 空间效率（空间复杂度）：临时占用存储空间大小的量度（变量的多少）
// 递归的空间复杂度：递归次数
// 顺序表和链表
// 1.属于数据结构的一部分
// 2.数据结构是一个单独的学科，和语言没有关系
// 3.数据结构：逻辑非常严谨的一门学科
// 3.1多画图 3.2多写代码 3.3 不要抄代码
// 线性表
// 顺序表：底层是数组
public static void main(String[] args) {
int[] array = new int[10];
array[0] = 1;
}
public static void main(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(0,1);
myArrayList.add(1,2);
myArrayList.add(2,3);
myArrayList.add(3,4);
myArrayList.display();
System.out.println(myArrayList.contains(3));
myArrayList.setPos(0,99);
System.out.println(myArrayList.getPos(0));
myArrayList.remove(2);
myArrayList.display();
System.out.println("============================");
myArrayList.clear();
myArrayList.display();
}
// 顺序表效率不是很高
// 插入删除必须移动元素 O(N)
// 扩容也是问，想放第11个，扩容2倍-》20
// 能不能把插入删除做到 O(1)
// ->链表（满足顺序表的缺点）
}
Calculator
class Calculator {
private int num1;
private int num2;
public int getNum1() {
return num1;
}
public void setNum1(int num1) {
this.num1 = num1;
}
public int getNum2() {
return num2;
}
public void setNum2(int num2) {
this.num2 = num2;
}
public int add() {
return num1+num2;
}
public int sub() {
return num1-num2;
}
public int mul() {
return num1*num2;
}
public double dev() {
return num1*1.0/num2;
}
}
// 交换对象
class MyValue {
public int val;
}
MyArrayList.java
import java.util.Arrays;
/**
* Created with IntelliJ IDEA.
* Description: 顺序表
* User: zhuzhuzhuchao
* Date: 2022-01-01
* Time: 17:14
*/
public class MyArrayList {
public int[] elem;
public int usedSize; // 有效的数据个数
public MyArrayList() {
this.elem = new int[10];
}
// 打印顺序表
public void display() {
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
// 获取顺序表有效数据长度
public int size() {
return this.usedSize;
}
// 在 pos 位置新增元素
// pos位置可以指定
// pos<0不行，不能隔一个位置放元素（前面一定有元素）
// pos < 0 || pos > usedSize 不行 || 满不满？usedSize == len ->扩容
// pos有元素,从后移位
public void add(int pos, int data) {
if (pos > 0 && pos < this.usedSize) {
if (this.usedSize == this.elem.length) {
Arrays.copyOf(this.elem,this.usedSize+1);
}
for (int i = this.usedSize-1; i >= pos; i--) {
this.elem[i+1] = this.elem[i];
}
this.elem[pos] = data;
this.usedSize++;
} else {
System.out.println("pos位置不合法");
}
}
// 博哥写
public void add(int pos,int data) {
if(pos < 0 || pos > this.usedSize) {
System.out.println("pos位置不合法！");
return ;
}
if (isFull()) {
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
}
for (int i = this.usedSize-1; i >= pos; i--) {
this.elem[i+1] = this.elem[i];
}
this.elem[pos] = data;
this.usedSize++;
}
public boolean isFull() {
return this.usedSize == this.elem.length;
}
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) {
return true;
}
}
return false;
}
// 查找某个元素对应的位置,找不到返回-1
public int search(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) {
return i;
}
}
return -1;
}
// 获取 pos 位置的元素
public int getPos(int pos) {
if (pos < 0 || pos >= this.usedSize) {
System.out.println("pos 位置不合法");
return -1;// 业务上的处理
}
if (isEmpty()) {
System.out.println("顺序表为空");
return -1;
}
return this.elem[pos];
}
public boolean isEmpty() {
return this.usedSize == 0;
}
// 给 pos 位置的元素设为 value(更新元素)
public void setPos(int pos, int value) {
if (pos < 0 || pos >= this.usedSize) {
System.out.println("pos位置不合法");
return;
}
if(isEmpty()) {
return;
}
this.elem[pos] = value;
}
// 删除第一次出现的关键字key
// 让elem[i] = elem[i+1]
public void remove(int toRemove) {
if (isEmpty()) {
System.out.println("顺序表为空");
return;
}
int index = search(toRemove);
if(index == -1) {
System.out.println("没有你要删除的数字");
}
for (int i = index; i < this.usedSize-1; i++) {
this.elem[i] = this.elem[i+1];
}
this.usedSize--;
}
// 清空顺序表
public void clear() {
this.usedSize = 0;
}
}