數據結構Java01-【數據結構概述、數組基本使用】

課件（源碼、XMind文件）： 

鏈接：https://pan.baidu.com/s/1JYLnvxdvTCbRybxi2RE6Ew 
提取碼：mi7f

 

或者，加我QQ：386335886。

【免費發！當然免費發！！！啊哈哈哈哈哈哈哈哈~~~】

希望能夠幫助到大家！！！

目   錄

P1-1.1數據結構概述

1、數據結構概述

P2-1.2算法概述

1、思維導圖

2、導入老師的eclipse工程，中文亂碼---解決方案

3、格式化代碼

P3-2.1數組的基本使用

P4-2.2數組元素的添加

1、替換數組

P5-2.3數組元素的刪除

P6-2.4面向對象的數組

1、數組的底層實現原理

1.1、MyArray.java

1.2、TestMyArray.java

P7-2.5查找算法之線性查找

P8-2.6查找算法之二分法查找

P9-2.7查找算法整合

1、MyArray.java

2、TestMyArraySearch.java

---

P1-1.1數據結構概述

整個思維導圖【實在是太大了！！！請自己下載xmind文件，自行查看吧！】

1、數據結構概述

第一集的思維導圖

什麼是數據結構：數據與數據之間的關係！

數據的存儲結構：數據在計算機中如何存儲！

數據的邏輯結構：數據與數據之間的關係！

圖結構：多對多！！！

P2-1.2算法概述

算法是規則的有限集合，會爲解決特定問題而規定的一系列操作。

數據結構：是相互之間存在一種或多種特定關係的數據元素的集合。

1、思維導圖

2、導入老師的eclipse工程，中文亂碼---解決方案

1、右鍵出現中文亂碼的java項目名，在右鍵菜單中選擇最後一項Properties！ 

2、點擊【Properties】，在彈出窗口選擇Resource選項，然後在右側操作窗口中的第一項選擇other選項，在選項右邊下拉選擇中點選合適的編碼格式！如果你不知道導入項目的使用了什麼編碼，你可以嘗試選擇utf-8，這是編程中最常用的編碼格式。然後確定Apple and close就可以了！

3、格式化代碼

package demo1;

public class AddOneToHundred {

	public static void main(String[] args) {
		int total = 0;
		int end = 100;
		
		// 使用for循環計算
		for (int i = 1; i <= end; i++) {
			total += i;
		}
		System.out.println(total);

		// 直接計算
		total = (1 + end) * end / 2;
		
		// 算法沒有最好的，只有最適合的！

		// 打印結果
		System.out.println(total);
	}

}

P3-2.1數組的基本使用

package demo1;

public class TestArray {

	public static void main(String[] args) {
		// 創建一個數組
		int[] arr1 = new int[3];
		
		// 獲取數組長度
		int length1 = arr1.length;
		System.out.println("arr1's length: " + length1);
		
		// 訪問數組中的元素:數組名[下標] 注意：下標從0開始,最大可以取到長度-1
		int element0 = arr1[0];
		System.out.println("element0: " + element0);
		for(int x: arr1) {
			System.out.println(x);
		}
		
		// 爲數組中的元素賦值
		arr1[0] = 99;
		System.out.println("element0: " + arr1[0]);
		arr1[1] = 98;
		arr1[2] = 97;
		
		// 遍歷數組
		for (int i = 0; i < length1; i++) {
			System.out.println("arr1 element" + i + ": " + arr1[i]);
		}
		
		// 創建數組的同時爲數組中的元素賦值
		int[] arr2 = new int[] { 90, 80, 70, 60, 50 };
		
		// 獲取數組的長度
		System.out.println("arr2 length: " + arr2.length);
	}

}

P4-2.2數組元素的添加

1、替換數組

package demo1;

import java.util.Arrays;

public class TestOpArray {

	public static void main(String[] args) {
		
		// 解決數組的長度不可變的問題
		int[] arr = new int[] { 9, 8, 7 };
		
		// 快速查看數組中的元素
		System.out.println(Arrays.toString(arr));
		
		// 要加入數組的目標元素
		int dst = 6; // destination 目的地 縮寫

		// 創建一個新的數組，長度是原數組長度+1
		int[] newArr = new int[arr.length + 1];
		
		// 把原數組中的數據全部複製到新數組中
		for (int i = 0; i < arr.length; i++) {
			newArr[i] = arr[i];
		}
		
		// 把目標元素放入新數組的最後
		newArr[arr.length] = dst;
		
		// 新數組替換原數組
		arr = newArr;
		
		System.out.println(Arrays.toString(arr));
	}

}

P5-2.3數組元素的刪除

 

或者 數組元素前移操作！！！

package demo1;

import java.util.Arrays;

public class TestOpArray2 {
	
	// 如何刪除數組中的元素
	
	public static void main(String[] args) {
		
		// 目標數組
		int[] arr = new int[] { 9, 8, 7, 6, 5, 4 }; // 數組長度爲6
		
		System.out.println(arr.length);
		
		// 要刪除的元素的下標
		int dst = 3; // 0、1、2、3、4、5
		
		System.out.println(Arrays.toString(arr));

		// 創建一個新的數組，長度是原數組的長度-1
		int[] newArr = new int[arr.length - 1]; // 數組長度爲5
		
		// 複製原數組中除了要刪除的那個元素以外其它的元素
		for (int i = 0; i < newArr.length; i++) { // i: 0\1\2\3\4
			// 要刪除的元素之前的元素
			
			/**-----------------------------------*/
//			if (i < dst) {
//				System.out.println("---: " + i);
//				newArr[i] = arr[i];
//				// 要刪除的元素之後的元素
//			} else {
//				System.out.println("***: " + i);
//				newArr[i] = arr[i + 1];
//			}
			
			/**-----------------------------------*/
			if (i == dst) {
				continue;				
			}
			System.out.println("***: " + i);
			newArr[i] = arr[i];
		}
		
		// 新數組替換舊數組
		arr = newArr;
		
		System.out.println(Arrays.toString(arr));
	}

}

P6-2.4面向對象的數組

1、數組的底層實現原理

1.1、MyArray.java

// 判斷下標是否越界

if (index < 0 || index > elements.length - 1) {

      throw new RuntimeException("下標越界");

}

package demo1.util;

import java.util.Arrays;

public class MyArray {

	// 用於存儲數據的數組
	private int[] elements; // 只能存 int, 存其他類型的數據：object

	public MyArray() {
		elements = new int[0];
	}

	// 獲取數組長度的方法
	public int size() {
		return elements.length;
	}

	// 往數組的末尾添加一個元素
	public void add(int element) {
		// 創建一個新的數組
		int[] newArr = new int[elements.length + 1];
		// 把原數組中的元素複製到新數組中
		for (int i = 0; i < elements.length; i++) {
			newArr[i] = elements[i];
		}
		// 把添加的元素放入新數組中
		newArr[elements.length] = element;
		// 使用新數組替換舊數組
		elements = newArr;
	}

	// 打印所有元素到控制檯
	public void show() {
		System.out.println(Arrays.toString(elements));
	}

	// 刪除數組中的元素
	public void delete(int index) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		// 創建一個新的數組，長度爲原數組的長度-1
		int[] newArr = new int[elements.length - 1];
		// 複製原有數據到新數組
		for (int i = 0; i < newArr.length; i++) {
			// 想要刪除的元素前面的元素
			if (i < index) {
				newArr[i] = elements[i];
				// 想要刪除的元素後面的元素
			} else {
				newArr[i] = elements[i + 1];
			}
		}
		// 新數組替換舊數組
		elements = newArr;
	}

	// 取出指定位置的元素
	public int get(int index) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		return elements[index];
	}

	// 插入一個元素到指定位置
	public void insert(int index, int element) {
		// 創建一個新的數組
		int[] newArr = new int[elements.length + 1];
		// 將原數組中的元素放入新數組中。
		for (int i = 0; i < elements.length; i++) {
			// 目標位置之前的元素
			if (i < index) {
				newArr[i] = elements[i];
				// 目標位置之後的元素
			} else {
				newArr[i + 1] = elements[i];
			}
		}
		// 插入新的元素
		newArr[index] = element;
		// 新數組替換舊數組
		elements = newArr;
	}

	// 替換指定位置的元素
	public void set(int index, int element) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		elements[index] = element;
	}

	// 線性查找
	public int search(int target) {
		// 遍歷數組
		for (int i = 0; i < elements.length; i++) {
			if (elements[i] == target) {
				return i;
			}
		}
		// 沒有找到對應的元素
		return -1;
	}

	// 二分法查找
	public int binarySearch(int target) {
		// 記錄開始位置
		int begin = 0;
		// 記錄結束位置
		int end = elements.length - 1;
		// 記錄中間的位置
		int mid = (begin + end) / 2;
		// 循環查找
		while (true) {
			// 什麼情況下沒有這個元素？
			// 開始在結束位置之後或重合,沒有這個元素
			if (begin >= end) {
				return -1;
			}
			// 判斷中間的這個元素是不是要查找的元素
			if (elements[mid] == target) {
				return mid;
				// 中間這個元素不是要查的元素
			} else {
				// 判斷中間這個元素是不是比目標元素大
				if (elements[mid] > target) {
					// 把結束位置調整到中間位置前一個位置
					end = mid - 1;
					// 中間這個元素比目標元素小
				} else {
					// 把開始位置調整到中間位置的後一個位置
					begin = mid + 1;
				}
				// 取出新的中間位置
				mid = (begin + end) / 2;
			}
		}
	}

}

1.2、TestMyArray.java

package demo1;

import demo1.util.MyArray;

public class TestMyArray {

	public static void main(String[] args) {
		// 創建一個可變的數組
		MyArray ma = new MyArray();
		// 獲取長度
		int size = ma.size();
		ma.show();
		// 往可變數組中添加一個元素
		ma.add(99);
		ma.add(98);
		ma.add(97);
		// 顯示可變數組中的所有元素到控制檯
		ma.show();
		// 刪除某個元素
		ma.delete(1);
		ma.show();
		// 取出指定位置的元素
		int element = ma.get(1);
		System.out.println(element);
		System.out.println("=====================");
		ma.add(96);
		ma.add(95);
		ma.add(94);
		ma.show();
		// 插入元素到指定位置
		ma.insert(3, 33);
		ma.show();
		System.out.println("=====================");
		// 替換指定位置的元素
		ma.set(0, 100);
		ma.show();
		System.out.println(ma.size());
	}

}

P7-2.5查找算法之線性查找

package demo1;

public class TestSearch {

	public static void main(String[] args) {
		// 目標數組
		int[] arr = new int[] { 2, 3, 5, 6, 8, 4, 9, 0 };
		// 目標元素
		int target = 8;
		// 目標元素所在的下標
		int index = -1;
		// 遍歷數組
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == target) {
				index = i;
				break;
			}
		}
		// 打印目標元素的下標
		System.out.println("index:" + index);
	}

}

P8-2.6查找算法之二分法查找

二分法：要求 數組 必須 有序！！！

結束條件：while (begin < end) {}

package demo1;

public class TestBinarySearch {

	public static void main(String[] args) {
		// 目標數組
		int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		// 目標元素
		int target = 30;
		// 記錄開始位置
		int begin = 0;
		// 記錄結束位置
		int end = arr.length - 1;
		// 記錄中間的位置
		int mid = (begin + end) / 2;
		// 記錄目標位置
		int index = -1;
		// 循環查找
		while (begin < end) {
			// 判斷中間的這個元素是不是要查找的元素
			if (arr[mid] == target) {
				index = mid;
				break;
				// 中間這個元素不是要查的元素
			} else {
				// 判斷中間這個元素是不是比目標元素大
				if (arr[mid] > target) {
					// 把結束位置調整到中間位置的前一個位置
					end = mid - 1;
					// 中間這個元素比目標元素小
				} else {
					// 把開始位置調整到中間位置的後一個位置
					begin = mid + 1;
				}
				// 取出新的中間位置
				mid = (begin + end) / 2;
			}
		}
		System.out.println("index: " + index);
	}

}

P9-2.7查找算法整合

1、MyArray.java

package demo1.util;

import java.util.Arrays;

public class MyArray {

	// 用於存儲數據的數組
	private int[] elements; // 只能存 int, 存其他類型的數據：object

	public MyArray() {
		elements = new int[0];
	}

	// 獲取數組長度的方法
	public int size() {
		return elements.length;
	}

	// 往數組的末尾添加一個元素
	public void add(int element) {
		// 創建一個新的數組
		int[] newArr = new int[elements.length + 1];
		// 把原數組中的元素複製到新數組中
		for (int i = 0; i < elements.length; i++) {
			newArr[i] = elements[i];
		}
		// 把添加的元素放入新數組中
		newArr[elements.length] = element;
		// 使用新數組替換舊數組
		elements = newArr;
	}

	// 打印所有元素到控制檯
	public void show() {
		System.out.println(Arrays.toString(elements));
	}

	// 刪除數組中的元素
	public void delete(int index) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		// 創建一個新的數組，長度爲原數組的長度-1
		int[] newArr = new int[elements.length - 1];
		// 複製原有數據到新數組
		for (int i = 0; i < newArr.length; i++) {
			// 想要刪除的元素前面的元素
			if (i < index) {
				newArr[i] = elements[i];
				// 想要刪除的元素後面的元素
			} else {
				newArr[i] = elements[i + 1];
			}
		}
		// 新數組替換舊數組
		elements = newArr;
	}

	// 取出指定位置的元素
	public int get(int index) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		return elements[index];
	}

	// 插入一個元素到指定位置
	public void insert(int index, int element) {
		// 創建一個新的數組
		int[] newArr = new int[elements.length + 1];
		// 將原數組中的元素放入新數組中。
		for (int i = 0; i < elements.length; i++) {
			// 目標位置之前的元素
			if (i < index) {
				newArr[i] = elements[i];
				// 目標位置之後的元素
			} else {
				newArr[i + 1] = elements[i];
			}
		}
		// 插入新的元素
		newArr[index] = element;
		// 新數組替換舊數組
		elements = newArr;
	}

	// 替換指定位置的元素
	public void set(int index, int element) {
		// 判斷下標是否越界
		if (index < 0 || index > elements.length - 1) {
			throw new RuntimeException("下標越界");
		}
		elements[index] = element;
	}

	// 線性查找
	public int search(int target) {
		// 遍歷數組
		for (int i = 0; i < elements.length; i++) {
			if (elements[i] == target) {
				return i;
			}
		}
		// 沒有找到對應的元素
		return -1;
	}

	// 二分法查找
	public int binarySearch(int target) {
		// 記錄開始位置
		int begin = 0;
		// 記錄結束位置
		int end = elements.length - 1;
		// 記錄中間的位置
		int mid = (begin + end) / 2;
		// 循環查找
		while (true) {
			// 什麼情況下沒有這個元素？
			// 開始在結束位置之後或重合,沒有這個元素
			if (begin >= end) {
				return -1;
			}
			// 判斷中間的這個元素是不是要查找的元素
			if (elements[mid] == target) {
				return mid;
				// 中間這個元素不是要查的元素
			} else {
				// 判斷中間這個元素是不是比目標元素大
				if (elements[mid] > target) {
					// 把結束位置調整到中間位置前一個位置
					end = mid - 1;
					// 中間這個元素比目標元素小
				} else {
					// 把開始位置調整到中間位置的後一個位置
					begin = mid + 1;
				}
				// 取出新的中間位置
				mid = (begin + end) / 2;
			}
		}
	}

}

2、TestMyArraySearch.java

package demo1;

import demo1.util.MyArray;

public class TestMyArraySearch {

	public static void main(String[] args) {
		MyArray ma = new MyArray();
		ma.add(1);
		ma.add(2);
		ma.add(3);
		ma.add(4);
		ma.add(5);
		// 調用線性查找方法
		int index = ma.search(0);
		System.out.println("index: " + index);
		// 調用二分法查找
		int index2 = ma.binarySearch(6);
		System.out.println("index2: " + index2);
	}

}