学习数据结构与算法
程序=数据结构+算法
学习程度
能写
线性表,单链表,循环链表,栈,队列,二叉树,二叉线索树,AVL平衡树
排序算法,搜索算法,背包算法,分治算法,回溯算法,动态规划算法,贪心算法
数据:
但凡能够被计算机存储,识别和计算的东西都叫数据(二进制)
硬盘:mp3 jpg doc avi exe txt
内存:变量,常量,数组,对象,字节码
结构:
数据与数据之间的一种或多种特定的关系
数据结构的逻辑结构
集合结构:集合结构中的数据元素除了同属于一个集合外,他们之间没有其他关系
线性结构:线性结构中的数据元素之间是一对一的关系
树形结构:树形结构中的数据元素之间存在一种一对多的层次关系
图形结构:图形结构的数据元素是多对多的关系
动态数组
java内置数组的特点：
数组的长度一旦却确定则不可更改。
数组只能存储同一类型的数据。
数组中每个存储空间大小一致且地址连续。
数字提供角标访问元素
线性表list接口的定义
package 第二章动态数组1;
public interface List<E> {
/**
* 获取线性表中的元素个数(线性表的长度)
* @return
*/
public int getSize();
/**
* 判断线性表是否为空
* @return 是否为空的布尔类型值
*/
public boolean isEmpty();
/**
* 在线性表中指定的index角标处添加元素e
* @param index
* @param e
*/
public void add(int index,E e);
/**
* 在线性表的表头位置插入一个元素
* @param e要插入的元素 指定在角标0处
*/
public void addFirst(E e);
/**
* 在线性表的表尾插入一个元素
* @param e要插入的元素 指定在角标size处
*/
public void addLast(E e);
/**
* 在线性表中获取指定index角标的元素
* @param index
* @return
*/
public E get(int index);
/**
* 获取线性表中表头的元素
* @return
*/
public E getFirst();
/**
* 获取线性表中表尾的元素
* @return
*/
public E getLast();
/**
* 修改线性表中指定index处的元素为新元素e
* @param index
* @param e
*/
public void set(int index,E e);
/**
* 判断线性表中是否包含指定元素e 默认从前往后找
* @param e
*/
public boolean contains(E e);
/**
* 在线性表中获取指定元素e的角标
* @param e
* @return
*/
public int find(E e);
/**
* 在线性表中删除指定角标处的元素,并返回
* @param index
* @return
*/
public E remove(int index);
/**
* 删除线性表中的表头元素
* @return
*/
public E removeFirst();
/**
* 删除线性表中表尾元素
* @return
*/
public E removeLast();
/**
* 在线性表中删除指定元素e
* @param e
*/
public void removeElement(E e);
/**
* 清空线性表
*/
public void clear();
}
ArrayList类实现List接口
package 第二章动态数组1;
/**
* 用顺序存储结构实现的List-顺序线性表-顺序表
* */
public class ArrayList<E>implements List<E>{
private static int DEFAULT_SIZE=10;//容器的默认容量
private E[] data;//存储数据元素的容器
private int size; //线性表的有效元素的个数
//data.length表示线性表的最大容量Capacity
/**
* 创建一个容量默认为10的一个线性表
*
*/
public ArrayList() {
this(DEFAULT_SIZE);
}
/**
* 创建一个容量为指定capacity的一个线性表
*/
public ArrayList(int capacity) {
this.data= (E[]) new Object[capacity];
this.size=0;
}
/**
* 将一个数组封装成为一个线性表
*/
public ArrayList(E[] arr) {
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public void add(int index, E e) {
if(index<0||index>size) {
throw new ArrayIndexOutOfBoundsException("add函数角标越界");
}
//判断是否以满
if(size==data.length) {
resize(2*data.length);
}
for(int i=size-1;i>=index;i--) {
data[i+1]=data[i];
}
data[index]=e;
size++;
}
/**
* 改变data的长度(扩容,缩容)
* @param 新数组的长度
*/
private void resize(int newLen) {
E[] newData= (E[]) new Object[newLen];
for(int i =0;i<size;i++) {
newData[i]=data[i];
}
data= newData;
}
@Override
public void addFirst(E e) {
add(0,e);
}
@Override
public void addLast(E e) {
add(size,e);
}
@Override
public E get(int index) {
if(index<0||index>size-1)
throw new ArrayIndexOutOfBoundsException("get函数角标越界");
return data[index];
}
@Override
public E getFirst() {
return get(0);
}
@Override
public E getLast() {
return get(size-1);
}
@Override
public void set(int index, E e) {
if(index<0||index>size-1) {
throw new ArrayIndexOutOfBoundsException("set函数角标越界");
}
data[index]=e;
}
@Override
public boolean contains(E e) {
if(isEmpty()) {
return false;
}
for(int i =0;i<size;i++) {
if(data[i]==e) {
return true;
}
}
return false;
}
@Override
public int find(E e) {
if(isEmpty()) {
return -1;
}
for(int i =0;i<size;i++) {
if(data[i]==e) {
return i;
}
}
return -1;
}
@Override
public E remove(int index) {
if(index<0||index>size-1)
throw new ArrayIndexOutOfBoundsException("remove函数角标越界");
E e= get(index);
for(int i =index+1;i<size-1;i++) {
data[i-1]=data[i];
}
size--;
//判断是否缩容
//1.最短不能缩过默认容量
//2.有效元素的个数小于等于容量的1/4
if(data.length>DEFAULT_SIZE&&size<data.length/4) {
resize(data.length/2);
}
return e;
}
@Override
public E removeFirst() {
return remove(0);
}
@Override
public E removeLast() {
return remove(size-1);
}
@Override
public void removeElement(E e) {
int index = find(e);
if(index==-1) {
throw new IllegalArgumentException("删除元素不存在");
}
remove(index);
}
@Override
public void clear() {
size=0;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("ArrayList:size"+size+",capacity="+data.length+"\n");
if(isEmpty()) {
sb.append("[]");
}else {
sb.append('[');
for(int i =0;i<size;i++) {
sb.append(data[i]);
if(i==size-1) {
sb.append(']');
}else {
sb.append(',');
}
}
}
return sb.toString();
}
public int getCapacity() {
return data.length;
}
public void swap(int i ,int j) {
E temp = data[i];
data[i]=data[j];
data[j]=temp;
}
public boolean equals(Object obj) {
if(obj==null) {
return false;
}
if(obj==this) {
return true;
}
if(obj instanceof ArrayList) {
ArrayList l =(ArrayList)obj;
if(getSize()==l.getSize()) {
for(int i =0;i<getSize();i++) {
if(get(i)!=l.get(i)) {
return false;
}
}
return true;
}
}
return false;
}
}
Test测试类
package 第二章动态数组1;
public class Main {
public static void main(String[] args) {
ArrayList<Integer>list = new ArrayList<Integer>();
System.out.println(list);
for(int i =1;i<=5;i++) {
list.addFirst(i);
}
System.out.println(list);
for(int i =6;i<=10;i++) {
list.addLast(i);
}
System.out.println(list);
list.add(5, 0);
System.out.println(list);
for(int i =11;i<=30;i++) {
list.addLast(i);
}
System.out.println(list);
for(int i=1;i<=10;i++) {
System.out.println(list.removeLast());
}
System.out.println(list);
list.remove(5);
System.out.println(list);
list.removeElement(10);
System.out.println(list);
list.removeElement(15);
for(int i =1;i<=4;i++) {
list.removeFirst();
}
System.out.println(list);
for(int i =1;i<=4;i++) {
list.removeLast();
}
System.out.println(list);
list.swap(1, 2);
System.out.println(list);
ArrayList<Integer>list2=new ArrayList<Integer>();
list2.addFirst(20);
System.out.println(list2);
System.out.println(list.equals(list2));
}
}
喜欢我的可以关注我,我们可以一起交流学习
微信公众号:
让我爱上它Computer
qq群:473989408
