复习总结并手写常用数据结构--数组

前段时间一直忙着毕业设计，很久没有复习一些编程基础。即将毕业，趁着还有充足的时间，现在每天都在复习以及学习新的知识。前几天复习的是Java 中array的知识，正好趁着记忆有点模糊，来总结一下。PS 前几天学习的新东西是使用SpringBoot搭建个人博客，总的来说自己看着别人的源码，照着学习，还是学到了很多知识，但是因为找的学习资源不充分，因此博客项目的学习最后还是草草收工，代码已经上传到我的Github仓库了，有需要的小伙伴可以去下载看看。至少是可以从中学到很多知识，比如权限管理的拦截器，前后端的连接调通，Mybatis知识的复习等等，非常多。

我新创建的一个专门复习的Java工程，也上传到了我的Github仓库没有需要的小伙伴们可以自行下载代码。
Fighting_Boss_Hao 的Github仓库

对此次复习的知识，数组部分的代码目录如下

首先是手写一个通过索引操作无序数组

public class OperateWithIndex {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateWithIndex(int length) {datas = new int[length];}public int insert(int data) {datas[currentIndex] = data;currentIndex++;return currentIndex - 1;//这里是返回自增之前的添加索引}//删除就是从index开始，所有元素向后移一位public void remove(int index) {for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;}public int searchOne(int index) {return datas[index];}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateWithIndex op = new OperateWithIndex(20);op.insert(1);op.insert(3);op.insert(4);op.insert(6);op.insert(6);op.insert(7);op.printDatas();op.remove(3);op.printDatas();int result = op.searchOne(3);System.out.println("result : " + result);}
}

接下来逐步演进，第二个是演示操作直接使用数据操作无无序数组,存放不重复的值
第二种通过直接使用数据来操作无序数组，相比于第一种差别就是它操作的是数据。多加的操作就是执行操作前先找到数据的索引，然后再进一步操作。

public class OperateNoIndex {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateNoIndex(int length) {datas = new int[length];}public int insert(int data) {datas[currentIndex] = data;currentIndex++;return currentIndex - 1;}public int getIndex(int data) {int index = -1;for (int j = 0; j < currentIndex; j++) {if (datas[j] == data) {index = j;break;}}return index;}public void remove(int data) {//1.查找这个数据对应的索引int index = getIndex(data);//2.同使用索引的而方法，由索引删除数据for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;}public int searchOne(int data) {//1.查找这个数据对应的索引int index = getIndex(data);//2.如果有，就返回datas中的数据if (index >=0) {return datas[index];}//3.如果没有，就返回0;return 0;}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateNoIndex op = new OperateNoIndex(20);op.insert(1);op.insert(3);op.insert(4);op.insert(6);op.insert(7);op.printDatas();op.remove(3);op.printDatas();int result = op.searchOne(3);System.out.println("result : " + result);}
}

第三种演示操作直接使用数据操作无无序数组,* 存放重复的值
第三种相较于第二种，主要是可以存放重复的值，需要多做的操作就是对操做的结果要循环的执行，找出所有的结果。

public class OperateNoIndexRepetable {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateNoIndexRepetable(int length) {datas = new int[length];}public int insert(int data) {datas[currentIndex] = data;currentIndex++;return currentIndex - 1;}
/***获取数据data在数组中的索引位置* begin 开始查找的位置* data  查找索引的数据* return 从开始位置往后的第一个索引*/public int getIndex(int begin,int data) {int index = -1;for (int j = begin; j < currentIndex; j++) {if (datas[j] == data) {index = j;break;}}return index;}public void remove(int data) {//1.查找这个数据对应的索引int index = getIndex(0,data);//循环向后查找这个索引，直到找不到为止while(index>=0){//2.同使用索引的而方法，由索引删除数据 这里要注意的是 这个循环是从尾部开始，为前边                  // index对应的data让出位置，依次向后移动for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;//再次查找后续的数据对应的索引index= getIndex(index,data);}}public List<Integer> searchOne(int data) {List<Integer> reList =  new ArrayList<>();//1.查找这个数据对应的索引int index = getIndex(0,data);while(index>=0){//2.如果有，就添加到要返回的集合中reList.add(datas[index]);//再次查找后续的数据对应的索引index= getIndex(index+1,data);}return reList;}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateNoIndexRepetable op = new OperateNoIndexRepetable(20);op.insert(1);op.insert(3);op.insert(3);op.insert(4);op.insert(6);op.insert(6);op.insert(7);op.printDatas();op.remove(3);op.printDatas();List<Integer> result = op.searchOne(6);System.out.println("result : " + result);}
}

第四种是演示操作直接使用数据操作有序数组,存放不重复的值
第四种操作的是有序数组，因此对于数据的插入操作需要先进行排序。对于删除和查找则是循环的比较

public class OperateOrderNoIndex {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateOrderNoIndex(int length) {datas = new int[length];}public int insert(int data) {//假设顺序是升序int index =0;//1.查找数据data应该存放的位置for (index=0;index<currentIndex;index++){if(datas[index]>data){break;}}//2.把这个位置及其后面的数据，向后移动一位for (int i =currentIndex;i>index;i--){datas[i]=datas[i-1];}//3.把data设置到应该存放的位置datas[index] = data;currentIndex++;return currentIndex -1;//返回自增前的地址}public int getIndex(int data) {int index = -1;for (int j = 0; j < currentIndex; j++) {if (datas[j] == data) {index = j;break;}}return index;}public void remove(int data) {//1.查找这个数据对应的索引int index = getIndex(data);//2.同使用索引的而方法，由索引删除数据for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;}public int searchOne(int data) {//1.查找这个数据对应的索引int index = getIndex(data);//2.如果有，就返回datas中的数据if (index >=0) {return datas[index];}//3.如果没有，就返回0;return 0;}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateOrderNoIndex op = new OperateOrderNoIndex(20);op.insert(1);op.insert(3);op.insert(4);op.insert(6);op.insert(7);op.printDatas();op.remove(3);op.printDatas();int result = op.searchOne(3);System.out.println("result : " + result);}
}

第五种是演示操作直接使用数据操作有序数组,* 存放重复的值

重点就是有序数组，重复的值

此方法，和第四种几乎没变

public class OperateOrderNoIndexRepetable {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateOrderNoIndexRepetable(int length) {datas = new int[length];}public int insert(int data) {//假设顺序是升序int index =0;//1.查找数据data应该存放的位置for (index=0;index<currentIndex;index++){if(datas[index]>data){break;}}//2.把这个位置及其后面的数据，向后移动一位for (int i =currentIndex;i>index;i--){datas[i]=datas[i-1];}//3.把data设置到应该存放的位置datas[index] = data;currentIndex++;return currentIndex -1;//返回自增前的地址}
/***获取数据data在数组中的索引位置* begin 开始查找的位置* data  查找索引的数据* return 从开始位置往后的第一个索引*/public int getIndex(int begin,int data) {int index = -1;for (int j = begin; j < currentIndex; j++) {if (datas[j] == data) {index = j;break;}}return index;}public void remove(int data) {//1.查找这个数据对应的索引int index = getIndex(0,data);//循环向后查找这个方法，直到找不到为止while(index>=0){//2.同使用索引的方法，由索引删除数据for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;//再次查找后续的数据对应的索引index= getIndex(index,data);}}public List<Integer> searchOne(int data) {List<Integer> reList =  new ArrayList<>();//1.查找这个数据对应的索引int index = getIndex(0,data);while(index>=0){//2.如果有，就添加到要返回的集合中reList.add(datas[index]);//再次查找后续的数据对应的索引index= getIndex(index+1,data);}return reList;}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateOrderNoIndexRepetable op = new OperateOrderNoIndexRepetable(20);op.insert(1);op.insert(3);op.insert(3);op.insert(4);op.insert(6);op.insert(6);op.insert(7);op.printDatas();op.remove(3);op.printDatas();List<Integer> result = op.searchOne(6);System.out.println("result : " + result);}
}

第六种将操作对象换成 Object
1.先创建一个Model ,排序用到的是其属性UUID
2.将对象换到代码中去

public class UserModel1 {private int uuid;private String name;private int age;public UserModel1(int uuid, String name, int age) {this.uuid = uuid;this.name = name;this.age = age;}public int getUuid() {return uuid;}public void setUuid(int uuid) {this.uuid = uuid;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "UserModel1{" +"uuid=" + uuid +", name='" + name + '\'' +", age=" + age +'}';}
}

public class OperateOrderNoIndexObject {private UserModel1[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateOrderNoIndexObject(int length) {datas = new UserModel1[length];}public int insert(UserModel1 data) {//假设顺序是升序int index = 0;//1.查找数据data应该存放的位置for (index = 0; index < currentIndex; index++) {if (datas[index].getUuid() > data.getUuid()) {break;}}//2.把这个位置及其后面的数据，向后移动一位for (int i = currentIndex; i > index; i--) {datas[i] = datas[i - 1];}//3.把data设置到应该存放的位置datas[index] = data;currentIndex++;return currentIndex - 1;//返回自增前的地址}public int getIndex(int uuid) {int index = -1;for (int j = 0; j < currentIndex; j++) {if (datas[j].getUuid() == uuid) {index = j;break;}}return index;}public void remove(int uuid) {//1.查找这个数据对应的索引int index = getIndex(uuid);//2.同使用索引的而方法，由索引删除数据for (int i = index; i < currentIndex; i++) {datas[i] = datas[i + 1];}currentIndex--;}public UserModel1 searchOne(int uuid) {//1.查找这个数据对应的索引int index = getIndex(uuid);//2.如果有，就返回datas中的数据if (index >= 0) {return datas[index];}//3.如果没有，就返回null;return null;}public void printDatas() {System.out.println("==================");for (UserModel1 d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateOrderNoIndexObject op = new OperateOrderNoIndexObject(10);op.insert(new UserModel1(1,"张三",6));op.insert(new UserModel1(2,"haha",7));op.insert(new UserModel1(3,"李四",6));op.insert(new UserModel1(6,"呱呱",5));op.insert(new UserModel1(7,"唧唧",3));op.insert(new UserModel1(4,"啦啦",16));op.remove(3);op.printDatas();UserModel1 model1 = op.searchOne(4);System.out.println("result : " + model1);}
}

最后可以利用第五重数据的代码，稍加修改写一个二分查找算法

public class OperateOrderNoIndexBinarySearch {private int[] datas = null;//定义数据private int currentIndex = 0;//定义索引public OperateOrderNoIndexBinarySearch(int length) {datas = new int[length];}public int insert(int data) {//假设顺序是升序int index =0;//1.查找数据data应该存放的位置。for (index=0;index<currentIndex;index++){if(datas[index]>data){break;}}//2.把这个位置及其后面的数据，向后移动一位。for (int i =currentIndex;i>index;i--){datas[i]=datas[i-1];}//3.把data设置到应该存放的位置。datas[index] = data;currentIndex++;return currentIndex -1;//返回自增前的地址}public int binarySearch(int data) {int index = -1;//用来表示小的这边的索引int lowIndex=0;//用来表示大的这边的索引int highIndex=currentIndex-1;//因为插入的时候最后的索引是++while(true){//1.找到中间的位置index= ( lowIndex + highIndex )/2;//2.把要查找的数据和中间索引位置的数据进行比较if(lowIndex>highIndex){//没找到数据return -1;}else if(datas[index]==data){return index;}else{if (data<datas[index]) {highIndex = index-1;}else{lowIndex = index +1;}}}}public void printDatas() {System.out.println("==================");for (int d : datas) {System.out.println(d);}}public static void main(String args[]) {OperateOrderNoIndexBinarySearch op = new OperateOrderNoIndexBinarySearch(20);op.insert(1);op.insert(3);op.insert(4);op.insert(6);op.insert(7);op.printDatas();int i = op.binarySearch(4);System.out.println("result index is :"+ i);}
}

哦了，过了一遍代码，又复习了一遍。对于所实现的数据，仅仅是简单的实现，并没有考虑一下边界值等。接下来该复习今天的知识，以及学习新的知识。