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;

}

}