數據結構與算法學習筆記01-數組

相關視頻: 提取碼: n9pe

1 時間複雜度

public  static void test1(int n) {
		//執行一條
		if(n>5) {
			System.out.println("n>5");
		}else if(n>3) {
			System.out.println("n>3");
		}else {
			System.out.println("n<=3");
		}
		//執行1（int i=0）+5（i++）+5（i<5）+5條(syso)
		for(int i=0;i<5;i++) {
			System.out.println("test"+i);
		}
	}
	//時間複雜度：O(n+k)
	public static void test2(int n,int k) {
		for(int i=0;i<n;i++) {
			System.out.println("test");
		}
		for(int i=0;i<k;i++) {
			System.out.println("test");
		}
	}

2 斐波那契數列

package 複雜度;

public class Main {
	public static void main(String[] args) {
	   	System.out.println(fib(8));
	}
	public static int fib(int n) {
        if(n<=1){
            return n;
        }   
        int first = 0;
        int second = 1;
        for(int i=1;i<n;i++){
            int sum = first+second;
            first = second;
            second = sum;
        }
        return second;
    }
}

3 動態數組

• 1 數組初始化後大小不可改變（棧中存放數組地址，指向堆（爲數組開闢的空間））
• 2 main方法結束後，銷燬內部棧中數組（局部變量），指針消失。（當年輕代滿以後會回收堆中沒有指針指向的內容）
• 3 this(elements) ：調用類內部含有參數的構造函數
• 4 Integer是int的包裝類
• 5 == 基本數據類型比較：值，引用數據類型比較：對象地址
• 6 右移 >> 例如：4>>1 相當於除以2（二進制：100 ->010）
• 7 泛型只能放對象
• 8 爲保證不同對象在數組中所佔空間一致，數組裏面放的是地址值。

//消除警告
@SuppressWarnings("unchecked")

public class ArrayListDong<E> {
	/**
	 * 元素的數量
	 */
	private int size;
	/**
	 * 所有的元素
	 */
	private E[] elements;
	private static final int DEFAULT_CAPACITY = 10;
	private static final int ELEMENT_NOT_FOUND = -1;
	//初始化數組
	public ArrayListDong(int capaticy) {
		capaticy = (capaticy<DEFAULT_CAPACITY)?DEFAULT_CAPACITY:capaticy;
		//因爲所有類都繼承自object，所以先new Object數組，再強轉
		elements = (E[])new Object[capaticy];
	}
	//無參數則默認大小爲10
	public ArrayListDong() {
		//調用有參的構造函數!!!
		this(DEFAULT_CAPACITY);
	}
	
	/**
	 * 清除所有元素
	 */
	public void clear() {
		for (int i = 0; i < size; i++) {
			elements[i] = null;
		}
		//不能用：elements = null; 因爲會斷掉數組（棧）指向堆的空間，堆內部東西會銷燬，每次都需要重新開闢空間。
		size = 0;
	}
	/**
	 * 元素的數量 
	 */
	public int size() {
		return size;
	}
	/**
	 * 是否爲空
	 */
	public boolean isEmpty() {
		return size == 0;
	}
	
	/**
	 * 是否包含某個元素
	 */
	public boolean contains(E element) {
		return indexOf(element)!=ELEMENT_NOT_FOUND;
	}
	
	/**
	 * 添加元素到尾部
	 */
	public void add(E element) {
		add(size,element);
	}
	
	/**
	 * 獲取index位置的元素
	 */
	public E get(int index) {
		rangeCheck(index);
		return elements[index];
	}
	/**
	 * 設置index位置的元素
	 * @return 歷史的元素
	 */
	public E set(int index,E element) {
		rangeCheck(index);
		E old = elements[index];
		elements[index] = element;
		return old;
	}
	
	/**
	 * 在index位置插入一個元素
	 */
	public void add(int index,E element) {
		rangeCheckForAdd(index);
		ensureCapacity(size+1);
		for (int i = size-1; i >= index; i--) {
			elements[i+1] = elements[i];
		}
		elements[index] = element;
		size++;
	}
	
	/**
	 * 刪除index位置的元素
	 */
	public E remove(int index) {
		rangeCheck(index);
		E old =  elements[index];
		for (int i = index+1; i < size; i++) {
			elements[i-1] = elements[i];
		}
		elements[--size]=null;
		return old;
	}
	/**
	 * 動態縮容
	 */
	public E removed(int index) {
		rangeCheck(index);
		E old =  elements[index];
		for (int i = index+1; i < size; i++) {
			elements[i-1] = elements[i];
		}
		elements[--size]=null;
		trim();
		return old;
	}
	/**
	 * 裁剪數組
	 */
	private void trim() {
		int capacity = elements.length;
		//元素數量大於數組空間的一半，不縮容
		int newCapacity = capacity>>1;
		if(size>=newCapacity || capacity<=DEFAULT_CAPACITY) return;
		//剩餘空間還很多
		E[] newElements = (E[])new Object[newCapacity];
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i];
		}
		//原數組指向新數組
		elements = newElements;
		System.out.println("縮容："+capacity+"至"+newCapacity);
	}
	/**
	 * 查看元素的位置
	 */
	public int indexOf(E element) {
		if(element==null) {
			for (int i = 0; i < size; i++) {
				if (elements[i] == null) {
					return i;
				}
				
			}
		}else {
			for(int i=0;i<size;i++) {
				if(elements[i].equals(element)) return i;
			}
		}
		
		return ELEMENT_NOT_FOUND;
	}
	
	/**
	 * 數組轉換成字符串
	 */
	@Override
	public String toString() {
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.append("size=").append(size).append(",[");
		for (int i = 0; i < size; i++) {
			if(i!=0) {
				stringBuilder.append(",");
			}
			stringBuilder.append(elements[i]);
//			if(i!=size-1) {
//				stringBuilder.append(",");
//			}
		}
		stringBuilder.append("]");
		return stringBuilder.toString();
	}
	
	//封裝報錯
	private void outOfBounds(int index) {
		throw new IndexOutOfBoundsException("Index"+index+",Size:"+size);
	}
	private void rangeCheck(int index) {
		if(index<0||index>=size) {
			outOfBounds(index);
		}
	}
	private void rangeCheckForAdd(int index) {
		if(index<0||index>size) {
			outOfBounds(index);
		}
	}
	
	/**
	 * @Description:保證容量至少有capacity
	 */
	private void ensureCapacity(int capacity) {
		int oldCapacity = elements.length;
		if(oldCapacity>=capacity) return;
		//新容量爲舊容量的1.5倍
		int newCapacity = oldCapacity+(oldCapacity>>1);
		E[] newElements = (E[])new Object[newCapacity];
		//將原數組的元素填入新數組
		for (int i = 0; i < size; i++) {
			newElements[i] = elements[i];
		}
		//原數組指向新數組
		elements = newElements;
		
		System.out.println("擴容："+oldCapacity+"至"+newCapacity);
	}
}

public class Assert {
	public static void test(boolean value) {
		try {
			if(!value) throw new Exception("測試未通過");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

public class DongArray {
	public static void main(String[] args) {
		//正常情況下，創建數組後，數組大小無法改變
//		int arr[] = new int[]{11,22,333};
//		ArrayListDong listDong = new ArrayListDong();
//		listDong.add(99);
//		listDong.add(77);
//		listDong.add(88);
//		listDong.add(66);
//		listDong.add(55);
//		for(int i=0;i<30;i++) {
//			listDong.add(i);
//		}
//		listDong.set(3, 80);
		ArrayListDong<Person> persons = new ArrayListDong<>();
		persons.add(new Person(11, "aa"));
		persons.add(new Person(12, "bb"));
		persons.add(new Person(13, "cc"));
		persons.add(null);
		persons.add(null);
		System.out.println(persons);
		System.out.println(persons.indexOf(null));
//		persons.clear();
		//提醒jvm進行垃圾回收
//		System.gc();
//		ArrayListDong<Integer> ints = new ArrayListDong<>();
//		ints.add(1);
//		ints.add(2);
//		ints.add(3);
//		System.out.println(ints);		
	}
}

public class Person {
	private int age;
	private String name;
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}

	public String toString() {
		return "Person [age=" + age + ", name=" + name + "]";
	}
	//對象被銷燬之前調用
	@Override
	protected void finalize() throws Throwable {
		super.finalize();
		System.out.println("Person - finalize");
	}
	@Override
	public boolean equals(Object obj) {
		Person person = (Person)obj;
		return this.age == person.age;
	}
}