大話數據結構
目錄：
數據結構和算法理論
線性表
棧與隊列
串
樹
查找
排序
數據結構和算法理論
數據
描述客觀事實的符號，是計算機可操作的對象，是能被計算機識別，並輸入給計算機處理的符號集合。
數據元素
是組成數據的，有一定意義的基本單位，在計算機中通常作爲整體處理，也稱爲記錄。比如 人。
數據項
一個數據元素可以由若干數據項組成。比如 手，腳
數據對象
是性質相同的數據元素的集合，是數據的子集。
數據結構
是相互存在一種或多種特定關係的數據元素的集合。
數據的關係存在 邏輯關係和物理結構
邏輯關係
集合關係
線性關係
樹形結構
圖形結構
物理結構
順序存儲結構
鏈式存儲結構
算法
算法是解決特定問題求解步驟的描述，在計算機中表現爲指令的有限序列。並且每個指令代表一個或多個操作。
算法的特性
輸入輸出
有窮性
確定性
可行性
算法的設計要求
正確性
可讀性
健壯性
算法效率的度量方法
事後統計法
事前估算法
函數的漸進增長
算法時間複雜度
大0推導法
用常數1取代運行時間中的所有加法常數
只保留最高階項
去掉前面的常數
常數階，線性階，對數階，平方階，立方階，指數階，階乘階
線性表
零個或多個數據元素的有限序列
棧與隊列
棧：是限定僅在表尾進行插入和刪除操作的線性表。後進先出LFIO,能操作的一段叫做棧頂，另一端稱爲棧底。
隊列：是隻允許在一端進行插入，另一端進行刪除的線性表。FIFO先進先出，允許插入的稱爲隊尾，允許刪除的爲對頭。
串
由零個或多個字符組成的有限序列，又叫做字符串
樹
由多個節點組成。
節點
度
深度
雙親
祖先
孩子
兄弟
樹的存儲結構
雙親表示法
孩子表示法
孩子兄弟表示法
二叉樹
每個節點最多有2個子樹
左子樹和右子樹是有順序的，不能顛倒
即使樹中只有一個棵子樹也要區分左或右
二叉樹的存儲結構
完全二叉樹 才使用順序存儲就是數組
二叉鏈表 節點 有左右孩子
遍歷二叉樹
指從根節點出發按某種次序依次訪問二叉樹中所有的節點，使得每個節點被訪問一次且僅被訪問一次
前序遍歷 根左右
中序遍歷 左根右
後序遍歷 左右根
層序遍歷 一層一層訪問
二叉樹的建立
查找
順序查找
二分查找
二叉排序樹
平衡二叉樹
散列查找-哈希表
散列函數的構造方法
計算簡單
散列地址分佈均勻
直接定址法：取關鍵字的某個線性函數值爲散列地址。
數字分析法：
平方求中法：
摺疊法：
除留餘數法：
隨機數法
處理衝突方法
開放定址法：也叫線性探測法
再散列函數法
鏈地址法：
公共溢出區法
排序
基礎代碼
/** 交換數組中的 2個 下標位置值 ,i被交換，j交換 */
private static void swap(int[] des, int i, int j) {
int temp = des[i];
des[i] = des[j];
des[j] = temp;
}
/** 打印數組 */
public static void printArray(String tag, int[] data) {
StringBuilder builder = new StringBuilder(tag);
for (int i = 0; i < data.length; i++) {
builder.append(data[i] + ",");
}
System.out.println(builder);
}
/** 打印單個 */
public static void printInt(String tag, int data) {
System.out.println(tag + "=" + data);
}
/** 打印單個 */
public static void printInt(String msg) {
System.out.println(msg);
}
int[] bubble = { 4, 5, 3, 1, 2 };
int[] inset = { 0, 5, 3, 4, 6, 2 };// 0作爲臨時變量或者哨兵
int[] shell = { 0, 7, 5, 8, 3, 2, 4, 6, 1 };// 0作爲臨時變量或者哨兵
int[] merge = { 7, 5, 8, 3, 2, 4, 6, 1};
int[] quick = { 7, 5, 8, 3, 2, 4, 6, 1 };
冒泡排序
/** 冒泡 //兩兩比較相鄰記錄的關鍵字，如果反序則交換 */
private static void bubble(int[] data) {
printArray("----------------bubble----------", data);
int len = data.length;
boolean flag = true;
for (int i = 0; i < len && flag; i++) {
flag = false;
for (int j = len - 1; j > i; j--) {
if (data[j] < data[j - 1]) {
swap(data, j, j - 1);
flag = true;
printArray("swap:", data);
}
}
printInt("--------------------" + i);
}
printArray("----------------bubble----------", data);
}
選擇排序
/** 選擇,改進型 交換，一次循環記錄最小的，然後換一次 */
private static void select(int[] data) {
printArray("----------------select----------", data);
int len = data.length;
int min = 0;
for (int i = 0; i < len; i++) {
printInt("-------------------------" + i);
min = i;
for (int j = i + 1; j < len; j++) {
if (data[j] < data[min]) {
min = j;
}
}
if (i != min) {
swap(data, i, min);
printArray("swap:", data);
}
}
printArray("----------------select----------", data);
}
插入排序
/** 簡單插入,慢慢移動位置 插入到指定位置，和排隊類似 */
private static void insert(int[] newSrc) {
printArray("----------------insert----------", newSrc);
int i, j;
for (i = 2; i < 6; i++) {
printInt("-------------------------" + i);
if (newSrc[i] < newSrc[i - 1]) {
newSrc[0] = newSrc[i];// 寄存 i的值
printArray("insert-zero-", newSrc);
for (j = i - 1; newSrc[j] > newSrc[0]; j--) {
newSrc[j + 1] = newSrc[j];// 往後移動一個位置 空出合適的位置
printArray("insert-two-", newSrc);
}
newSrc[j + 1] = newSrc[0]; // 把值插入 空出的位置
printArray("insert-one-", newSrc);
}
}
printArray("----------------insert----------", newSrc);
}
希爾排序
/** 希爾排序-升級插入排序-用增量去切割整體待排序-使得基本有序-簡單插入的升級版-就是把1換成了增量 */
private static void shellSort(int[] src) {
printArray("----------------shellSort----------", src);
int increment = 8;// 爲待排序的數據長度
int i, j;
do {
increment = increment / 3 + 1;// 與簡單插入排序相比把1替換爲 increment，減少了排序次數.
printInt("------------------increment=" + increment);
for (i = increment + 1; i <= 8; i++) {
printInt("-----------------i=" + i);
if (src[i] < src[i - increment]) {// 將src[i]插入有序增列表中 這裏就是直接插入，
src[0] = src[i];// 暫存
for (j = i - increment; j > 0 && src[j] > src[0]; j -= increment) {
src[j + increment] = src[j];// 空出插入位置
printArray("insert one:", src);
}
src[j + increment] = src[0];
printArray("insert two:", src);
}
}
} while (increment > 1);
printArray("----------------shellSort----------", src);
}
並歸排序
/** 並歸排序-用遞歸的思想-遞歸和樹是一樣的 執行順序和前序遍歷一樣，從左到右 */
private static void mergeSort(int[] src) {
printArray("mergeSort-src：", src);
MSort(src, src, 0, src.length-1);
}
private static void MSort(int[] SR, int[] TR, int low, int high) {
int mid;
int[] NewTR = new int[high+1];
if (low == high) {
TR[low] = SR[low]; //這個是退出遞歸條件，否則就會無限遞歸，當遞歸到只有1個元素時就退出。
} else {
mid = (low + high) / 2;
MSort(SR, NewTR, low, mid);
MSort(SR, NewTR, mid + 1, high);
Merge(NewTR, TR, low, mid, high);
}
}
private static void Merge(int[] SR, int[] TR, int low, int mid, int high) {
int j, k, l;
for (j = mid + 1, k = low; low <= mid && j <= high; k++) {
if (SR[low] < SR[j]) {
TR[k] = SR[low++];
} else {
TR[k] = SR[j++];
}
}
if (low <= mid) {
for (l = 0; l <= mid - low; l++) {
TR[k + l] = SR[low + l];
}
}
if (j <= high) {
for (l = 0; l <= high - j; l++) {
TR[k + l] = SR[j + l];
}
}
}
快速排序
/** 快速排序-冒泡排序的升級版-把大的待排序切割成小的 */
private static void quickSort(int[] src) {
qSort(src, 0, src.length - 1);
}
private static void qSort(int[] des, int low, int high) {
int pivot;
if (low < high) {
pivot = partition(des, low, high);// 樞軸
printInt("qSort--pivot=" + pivot );
qSort(des, low, pivot - 1);
qSort(des, pivot + 1, high);
}
}
/** 大的數據分割成小的部分 */
private static int partition(int[] des, int low, int high) {
int value;
value = des[low];
while (low < high) {
while (low < high && des[high] >= value) {
high--;
}
swap(des, low, high);
while (low < high && des[low] <= value) {
low++;
}
swap(des, low, high);
}
return low;
}