17春北理工《实用数据结构与算法》在线作业_百度文库
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
17春北理工《实用数据结构与算法》在线作业
文化艺术交流活动,远程教育学习辅助，商务信...|
总评分0.0|
阅读已结束，下载本文需要
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩32页未读，
定制HR最喜欢的简历
你可能喜欢没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！常见数据结构与算法整理总结（下） - 简书
常见数据结构与算法整理总结（下）
这篇文章是常见数据结构与算法整理总结的下篇，上一篇主要是对常见的数据结构进行集中总结，这篇主要是总结一些常见的算法相关内容，文章中如有错误，欢迎指出。
二、查找算法
三、排序算法
四、其它算法
五、常见算法题
以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习总结。
算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。对于同一个问题的解决，可能会存在着不同的算法，为了衡量一个算法的优劣，提出了空间复杂度与时间复杂度这两个概念。
时间复杂度
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，算法的时间度量记为 ** T(n) = O(f(n)) **，它表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度。这里需要重点理解这个增长率。
举个例子，看下面3个代码：
2、for(i = 1; i &= i++) { ++x; }
3、for(j = 1; j &= j++)
for(j = 1; j &= j++)
上述含有 ++x 操作的语句的频度分别为1 、n 、n^2，
假设问题的规模扩大了n倍，3个代码的增长率分别是1 、n 、n^2
它们的时间复杂度分别为O(1)、O(n )、O(n^2)
空间复杂度
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。
二、查找算法
查找和排序是最基础也是最重要的两类算法，熟练地掌握这两类算法，并能对这些算法的性能进行分析很重要，这两类算法中主要包括二分查找、快速排序、归并排序等等。
顺序查找又称线性查找。它的过程为：从查找表的最后一个元素开始逐个与给定关键字比较，若某个记录的关键字和给定值比较相等，则查找成功，否则，若直至第一个记录，其关键字和给定值比较都不等，则表明表中没有所查记录查找不成功，它的缺点是效率低下。
二分查找又称折半查找，对于有序表来说，它的优点是比较次数少，查找速度快，平均性能好。
二分查找的基本思想是将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x，算法中止；如果x&a[n/2]，则只要在数组a的左半部分继续搜索x，如果x&a[n/2]，则只要在数组a的右半部搜索x。
二分查找的时间复杂度为O(logn)
//给定有序查找表array 二分查找给定的值data
//查找成功返回下标 查找失败返回-1
static int funBinSearch(int[] array, int data) {
int low = 0;
int high = array.length - 1;
while (low &= high) {
int mid = (low + high) / 2;
if (data == array[mid]) {
} else if (data & array[mid]) {
high = mid - 1;
low = mid + 1;
return -1;
三、排序算法
排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。下面主要对一些常见的排序算法做介绍，并分析它们的时空复杂度。
常见排序算法
常见排序算法性能比较：
图片来自网络
上面这张表中有稳定性这一项，排序的稳定性是指如果在排序的序列中，存在前后相同的两个元素的话，排序前和排序后他们的相对位置不发生变化。
下面从冒泡排序开始逐一介绍。
冒泡排序的基本思想是：设排序序列的记录个数为n，进行n-1次遍历，每次遍历从开始位置依次往后比较前后相邻元素，这样较大的元素往后移，n-1次遍历结束后，序列有序。
例如，对序列(3,2,1,5)进行排序的过程是：共进行3次遍历，第1次遍历时先比较3和2，交换，继续比较3和1,交换，再比较3和5，不交换，这样第1次遍历结束，最大值5在最后的位置，得到序列(2,1,3,5)。第2次遍历时先比较2和1，交换，继续比较2和3，不交换，第2次遍历结束时次大值3在倒数第2的位置，得到序列(1,2,3,5)，第3次遍历时，先比较1和2，不交换，得到最终有序序列(1,2,3,5)。
需要注意的是，如果在某次遍历中没有发生交换，那么就不必进行下次遍历，因为序列已经有序。
// 冒泡排序 注意 flag 的作用
static void funBubbleSort(int[] array) {
boolean flag =
for (int i = 0; i & array.length - 1 && i++) {
for (int j = 0; j & array.length - 1 - j++) {
if (array[j] & array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] =
for (int i = 0; i & array. i++) {
System.out.println(array[i]);
最佳情况下冒泡排序只需一次遍历就能确定数组已经排好序，不需要进行下一次遍历，所以最佳情况下，时间复杂度为** O(n) **。
最坏情况下冒泡排序需要n-1次遍历，第一次遍历需要比较n-1次，第二次遍历需要n-2次，...，最后一次需要比较1次，最差情况下时间复杂度为** O(n^2) **。
简单选择排序
简单选择排序的思想是：设排序序列的记录个数为n，进行n-1次选择，每次在n-i+1(i = 1,2,...,n-1)个记录中选择关键字最小的记录作为有效序列中的第i个记录。
例如，排序序列(3,2,1,5)的过程是，进行3次选择，第1次选择在4个记录中选择最小的值为1，放在第1个位置，得到序列(1,3,2,5)，第2次选择从位置1开始的3个元素中选择最小的值2放在第2个位置，得到有序序列(1,2,3,5)，第3次选择因为最小的值3已经在第3个位置不需要操作，最后得到有序序列（1,2,3,5）。
static void funSelectionSort(int[] array) {
for (int i = 0; i & array.length - 1; i++) {
int mink =
// 每次从未排序数组中找到最小值的坐标
for (int j = i + 1; j & array. j++) {
if (array[j] & array[mink]) {
// 将最小值放在最前面
if (mink != i) {
int temp = array[mink];
array[mink] = array[i];
array[i] =
for (int i = 0; i & array. i++) {
System.out.print(array[i] + " ");
简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况** 无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为 O(n^2) ，进行移动操作的时间复杂度为 O(n) 。总的时间复杂度为 O(n^2) **。
最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。最坏情况下，即待排序记录初始状态是按第一条记录最大，之后的记录从小到大顺序排列，则需要移动记录的次数最多为3（n-1）。
简单选择排序是不稳定排序。
直接插入排序
直接插入的思想是：是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。
例如，排序序列(3,2,1,5)的过程是，初始时有序序列为(3)，然后从位置1开始，先访问到2，将2插入到3前面，得到有序序列(2,3)，之后访问1,找到合适的插入位置后得到有序序列(1,2,3)，最后访问5，得到最终有序序列(1,2,3,5).
static void funDInsertSort(int[] array) {
for (int i = 1; i & array. i++) {
int temp = array[i];
j = i - 1;
while (j & -1 && temp & array[j]) {
array[j + 1] = array[j];
array[j + 1] =
for (int i = 0; i & array. i++) {
System.out.print(array[i] + " ");
最好情况下，当待排序序列中记录已经有序时，则需要n-1次比较，不需要移动，时间复杂度为** O(n) 。最差情况下，当待排序序列中所有记录正好逆序时，则比较次数和移动次数都达到最大值，时间复杂度为 O(n^2) 。平均情况下，时间复杂度为 O(n^2) **。
希尔排序又称“缩小增量排序”，它是基于直接插入排序的以下两点性质而提出的一种改进：(1) 直接插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。(2) 直接插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。
归并排序是分治法的一个典型应用，它的主要思想是：将待排序序列分为两部分，对每部分递归地应用归并排序，在两部分都排好序后进行合并。
例如，排序序列(3,2,8,6,7,9,1,5)的过程是，先将序列分为两部分，(3,2,8,6)和(7,9,1,5)，然后对两部分分别应用归并排序，第1部分(3,2,8,6)，第2部分(7,9,1,5)，对两个部分分别进行归并排序，第1部分继续分为(3,2)和(8,6)，(3,2)继续分为(3)和(2)，(8,6)继续分为(8)和(6)，之后进行合并得到(2,3)，(6,8)，再合并得到(2,3,6,8)，第2部分进行归并排序得到(1,5,7,9)，最后合并两部分得到(1,2,3,5,6,7,8,9)。
//归并排序
static void funMergeSort(int[] array) {
if (array.length & 1) {
int length1 = array.length / 2;
int[] array1 = new int[length1];
System.arraycopy(array, 0, array1, 0, length1);
funMergeSort(array1);
int length2 = array.length - length1;
int[] array2 = new int[length2];
System.arraycopy(array, length1, array2, 0, length2);
funMergeSort(array2);
int[] datas = merge(array1, array2);
System.arraycopy(datas, 0, array, 0, array.length);
//合并两个数组
static int[] merge(int[] list1, int[] list2) {
int[] list3 = new int[list1.length + list2.length];
int count1 = 0;
int count2 = 0;
int count3 = 0;
while (count1 & list1.length && count2 & list2.length) {
if (list1[count1] & list2[count2]) {
list3[count3++] = list1[count1++];
list3[count3++] = list2[count2++];
while (count1 & list1.length) {
list3[count3++] = list1[count1++];
while (count2 & list2.length) {
list3[count3++] = list2[count2++];
return list3;
归并排序的时间复杂度为O(nlogn)，它是一种稳定的排序，java.util.Arrays类中的sort方法就是使用归并排序的变体来实现的。
快速排序的主要思想是：在待排序的序列中选择一个称为主元的元素，将数组分为两部分，使得第一部分中的所有元素都小于或等于主元，而第二部分中的所有元素都大于主元，然后对两部分递归地应用快速排序算法。
// 快速排序
static void funQuickSort(int[] mdata, int start, int end) {
if (end & start) {
int pivotIndex = quickSortPartition(mdata, start, end);
funQuickSort(mdata, start, pivotIndex - 1);
funQuickSort(mdata, pivotIndex + 1, end);
// 快速排序前的划分
static int quickSortPartition(int[] list, int first, int last) {
int pivot = list[first];
int low = first + 1;
int high =
while (high & low) {
while (low &= high && list[low] &= pivot) {
while (low &= high && list[high] & pivot) {
if (high & low) {
int temp = list[high];
list[high] = list[low];
list[low] =
while (high & first && list[high] &= pivot) {
if (pivot & list[high]) {
list[first] = list[high];
list[high] =
在快速排序算法中，比较关键的一个部分是主元的选择。在最差情况下，划分由n个元素构成的数组需要进行n次比较和n次移动，因此划分需要的时间是O(n)。在最差情况下，每次主元会将数组划分为一个大的子数组和一个空数组，这个大的子数组的规模是在上次划分的子数组的规模上减1，这样在最差情况下算法需要(n-1)+(n-2)+...+1= ** O(n^2) **时间。
最佳情况下，每次主元将数组划分为规模大致相等的两部分，时间复杂度为** O(nlogn) **。
在介绍堆排序之前首先需要了解堆的定义，n个关键字序列K1，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：(1) ki &= k(2i）且 ki &= k(2i+1) (1 ≤ i≤ n/2），当然，这是小根堆，大根堆则换成&=号。
如果将上面满足堆性质的序列看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有的非终端节点的值均不大于（或不小于）其左右孩子节点的值。
堆排序的主要思想是：给定一个待排序序列，首先经过一次调整，将序列构建成一个大顶堆，此时第一个元素是最大的元素，将其和序列的最后一个元素交换，然后对前n-1个元素调整为大顶堆，再将其第一个元素和末尾元素交换，这样最后即可得到有序序列。
public class TestHeapSort {
public static void main(String[] args) {
int arr[] = { 5, 6, 1, 0, 2, 9 };
heapsort(arr, 6);
System.out.println(Arrays.toString(arr));
static void heapsort(int arr[], int n) {
// 先建大顶堆
for (int i = n / 2 - 1; i &= 0; i--) {
heapAdjust(arr, i, n);
for (int i = 0; i & n - 1; i++) {
swap(arr, 0, n - i - 1);
heapAdjust(arr, 0, n - i - 1);
// 交换两个数
static void swap(int arr[], int low, int high) {
int temp = arr[low];
arr[low] = arr[high];
arr[high] =
static void heapAdjust(int arr[], int index, int n) {
int temp = arr[index];
int child = 0;
while (index * 2 + 1 & n) {
child = index * 2 + 1;
// child为左右孩子中较大的那个
if (child != n - 1 && arr[child] & arr[child + 1]) {
// 如果指定节点大于较大的孩子 不需要调整
if (temp & arr[child]) {
// 否则继续往下判断孩子的孩子 直到找到合适的位置
arr[index] = arr[child];
arr[index] =
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。堆排序时间复杂度也为O(nlogn)，空间复杂度为O(1)。它是不稳定的排序方法。与快排和归并排序相比，堆排序在最差情况下的时间复杂度优于快排，空间效率高于归并排序。
四、其它算法
在上面的篇幅中，主要是对查找和常见的几种排序算法作了介绍，这些内容都是基础的但是必须掌握的内容，尤其是二分查找、快排、堆排、归并排序这几个更是面试高频考察点。（这里不禁想起百度一面的时候让我写二分查找和堆排序，二分查找还行，然而堆排序当时一脸懵逼...）下面主要是介绍一些常见的其它算法。
在平常解决一些编程或者做一些算法题的时候，经常会用到递归。程序调用自身的编程技巧称为递归。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。上面介绍的快速排序和归并排序都用到了递归的思想。
斐波那契数列，又称黄金分割数列、因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。
//斐波那契数列 递归实现
static long funFib(long index) {
if (index == 0) {
} else if (index == 1) {
return funFib(index - 1) + funFib(index - 2);
上面代码是斐波那契数列的递归实现，然而我们不难得到它的时间复杂度是O(2^n)，递归有时候可以很方便地解决一些问题，但是它也会带来一些效率上的问题。下面的代码是求斐波那契数列的另一种方式，效率比递归方法的效率高。
static long funFib2(long index) {
long f0 = 0;
long f1 = 1;
long f2 = 1;
if (index == 0) {
return f0;
} else if (index == 1) {
return f1;
} else if (index == 2) {
return f2;
for (int i = 3; i &= i++) {
f2 = f0 + f1;
return f2;
分治算法的思想是将待解决的问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后合并这些子问题的解来建立最终的解。分治算法中关键地一步其实就是递归地求解子问题。关于分治算法的一个典型例子就是上面介绍的归并排序。
动态规划与分治方法相似，都是通过组合子问题的解来求解待解决的问题。但是，分治算法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，而动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。动态规划方法通常用来求解最优化问题。
动态规划典型的一个例子是问题。
常见的算法还有很多，比如贪心算法，回溯算法等等，这里都不再详细介绍，想要熟练掌握，还是要靠刷题，刷题，刷题，然后总结。
五、常见算法题
下面是一些常见的算法题汇总。
不使用临时变量交换两个数
static void funSwapTwo(int a, int b) {
System.out.println(a + " " + b);
判断一个数是否为素数
static boolean funIsPrime(int m) {
boolean flag =
if (m == 1) {
for (int i = 2; i &= Math.sqrt(m); i++) {
if (m % i == 0) {
其它算法题
以上就是自己对常见的算法相关内容的总结，算法虐我千百遍，我待算法如初恋，革命尚未成功，同志仍需刷题，加油。
道可顿悟，事须渐修。
第一章 绪论 什么是数据结构？ 数据结构的定义：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 第二章 算法 算法的特性：有穷性、确定性、可行性、输入、输出。 什么是好的算法？ ----正确性、可读性、健壮性、时间效率高、存储量低 函数的渐近增长：给定两个函数f...
前言 查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两...
因为之前就复习完数据结构了，所以为了保持记忆，整理了一份复习纲要，复习的时候可以看着纲要想具体内容。 树 树的基本概念树是递归的定义有序树（如二叉树）树的高度（叶结点高度为1）树的性质（王道补充）高度为h的m叉树至多结点数: (m^h - 1)/(m-1)，等比数列求和公式...
1. 链表 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。 链表问题中的一个重要的方法叫双指针...
本篇有7k+字, 系统梳理了js中排序算法相关的知识, 希望您能喜欢. 原文:JS中可能用得到的全部的排序算法 导读 排序算法可以称得上是我的盲点, 曾几何时当我知道Chrome的Array.prototype.sort使用了快速排序时, 我的内心是奔溃的(啥是快排, 我只...
盛德煌：小白如何做销售？ 做销售就是销售自己，做销售就是要对自己狠一点，你不对自己狠，市场对你狠，你就要被淘汰。成功在于学习，不断给自己充电。也许下面我说的你可能觉得似曾相识，就不往下读了，记得毛主席读资治通鉴十七遍，每遍收获都是不一样的。其实读多少遍也不过是每天伴读自己、...
今天推荐的书是《三杯茶》，有人说，人生就如三泡茶，第一杯：清香中带着苦涩，苦涩中富含回味，这就宛如人生的开端，充满希望、意味深长；第二杯：淡雅中百转千回，苦涩变清淡、幽香变平凡，就宛如人生的成长路，味道多变却值得回味；第三杯：芳香不在，苦涩亦不在，仅留下浅浅的味道，清而无味...
同！学！们！开学啦！~~ 春天是播种的季节，也是充满希望的季节，3月12日的植树节，迎来了天科教育2017级新生的开学典礼，新年新学期，当然要有新的打开方式！一起来看看天科学子们的花式开学style~ 环江徒步、拼手气抢红包赢大奖？是不是走错片场了？没错！我们的开学活动就是...
“研究生导师、博士生导师不是贪财就是好色”，这说法近些年十分流行，整得就跟每位硕士生导师、博士生导师都有些说不清的桃色绯闻似的。 作为一名已经毕业的硕士研究生，我认真而负责地说，不能因为个别不良导师的问题就将一个巨大的脏帽子扣在整个导师群体的头上。 重要的事情说三遍！ 导师...关注51Testing
游戏开发中常用数据结构和算法
发表于： 10:10 &作者：未知 & 来源：51Testing软件测试网采编
推荐标签：
&软件大小：196KB资源类型：资料类授权方式：免费/开源资料&&&简介：& &&专业教程，理论讲解部分.......
搜索风云榜
51Testing官方微信
51Testing官方微博
测试知识全知道常见数据结构与算法整理总结（上） - 简书
常见数据结构与算法整理总结（上）
数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容，如有错误，欢迎指出。
为了便于描述，文中涉及到的代码部分都是用Java语言编写的，其实Java本身对常见的几种数据结构，线性表、栈、队列等都提供了较好的实现，就是我们经常用到的Java集合框架，有需要的可以阅读这篇文章。
一、线性表
1.数组实现
二、栈与队列
三、树与二叉树
2.二叉树基本概念
3.二叉查找树
4.平衡二叉树
一、线性表
线性表是最常用且最简单的一种数据结构，它是n个数据元素的有限序列。
实现线性表的方式一般有两种，一种是使用数组存储线性表的元素，即用一组连续的存储单元依次存储线性表的数据元素。另一种是使用链表存储线性表的元素，即用一组任意的存储单元存储线性表的数据元素（存储单元可以是连续的，也可以是不连续的）。
数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。
创建一个更大的数组来替换当前数组
int[] oldArray = new int[10];
int[] newArray = new int[20];
for (int i = 0; i & oldArray. i++) {
newArray[i] = oldArray[i];
// 也可以使用System.arraycopy方法来实现数组间的复制
// System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
oldArray = newA
代码2 在数组位置index上添加元素e
//oldArray 表示当前存储元素的数组
//size 表示当前元素个数
public void add(int index, int e) {
if (index & size || index & 0) {
System.out.println("位置不合法...");
//如果数组已经满了 就扩容
if (size &= oldArray.length) {
// 扩容函数可参考代码1
for (int i = size - 1; i &= i--) {
oldArray[i + 1] = oldArray[i];
//将数组elementData从位置index的所有元素往后移一位
// System.arraycopy(oldArray, index, oldArray, index + 1,size - index);
oldArray[index] =
上面简单写出了数组实现线性表的两个典型函数，具体我们可以参考Java里面的ArrayList集合类的源码。数组实现的线性表优点在于可以通过下标来访问或者修改元素，比较高效，主要缺点在于插入和删除的花费开销较大，比如当在第一个位置前插入一个元素，那么首先要把所有的元素往后移动一个位置。为了提高在任意位置添加或者删除元素的效率，可以采用链式结构来实现线性表。
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，这些节点不必在内存中相连。每个节点由数据部分Data和链部分Next，Next指向下一个节点，这样当添加或者删除时，只需要改变相关节点的Next的指向，效率很高。
单链表的结构
下面主要用代码来展示链表的一些基本操作，需要注意的是，这里主要是以单链表为例，暂时不考虑双链表和循环链表。
代码3 链表的节点
class Node&E& {
//构造函数
Node(E element) {
this.item =
this.next =
代码4 定义好节点后，使用前一般是对头节点和尾节点进行初始化
//头节点和尾节点都为空 链表为空
Node&E& head =
Node&E& tail =
代码5 空链表创建一个新节点
//创建一个新的节点 并让head指向此节点
head = new Node("nodedata1");
//让尾节点也指向此节点
代码6 链表追加一个节点
//创建新节点 同时和最后一个节点连接起来
tail.next = new Node("node1data2");
//尾节点指向新的节点
tail = tail.
代码7 顺序遍历链表
Node&String& current =
while (current != null) {
System.out.println(current.item);
current = current.
代码8 倒序遍历链表
static void printListRev(Node&String& head) {
//倒序遍历链表主要用了递归的思想
if (head != null) {
printListRev(head.next);
System.out.println(head.item);
代码 单链表反转
//单链表反转 主要是逐一改变两个节点间的链接关系来完成
static Node&String& revList(Node&String& head) {
if (head == null) {
Node&String& nodeResult =
Node&String& nodePre =
Node&String& current =
while (current != null) {
Node&String& nodeNext = current.
if (nodeNext == null) {
nodeResult =
current.next = nodeP
current = nodeN
return nodeR
上面的几段代码主要展示了链表的几个基本操作，还有很多像获取指定元素，移除元素等操作大家可以自己完成，写这些代码的时候一定要理清节点之间关系，这样才不容易出错。
链表的实现还有其它的方式，常见的有循环单链表，双向链表，循环双向链表。 循环单链表 主要是链表的最后一个节点指向第一个节点，整体构成一个链环。 双向链表 主要是节点中包含两个指针部分，一个指向前驱元，一个指向后继元，JDK中LinkedList集合类的实现就是双向链表。** 循环双向链表** 是最后一个节点指向第一个节点。
二、栈与队列
栈和队列也是比较常见的数据结构，它们是比较特殊的线性表，因为对于栈来说，访问、插入和删除元素只能在栈顶进行，对于队列来说，元素只能从队列尾插入，从队列头访问和删除。
栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈顶，对栈的基本操作有push(进栈)和pop(出栈)，前者相当于插入，后者相当于删除最后一个元素。栈有时又叫作LIFO(Last In First Out)表，即后进先出。
下面我们看一道经典题目，加深对栈的理解。
关于栈的一道经典题目
上图中的答案是C，其中的原理可以好好想一想。
因为栈也是一个表，所以任何实现表的方法都能实现栈。我们打开JDK中的类Stack的源码，可以看到它就是继承类Vector的。当然，Stack是Java2前的容器类，现在我们可以使用LinkedList来进行栈的所有操作。
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
队列示意图
我们可以使用链表来实现队列，下面代码简单展示了利用LinkedList来实现队列类。
代码9 简单实现队列类
public class MyQueue&E& {
private LinkedList&E& list = new LinkedList&&();
public void enqueue(E e) {
list.addLast(e);
public E dequeue() {
return list.removeFirst();
普通的队列是一种先进先出的数据结构，而优先队列中，元素都被赋予优先级。当访问元素的时候，具有最高优先级的元素最先被删除。优先队列在生活中的应用还是比较多的，比如医院的急症室为病人赋予优先级，具有最高优先级的病人最先得到治疗。在Java集合框架中，类PriorityQueue就是优先队列的实现类，具体大家可以去阅读源码。
三、树与二叉树
树型结构是一类非常重要的非线性数据结构，其中以树和二叉树最为常用。在介绍二叉树之前，我们先简单了解一下树的相关内容。
** 树 是由n（n&=1）个有限节点组成一个具有层次关系的集合。它具有以下特点：每个节点有零个或多个子节点；没有父节点的节点称为 根 节点；每一个非根节点有且只有一个 父节点 **；除了根节点外，每个子节点可以分为多个不相交的子树。
二叉树基本概念
二叉树是每个节点最多有两棵子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树常被用于实现二叉查找树和二叉堆。
二叉树的每个结点至多只有2棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。
二叉树的第i层至多有2(i-1)个结点；深度为k的二叉树至多有2k-1个结点。
一棵深度为k，且有2^k-1个节点的二叉树称之为** 满二叉树 **；
深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为** 完全二叉树 **。
三种遍历方法
在二叉树的一些应用中，常常要求在树中查找具有某种特征的节点，或者对树中全部节点进行某种处理，这就涉及到二叉树的遍历。二叉树主要是由3个基本单元组成，根节点、左子树和右子树。如果限定先左后右，那么根据这三个部分遍历的顺序不同，可以分为先序遍历、中序遍历和后续遍历三种。
(1) 先序遍历 若二叉树为空，则空操作，否则先访问根节点，再先序遍历左子树，最后先序遍历右子树。 (2) 中序遍历 若二叉树为空，则空操作，否则先中序遍历左子树，再访问根节点，最后中序遍历右子树。(3) 后序遍历 若二叉树为空，则空操作，否则先后序遍历左子树访问根节点，再后序遍历右子树，最后访问根节点。
给定二叉树写出三种遍历结果
树和二叉树的区别
(1) 二叉树每个节点最多有2个子节点，树则无限制。 (2) 二叉树中节点的子树分为左子树和右子树，即使某节点只有一棵子树，也要指明该子树是左子树还是右子树，即二叉树是有序的。 (3) 树决不能为空，它至少有一个节点，而一棵二叉树可以是空的。
上面我们主要对二叉树的相关概念进行了介绍，下面我们将从二叉查找树开始，介绍二叉树的几种常见类型，同时将之前的理论部分用代码实现出来。
二叉查找树
二叉查找树就是二叉排序树，也叫二叉搜索树。二叉查找树或者是一棵空树，或者是具有下列性质的二叉树： (1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；(2) 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；(3) 左、右子树也分别为二叉排序树；(4) 没有键值相等的结点。
典型的二叉查找树的构建过程
对于二叉查找树来说，当给定值相同但顺序不同时，所构建的二叉查找树形态是不同的，下面看一个例子。
不同形态平衡二叉树的ASL不同
可以看到，含有n个节点的二叉查找树的平均查找长度和树的形态有关。最坏情况下，当先后插入的关键字有序时，构成的二叉查找树蜕变为单支树，树的深度为n，其平均查找长度(n+1)/2(和顺序查找相同），最好的情况是二叉查找树的形态和折半查找的判定树相同，其平均查找长度和log2(n)成正比。平均情况下，二叉查找树的平均查找长度和logn是等数量级的，所以为了获得更好的性能，通常在二叉查找树的构建过程需要进行“平衡化处理”，之后我们将介绍平衡二叉树和红黑树，这些均可以使查找树的高度为O(log(n))。
代码10 二叉树的节点
class TreeNode&E& {
TreeNode&E&
TreeNode&E&
public TreeNode(E e) {
二叉查找树的三种遍历都可以直接用递归的方法来实现：
代码12 先序遍历
protected void preorder(TreeNode&E& root) {
if (root == null)
System.out.println(root.element + " ");
preorder(root.left);
preorder(root.right);
代码13 中序遍历
protected void inorder(TreeNode&E& root) {
if (root == null)
inorder(root.left);
System.out.println(root.element + " ");
inorder(root.right);
代码14 后序遍历
protected void postorder(TreeNode&E& root) {
if (root == null)
postorder(root.left);
postorder(root.right);
System.out.println(root.element + " ");
代码15 二叉查找树的简单实现
* @author JackalTsc
public class MyBinSearchTree&E extends Comparable&E&& {
private TreeNode&E&
// 默认构造函数
public MyBinSearchTree() {
// 二叉查找树的搜索
public boolean search(E e) {
TreeNode&E& current =
while (current != null) {
if (e.compareTo(current.element) & 0) {
current = current.
} else if (e.compareTo(current.element) & 0) {
current = current.
// 二叉查找树的插入
public boolean insert(E e) {
// 如果之前是空二叉树 插入的元素就作为根节点
if (root == null) {
root = createNewNode(e);
// 否则就从根节点开始遍历 直到找到合适的父节点
TreeNode&E& parent =
TreeNode&E& current =
while (current != null) {
if (e.compareTo(current.element) & 0) {
current = current.
} else if (e.compareTo(current.element) & 0) {
current = current.
if (e.compareTo(parent.element) & 0) {
parent.left = createNewNode(e);
parent.right = createNewNode(e);
// 创建新的节点
protected TreeNode&E& createNewNode(E e) {
return new TreeNode(e);
// 二叉树的节点
class TreeNode&E extends Comparable&E&& {
TreeNode&E&
TreeNode&E&
public TreeNode(E e) {
上面的代码15主要展示了一个自己实现的简单的二叉查找树，其中包括了几个常见的操作，当然更多的操作还是需要大家自己去完成。因为在二叉查找树中删除节点的操作比较复杂，所以下面我详细介绍一下这里。
二叉查找树中删除节点分析
要在二叉查找树中删除一个元素，首先需要定位包含该元素的节点，以及它的父节点。假设current指向二叉查找树中包含该元素的节点，而parent指向current节点的父节点，current节点可能是parent节点的左孩子，也可能是右孩子。这里需要考虑两种情况：
current节点没有左孩子，那么只需要将patent节点和current节点的右孩子相连。
current节点有一个左孩子，假设rightMost指向包含current节点的左子树中最大元素的节点，而parentOfRightMost指向rightMost节点的父节点。那么先使用rightMost节点中的元素值替换current节点中的元素值，将parentOfRightMost节点和rightMost节点的左孩子相连，然后删除rightMost节点。
// 二叉搜索树删除节点
public boolean delete(E e) {
TreeNode&E& parent =
TreeNode&E& current =
// 找到要删除的节点的位置
while (current != null) {
if (e.compareTo(current.element) & 0) {
current = current.
} else if (e.compareTo(current.element) & 0) {
current = current.
// 没找到要删除的节点
if (current == null) {
// 考虑第一种情况
if (current.left == null) {
if (parent == null) {
root = current.
if (e.compareTo(parent.element) & 0) {
parent.left = current.
parent.right = current.
} else { // 考虑第二种情况
TreeNode&E& parentOfRightMost =
TreeNode&E& rightMost = current.
// 找到左子树中最大的元素节点
while (rightMost.right != null) {
parentOfRightMost = rightM
rightMost = rightMost.
current.element = rightMost.
// parentOfRightMost和rightMost左孩子相连
if (parentOfRightMost.right == rightMost) {
parentOfRightMost.right = rightMost.
parentOfRightMost.left = rightMost.
平衡二叉树
平衡二叉树又称AVL树，它或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。
平衡二叉树
AVL树是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为1，所以它也被称为高度平衡树，n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。
红黑树是平衡二叉树的一种，它保证在最坏情况下基本动态集合操作的事件复杂度为O(log n)。红黑树和平衡二叉树区别如下：(1) 红黑树放弃了追求完全平衡，追求大致平衡，在与平衡二叉树的时间复杂度相差不大的情况下，保证每次插入最多只需要三次旋转就能达到平衡，实现起来也更为简单。(2) 平衡二叉树追求绝对平衡，条件比较苛刻，实现起来比较麻烦，每次插入新节点之后需要旋转的次数不能预知。
图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。
因为图这部分的内容还是比较多的，这里就不详细介绍了，有需要的可以自己搜索相关资料。
到这里，关于常见的数据结构的整理就结束了，断断续续大概花了两天时间写完，在总结的过程中，通过查阅相关资料，结合书本内容，收获还是很大的，在下一篇博客中将会介绍常用数据结构与算法整理总结（下）之算法篇，欢迎大家关注。
道可顿悟，事须渐修。
1 序 日夜，帝都，天下着大雨，拖着行李箱和同学在校门口照了最后一张合照，搬离寝室打车去了提前租好的房子，算来工作刚满一年。在过去的一年里，很庆幸刚迈出校门的我遇见了现在的这一群同事，这一帮朋友，虽然工作之初经历波折，还是很开心有现在的工作环境。其实走在这...
一、数据结构绪论 数据结构的基本概念 数据结构是一门研究非数值计算的程序设计问题中，计算机的操作对象以及它们之间的关系和操作的学科。 数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 数据结构包含三个方面的含义：
第一章 绪论 什么是数据结构？ 数据结构的定义：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 第二章 算法 算法的特性：有穷性、确定性、可行性、输入、输出。 什么是好的算法？ ----正确性、可读性、健壮性、时间效率高、存储量低 函数的渐近增长：给定两个函数f...
1、线性表、栈和队列等数据结构所表达和处理的数据以线性结构为组织形式。栈是一种特殊的线性表，这种线性表只能在固定的一端进行插入和删除操作，允许插入和删除的一端称为栈顶，另一端称为栈底。一个新元素只能从栈顶一端进入，删除时，只能删除栈顶的元素，即刚刚被插入的元素。所以栈又称后...
基于树实现的数据结构，具有两个核心特征： 逻辑结构：数据元素之间具有层次关系； 数据运算：操作方法具有Log级的平均时间复杂度。 因此，树在文件系统、编译器、索引以及查找算法中有很广的应用，本节将以树-二叉树-二叉搜索树-自平衡二叉树为线索，对树及其扩展结构进行说明。 栈和...
今天娃在床上玩，我拿来《我爸爸》这本自己读。读到大猩猩那一页，他走过来看。看了会他说，吃香蕉。当然我还没反应过来，说大猩猩喜欢吃香蕉，猴子也喜欢吃香蕉。然后他把手在书上捏一下，喂到大猩猩的嘴巴边。我才发现原来哑铃两头是香蕉。后来问他爸，说是之前跟他讲过一次。其实这个梗有次在...
感谢婉婉的热情款待，5月3日晚上在奈梅亨他们的家中度过。奈梅亨是座典型的荷兰小城，几乎没有高层建筑，所有社区里都是有着悠久历史的别墅。 阿诺德非常喜欢我们送给他的小玩意儿，那是从淘宝上买来的一个刘关张诸葛亮打麻将的小摆件。本来还想吹吹牛，普及一下三国以及博大精深的麻将文化。...
江南春 秋瑟瑟，草凄凄。 微风凉沁骨，寒雨细笼衣。 人情反复皆常事，思忆今年春意融。 冬日既思春之温暖，热夏犹忆初秋凉爽，往往复复，略无停刻。近日秋雨连绵，此情更甚。 丙申猴年九月廿二记。
1 小县城最让人崩溃的，不是它没有公交车，而是，它的公交车不仅点不准，还没有联网。 这段时间天气总是反常。 因为实习的关系，必须顶着寒风簌簌步行到地域十分偏僻的交警大队，办完事回来的时候忽然下起了瓢泼大雨，一个人在暴雨中冻得瑟瑟发抖。唯一值得庆幸的是，早上出门时候，顺手带了...
青爵遥举，隔着楚人的风霜 汨罗的江水泛着沉痛与悲凉 包棕龙舟，邀千年前的月光 丹阳的竹子悲鸣着《九章》 宽袍博带走出了蒙昧洪荒 峨冠高束，承载着历史的风采 楚国的屈子 一腔的碧血丹心铸就了炎黄精神 当襟带长飞，从容赴江 还有谁在吟唱：“朝饮木兰之坠露兮，夕餐秋菊之落英。” ...}