数据结构 --- Java数据结构与算法总览

一、数据结构概念

数据结构包含数据和结构，通俗一点就是将数据按照一定的结构组合起来，不同的组合方式会有不同的效率，使用不同的场景，如此而已。比如我们最常用的数组，就是一种数据结构，有独特的承载数据的方式，按顺序排列，其特点就是你可以根据下标快速查找元素，但是因为在数组中插入和删除元素会有其它元素较大幅度的便宜，所以会带来较多的消耗，所以因为这种特点，使得数组适合：查询比较频繁，增、删比较少的情况，这就是数据结构的概念。

数据结构包括两大类：线性结构和非线性结构，线性结构包括：线性表(数组、链表)、队列、栈等，非线性结构包括树、图、表等及衍生类结构。

总体看下图：

二、基础数据结构

数据结构是一种抽象的数据类型（ADT），可以这么说，我们可以采用任意的方式实现某种数据结构，只要符合将要实现的数据结构的特点。

数据结构就是一种标准，我们可以采用不同的方式去实现，最常用的两种就是数组和链表（包括单链表、双向链表等），其它几个就不介绍了。

Array是Java中随机访问一连串对象最有效率的数据结构，但很不灵活，大小固定，且不知道里面有多少元素。

为此JDK已经为我们提供了一系列相应的类来实现功能强大且更灵活的基本数据结构。这些类均在java.util包中。其继承结构如下： 

Collection 
├List 
│├LinkedList 
│├ArrayList 
│└Vector 
│　└Stack 
└Set 
│ └SortedSet 
└Queue

-Map 
├HashTable 
├HashMap 
└WeakHashMap

1、数组

数组是非常常见的数据类型，在任何一种语言里都有它的实现，我们这里采用Java来简单实现一下数组。

数组是一种引用类型的对象，我们可以像下面这样的方式来声明数组：

[java] view plain copy

1. int a[];  
2. int[] b;  
3. int []c;  

[java] view plain copy

1. a = new int[10];  

总结起来，声明一个数组有基本的三个因素：类型、名称、下标，Java里，数组在格式上相对灵活，下标和名称可以互换位置，前三种情况我们可以理解为声明一个变量，后一种为其赋值。或者像下面这样，在声明的时候赋值：

[java] view plain copy

1. int c[] = {2,3,6,10,99};  
2. int []d = new int[10];  

我稍微解释一下，其实如果只执行：int[] b,只是在栈上创建一个引用变量，并未赋值，只有当执行d = new int[10]才会在堆上真正的分配空间。上述第一行为静态初始化，就是说用户指定数组的内容，有系统计算数组的大小，第二行恰恰相反，用户指定数组的大小，由系统分配初始值，我们打印一下数组的初始值：

[java] view plain copy

1. int []d = new int[10];  
2. System.out.println(d[2]);  

结果输出0，对于int类型的数组，默认的初始值为0.

但是，绝对不可以像下面这样：

[java] view plain copy

1. int e[10] = new int[10];  

无法通过编译，至于为什么，语法就是这样，这是一种规范，不用去想它。
我们可以通过下标来检索数组。下面我举个简单的例子，来说明下数组的用法。

[java] view plain copy

1. public static void main(String[] args) {  
2.   
3.     String name[];  
4.   
5.     name = new String[5];  
6.     name[0] = "egg";  
7.     name[1] = "erqing";  
8.     name[2] = "baby";  
9.   
10.     for (int i = 0; i < name.length; i++) {  
11.         System.out.println(name[i]);  
12.     }  
13. }  

这是最简单的数组声明、创建、赋值、遍历的例子，下面写个增删的例子。

[java] view plain copy

1. package com.xtfggef.algo.array;  
2.   
3. public class Array {  
4.   
5.     public static void main(String[] args) {  
6.   
7.         int value[] = new int[10];  
8.         for (int i = 0; i < 10; i++) {  
9.             value[i] = i;  
10.         }  
11.   
12.         // traverse(value);  
13.         // insert(value, 666, 5);  
14.         delete(value, 3);  
15.         traverse(value);  
16.     }  
17.   
18.     public static int[] insert(int[] old, int value, int index) {  
19.         for (int k = old.length - 1; k > index; k--)  
20.             old[k] = old[k - 1];  
21.         old[index] = value;  
22.         return old;  
23.     }  
24.   
25.     public static void traverse(int data[]) {  
26.         for (int j = 0; j < data.length; j++)  
27.             System.out.print(data[j] + " ");  
28.     }  
29.   
30.     public static int[] delete(int[] old, int index) {  
31.         for (int h = index; h < old.length - 1; h++) {  
32.             old[h] = old[h + 1];  
33.         }  
34.         old[old.length - 1] = 0;  
35.         return old;  
36.     }  
37. }  

简单写一下，主要想说明数组中删除和增加元素的原理：增加元素，需要将index后面的依次向后移动，然后将值插入index位置，删除则将后面的值依次向前移动，较简单。

要记住：数组是表示相同类型的一类数据的集合，下标从0开始，就行了。

数组实现的线下表可以参考ArrayList，在JDK中附有源码，感兴趣的同学可以读读。

2、链表

单链表是最简单的链表，有节点之间首尾连接而成，简单示意如下：

除了头节点，每个节点包含一个数据域一个指针域，除了头、尾节点，每个节点的指针指向下一个节点，

三、线性结构

常用的线性结构有：线性表，栈，队列，数组。线性表中包括顺序表、链表等，其中，栈和队列是特殊的线性表，只是属于逻辑上的概念，实际中不存在，仅仅是一种思想，一种理念；线性表则是在内存中数据的一种组织、存储的方式。

1、线性表

线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。其基本操作主要有：

   1）MakeEmpty(L) 这是一个将L变为空表的方法
   2）Length（L） 返回表L的长度，即表中元素个数 
   3）Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）
   4）Prev（L，i） 取i的前驱元素
   5）Next（L，i） 取i的后继元素
   6）Locate（L，x） 这是一个函数，函数值为元素x在L中的位置
   7）Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置
   8）Delete（L，p） 从表L中删除位置p处的元素
   9）IsEmpty(L) 如果表L为空表(长度为0)则返回true，否则返回false
   10）Clear（L）清除所有元素
   11）Init（L）同第一个，初始化线性表为空
   12）Traverse（L）遍历输出所有元素
   13）Find（L，x）查找并返回元素
   14）Update（L，x）修改元素
   15）Sort（L）对所有元素重新按给定的条件排序
   16) strstr(string1,string2)用于字符数组的求string1中出现string2的首地址

不管采用哪种方式实现线性表，至少都应该具有上述这些基本方法，下面我会将下数据结构的基本实现方式。

       概念：

             数据元素的排列方式是线性的。

      分类：

             分类规则是根据上图中元素的存储结构来划分的。

                                                                                   

     （1）顺序表

          基本思想：元素的存储空间是连续的。在内存中是以顺序存储，内存划分的区域是连续的。存储结构如下图：

                           

          

      （2）链表

          基本思想：元素的存储空间是离散的，单独的（物理），它们可以通过在逻辑上指针的联系使得它成为了整体的链表。存储结构如下图：

                                

 

     

            1.单链表

                   

 

            2.循环链表

                        ·

3.双链表（双向循环表）

                   

                 （图有点小问题 ：最后一个节点的 指针域 也指向头结点）

           

 

           三者的区别（从上面三个图我们可以总结出来）：

       1、它们都有数据域（data(p)）和指针域(next(p))，但是从图中可以看出双链表有两个指针域，一个指向它的前节点，一个指向它的后节点。

       2、单链表最后一个节点的指针域为空，没有后继节点；循环链表和双链表最后一个节点的指针域指向头节点，下一个结点为头节点，构成循环；

          3、单链表和循环链表只可向一个方向遍历；双链表和循环链表，首节点和尾节点被连接在一起，可视为“无头无尾”；双链表可以向两个方向移动，灵活度更大。

 

    线性表操作：

         理解了顺序表和链表的基本思想之后，线性表的操作是简单，并且网上有很多讲解插入和删除结点的博客，在这里我就不过多的介绍了。

 

        顺序表和链表的对比：

                          

2、栈

      基本思想：后进先出（先进后出）即栈中元素被处理时，按后进先出的顺序进行，栈又叫后进先出表（LIFO）。

      举例：

      日常生活中有很多栈的例子。例如，放在书桌上的一摞书，只能从书顶上拿走一本书，书也只能放在顶上。如下图所示：

                                                 

 

3、队列

     基本思想：先进先出即先被接收的元素将先被处理，又叫先进先出表（FIFO）。如下图所示：

     举例：

     队列的例子，生活中更多。比如：买车票排队，排头最先买到车票，新来的排的队尾；进车站时，安检行李，先进去的最先出来，后进去的后出来。

                                                  

   

分类：

1.顺序队列

          如下图所示：

                          

      顺序队列的操作，要判断队满和队空的标志，从图中我们可以总结得到：

      1.队空：head = tail

      2.队满：tail = m

2.循环队列

        如下图所示：

                                  

      循环队列的操作，要判断队空和队满的情况，从图中我们可以总结得到：

         1.队空：head = tail

       2.队满：tail + 1 = head(在队列中会留一个空着的空间，所以要加1)

四、非线性结构

暂时略