一、线性表
线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。
前驱元素：
若A元素在B元素的前面，则称A为B的前驱元素
后继元素：
若B元素在A元素的后面，则称B为A的后继元素
线性表的特征：数据元素之间具有一种"一对一"的逻辑关系
-
第一个 数据元素没有前驱，这个数据元素被称为头结点
-
最后一个数据元素没有后继，这个数据元素被称为尾结点
-
除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继
如果把线性表用数学语言来定义，则可以表示为(a1,...ai-1,ai,ai+1,...an)，ai-1领先于ai，ai领先于ai+1，成ai-1是ai的前驱元素，ai
+1是ai的后继元素
线性
表的分类：
线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序表和链表
1.1 顺序表
顺序表是计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素，使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系
1.1.1 顺序表的实现
顺序表API设计
| 类名 | SequenceList<T> |
|---|---|
| 构造方法 | SequenceList(int capacity)：创建容量为capacity的Sequence |
| 成员方法 | 1. public void clear()：空置线性表 2. public boolean isEmpty()：判断线性表是否为空，是返回true，否返回false() 3. public int length()：获取线性表中元素的个数 4. public T get(int i)：读取并返回线性表中的第i个元素的值 5. public void insert(int i, T t)：在线性表的第i个元素之前插入一个值为t的数据元素 6. public void insert(T t)：向线性表中添加一个元素 7. public T remove(int i)：删除并返回线性表中第i个数据元素 8. public int indexOf(T t)：返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1 |
| 成员变量 | 1. private T[] eles：存储元素的数组 2. private int N：当前线性表的长度 |
代码实现：
// 存储元素的数组
private T[] eles;
// 记录当前顺序表中的元素个数
private int N;
// 构造方法
public SequenceList (int capacity){
// 初始化数组
this.eles= (T[]) new Object[capacity];
// 初始化长度
this.N = 0;
}
// 将一个线性表置为空表
public void clear(){
this.N = 0;
}
// 判断当前线性表是否为空表
public boolean isEmpty(){
return N == 0;
}
// 获取线性表的长度
public int length(){
return N;
}
// 获取指定位置的元素
public T get(int i){
return eles[i];
}
// 向线性表中添加元素t
public void insert(T t){
eles[N++] = t;
}
// 在i元素处插入元素t
public void insert(int i,T t){
// 先把i索引处的元素及其后面的元素依次向后移动一位
for (int index = N;index > i;index--){
eles[index] = eles[index-1];
}
// 再把t元素放到i索引处即可
eles[i] = t;
N++；
}
// 删除指定位置i处的元素，并返回该元素
public T remove(int i){
// 记录索引i处的值
T current = eles[i];
// 让索引i后面元素依次向前移动一位即可
for (int index = i;index < N -1;index++){
eles[index] = eles[index+1];
}
// 元素个数-1
this.N--;
return current;
}
// 查找t元素第一次出现的位置
public int indexOf(T t) {
for (int index = 0; index < N; index++) {
if (eles[index] == t) {
return index;
}
}
return -1;
}
1.1.2 顺序表的遍历
一般作为容器存储数据，都需要相互外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。
在java中，遍历集合的方式一般都是用的foreach循环，如果想让我们的SequenceList也能支持foreach循环，则需要做如下工作：
-
让SequenceList实现iterable接口，重写iterator方法
-
在SequenceList内部提供一个内部类Slterable，实现iterator接口，重写hasNext方法和next方法
1.1.3 顺序表的容量可变
在之前的实现中，当我们使用SequenceList时，先new SequenceList创建一个对象，创建对象时就需要制定容器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量伸缩性。
考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大小？
-
添加元素时：
添加元素时，应该检查当前数组的代销是否能容纳新的元素。
-
移除元素时：
移除元素时，应该检查当前数组的大小是否太大，造成内存的浪费。
代码实现：
// 根据参数newSize重置eles的大小 public void resize(int newSize){ // 定义一个临时数组，指向原数组 T[] temp = eles; // 创建新数组 eles = (T[]) new Object[newSize]; // 把原数组的数据拷贝到新数组即可 for (int i=0;i<N;i++){ eles[i] = temp[i]; } } // 扩容 if (N == eles.length){ resize(eles.length*2); } // 缩容 if (N < eles.length/4){ resize(eles.length/2) }
1.1.4 java中ArrayList实现
java中ArrayList集合的底层也是一种顺序表，使用数组实现，同样提供了增删改查以及扩容等功能
1.2 链表
链表是一种物理存储单元上非连续，非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的节点(链表中的每一个元素称为节点)组成，结点可以在运行时动态产生。
节点API设计：
| 类名 | Node<T> |
|---|---|
| 构造方法 | Node(T t,Node next)：创建Node对象 |
| 成员变量 | T item：存储数据 Node next：指向下一结点 |
节点类实现：
public class Node<T> {
// 存储元素
public T item;
// 指向下一结点
public Node next;
public Node(T item,Node next) {
this.item = item;
this.next = next;
}
}生成链表：
public static void main(String[] args) throws Exception {
// 构建结点
Node<Integer> first = new Node<Integer>(11,null);
Node<Integer> second = new Node<Integer>(12,null);
Node<Integer> third = new Node<Integer>(13,null);
Node<Integer> fourth = new Node<Integer>(14,null);
Node<Integer> fifth = new Node<Integer>(15,null);
// 生成链表
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
}1.2.1 单向链表
单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。
1.2.1.1 单向链表API设计
| 类名 | LinkList<T> |
|---|---|
| 构造方法 | LinkList()：创建LinkList对象 |
| 成员方法 | 1. public void clear()：空置链表 2. public boolean isEmpty()：判断链表是否为空，是返回true，否返回false() 3. public int length()：获取链表中元素的个数 4. public T get(int i)：读取并返回链表中的第i个元素的值 5. public void insert(int i, T t)：在链表的第i个元素之前插入一个值为t的数据元素 6. public void insert(T t)：向链表中添加一个元素 7. public T remove(int i)：删除并返回链表中第i个数据元素 8. public int indexOf(T t)：返回链表中首次出现的指定的数据元素的位序号，若不存在，则返回-1 |
| 成员内部类 | private class Node<T>：结点类 |
| 成员变量 | 1. private Node head：记录首节点 2. private int N：记录链表的长度 |
1.2.1.2 单向链表代码实现
public class LinkList<T>{
// 记录头结点
private Node head;
// 记录链表的长度
private int N;
// 节点类
private class Node{
// 存储数据
T item;
// 下一个节点
Node next;
public Node(T item,Node next){
this.item = item;
this.next = next;
}
}
public LinkList() {
// 初始化头结点
this.head = new Node(null,null);
// 初始化元素个数
this.N = 0;
}
// 清空链表
public void clear() {
head.next = null;
this.N = 0;
}
// 获取链表的长度
public int length() {
return this.N;
}
// 判断链表是否为空
public boolean isEmpty() {
return this.N == 0;
}
// 获取指定位置i处的元素
public T get(int i) {
// 通过循环从头节点开始往后找，依次找i次，就可以找到对应的元素
Node n = head.next;
for (int index = 0;index < i; index++){
n = n.next;
}
return n.item;
}
// 向链表中添加元素t
public void insert(T t) {
// 找到当前最后一个节点
Node n = head;
while(n.next!=null){
n = n.next;
}
// 创建新节点，保存元素t
Node newNode = new Node(t, null);
// 让当前最后一个节点指向新节点
n.next = newNode;
// 元素的个数+1
this.N++;
}
// 向指定位置i处，添加元素t
public void insert(int i,T t){
// 找到i位置前一个节点
Node pre = head;
for (int index = 0;index <= i-1;index++){
pre = pre.next;
}
// 找到i位置的节点
Node curr = pre.next;
// 创建新节点，并且新节点需要指向原来i位置的节点
Node newNode = new Node(t, curr);
// 原来i位置的前一个节点指向新节点即可
pre.next = newNode;
// 元素个数+1
this.N++;
}
// 删除指定位置i处的元素，并返回被删除的元素
public T remove(int i) {
// 找到i位置的前一个节点
Node pre = head;
for (int index = 0;index < i;index++){
pre = pre.next;
}
// 要找到i位置的节点
Node curr = pre.next;
// 找到i位置的下一个节点
Node nextNode = curr.next;
// 前一个节点指向下一个节点
pre.next = nextNode;
// 元素个数-1
N--;
return curr.item;
}
// 查找元素t在链表中第一次出现的位置
public int indexOf(T t) {
// 从头结点开始，一次找到每一个结点，取出item和t比较，如果相同，就找到了
Node n = head;
for (int i=0;n.next!=null;i++){
n=n.next;
if (n.item.equals(t)){
return i;
}
}
return -1;
}
}1.2.2 双向链表
双向链表也叫双向表，是链表的一种，它由多个节点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向其前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。
按照面向对象的思想，我们需要设计一个类，来描述结点这个事物。由于结点是属于链表的，所以我们把结点类作为链表类的一个内部类来实现
1.2.2.1 结点API设计
| 类名 | Node<T> |
|---|---|
| 构造方法 | Node(T t,Node pre,Node next)：创建Node对象 |
| 成员变量 | T item：存储数据 Node next：指向下一个结点 Node pre：指向上一个结点 |
1.2.2.2 双向链表API设计
| 类名 | TwoWayLinkList<T> |
|---|---|
| 构造方法 | TowWayLinkList()：创建TowWayLinkList对象 |
| 成员方法 | 1.public void clear()：空置线性表 2.publicboolean isEmpty()：判断线性表是否为空，是返回true，否返回false 3.public int length():获取线性表中元素的个数 4.public T get(int i):读取并返回线性表中的第i个元素的值 5.public void insert(T t)：往线性表中添加一个元素； 6.public void insert(int i,T t)：在线性表的第i个元素之前插入一个值为t的数据元素。 7.public T remove(int i):删除并返回线性表中第i个数据元素。 8.public int indexOf(T t):返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。 9.public T getFirst():获取第一个元素 10.public T getLast():获取最后一个元素 |
| 成员内部类 | private class Node:结点类 |
| 成员变量 | 1.private Node first:记录首结点 2.private Node last:记录尾结点 3.private int N:记录链表的长度 |
1.2.2.3 双向链表代码实现
public class TwoWayLinkList<T> implements Iterable<T> {
// 首结点
private Node head;
// 最后一个结点
private Node last;
// 链表的长度
private int N;
// 结点类
private class Node{
public Node (T item,Node pre,Node next){
this.item = item;
this.pre = pre;
this.next = next;
}
// 存储数据
public T item;
// 指向上一结点
public Node pre;
// 指向下一结点
public Node next;
}
public TwoWayLinkList() {
// 初始化头结点和尾结点
this.head = new Node(null,null,null);
this.last = null;
// 初始化元素个数
this.N = 0;
}
// 清空链表
public void clear() {
this.head.next = null;
this.head.pre = null;
this.head.item = null;
this.last = null;
this.N = 0;
}
// 获取链表长度
public int length() {
return N;
}
// 判断链表是否为空
public boolean isEmpty() {
return this.N == 0;
}
// 获取第一个元素
public T getFirst() {
if (isEmpty()) {
return null;
}
return head.next.item;
}
// 获取最后一个元素
public T getLast() {
if (isEmpty()) {
return null;
}
return last.item;
}
// 插入元素t
public void insert(T t) {
if (isEmpty()){
// 如果链表为空
// 创建新的结点
Node newNode = new Node(t, head, null);
// 让新节点成为尾结点
last = newNode;
// 让头结点指向尾结点
head.next = last;
}else {
// 如果链表不为空
Node oldLast = last;
// 创建新的结点
Node newNode = new Node(t, oldLast, null);
// 让当前尾结点指向新结点
oldLast.next = newNode;
// 让新节点称为尾结点
last = newNode;
}
// 元素个数+1
N++;
}
// 在指定位置i处插入元素
public void insert(int i,T t) {
// 找到i位置的前一个结点
Node pre = head;
for (int index = 0;index <= i-1;index++){
pre = pre.next;
}
// 找到i位置的结点
Node curr = pre.next;
// 创建新结点
Node newNode = new Node(t, pre, curr);
// 让i位置的前一个结点的下一个结点变为新结点
pre.next = newNode;
// 让i位置的前一个结点变为新结点
curr.next = newNode;
// 元素个数+1
N++;
}
// 获取指定位置i处的元素
public T get(int i) {
Node node = head.next;
for (int index=0;index<i;index++){
node = node.next;
}
return node.item;
}
// 找到元素t在链表中第一次出现的位置
public int indexOf(T t) {
Node node = head;
for (int i = 0;node.next != null;i++) {
node = node.next;
if (node.item.equals(t)) {
return i;
}
}
return -1;
}
// 删除位置i处的元素，并返回该元素
public T remove(int i) {
// 找到i位置的前一个结点
Node pre = head;
for (int index = 0;index < i;index++){
pre = pre.next;
}
// 找到i位置的结点
Node curr = pre.next;
// 找到i位置的下一个结点
Node nextNode = curr.next;
// 让i位置的前一个结点的下一个结点变为i位置的下一个结点
pre.next = nextNode;
// 让i位置的下一个结点的上一个结点变为i位置的前一个结点
nextNode.pre = pre;
// 元素个数减1
N--;
return curr.item;
}
@Override
public Iterator<T> iterator() {
return new TIterator();
}
private class TIterator implements Iterator {
private Node n;
public TIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
}1.2.3 链表反转
单链表的反转，是面试中的一个高频题目
需求：
原链表中的数据为：1->2->3->4
反转后链表中数据为：4->3->2->1
反转API
public void reverse()：对整个链表反转public Node reverse(Node curr)：反转链表中的某个结点curr,并把反转后的curr结点返回使用递归可以完成反转，递归反转其实就是从原链表的第一个存数据的的结点开始，依次递归调用反转每一个结点，直到把最后一个结点反转完毕，整个链表就反转完毕
代码
// 反转整个链表
public void reverse() {
// 判断当前链表是否为空链表，如果是空链表则结束运行，如果不是，则调用重载的reverse方法完成反转
if (isEmpty()) {
return;
}
reverse(head.next);
}
// 反转指定的结点curr，并把反转后的结点返回
public Node reverse(Node curr) {
if (curr.next == null) {
head.next = curr;
return curr;
}
// 递归的反转当前结点curr的下一结点；返回值就是链表反转后当前结点的上一个结点
Node pre = reverse(curr.next);
// 让返回的结点的下一个结点变为当前结点curr
pre.next = curr;
// 把当前结点的下一个结点变为null
curr.next = null;
return curr;
}1.2.4快慢指针
快慢指针指的是定义两个指针，这两个指针的移动速度一快一慢，以此来制造出自己想要的差值，这个差值可以让我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍
1.2.4.1 中间值问题
代码：
// 快慢指针
public class FastSlowTest {
public static void main(String[] args) throws Exception{
// 创建结点
Node<String> first = new Node<String>("aa",null);
Node<String> second = new Node<String>("bb",null);
Node<String> third = new Node<String>("cc",null);
Node<String> fourth = new Node<String>("dd",null);
Node<String> fifth = new Node<String>("ee",null);
Node<String> sixth = new Node<String>("ff",null);
Node<String> seventh = new Node<String>("gg",null);
// 完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = sixth;
sixth.next = seventh;
// 查找中间值
String mid = getMid(first);
System.out.println("中间值为："+mid);
}
/**
* @param first 链表的首结点
* @return 链表的中间结点的值
*/
public static String getMid(Node<String> first) {
// 定义两个指针
Node<String> fast = first;
Node<String> slow = first;
// 使用两个指针遍历链表，当快指针指向的结点没有下一个结时，就可以结束了，结束之后，慢指针指向的结点就是中间值
while (fast != null && fast.next != null){
// 变换fast和slow的值
fast = fast.next.next;
slow = slow.next;
}
return slow.item;
}
// 结点类
private static class Node<T> {
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item,Node next) {
this.item = item;
this.next = next;
}
}
}利用快慢指针，我们把一个链表看成一个跑道，假设a的速度是b的两倍，那么当a跑完全程后，b刚好跑一半，依次来达到找到中间结点的目的
如下图：最开始，slow和fast指针都指向链表的第一个结点，然后slow每次移动一个指针，fast每次移动两个指针
代码：
/**
* @param first 链表的首结点
* @return 链表的中间结点的值
*/
public static String getMid(Node<String> first) {
// 定义两个指针
Node<String> fast = first;
Node<String> slow = first;
// 使用两个指针遍历链表，当快指针指向的结点没有下一个结时，就可以结束了，结束之后，慢指针指向的结点就是中间值
while (fast != null && fast.next != null){
// 变换fast和slow的值
fast = fast.next.next;
slow = slow.next;
}
return slow.item;
}1.2.4.2 单向链表是否有环问题
代码：
// 快慢指针
public class CircleListCheckTest {
public static void main(String[] args) throws Exception{
// 创建结点
Node<String> first = new Node<String>("aa",null);
Node<String> second = new Node<String>("bb",null);
Node<String> third = new Node<String>("cc",null);
Node<String> fourth = new Node<String>("dd",null);
Node<String> fifth = new Node<String>("ee",null);
Node<String> sixth = new Node<String>("ff",null);
Node<String> seventh = new Node<String>("gg",null);
// 完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = sixth;
sixth.next = seventh;
// 产生环
seventh.next = third;
// 判断链表是否有环
boolean circle = isCircle(first);
System.out.println("first链表中是否有环："+circle);
}
/**
* @param first 链表首结点
* @return true代表有环，false代表无环
*/
public static boolean isCircle(Node<String> first) {
// 定义快慢指针
Node<String> fast = first;
Node<String> slow = first;
// 遍历链表，如果快慢指针指向了同一个结点，那么证明有环
while (fast != null && fast.next != null) {
// 变换fast和slow
fast = fast.next.next;
slow = slow.next;
if (fast.equals(slow)) {
return true;
}
}
return false;
}
// 结点类
private static class Node<T> {
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item,Node next) {
this.item = item;
this.next = next;
}
}
}分析：
使用快慢指针的思想，还是把链表比作一条跑道，链表中有环，那么这条跑道就是一条圆环跑道，在一条圆环跑道中，两个人有速度差，那么迟早两个人会相遇，只要相遇那么就说明有环。
代码：
/**
* @param first 链表首结点
* @return true代表有环，false代表无环
*/
public static boolean isCircle(Node<String> first) {
// 定义快慢指针
Node<String> fast = first;
Node<String> slow = first;
// 遍历链表，如果快慢指针指向了同一个结点，那么证明有环
while (fast != null && fast.next != null) {
// 变换fast和slow
fast = fast.next.next;
slow = slow.next;
if (fast.equals(slow)) {
return true;
}
}
return false;
}1.2.4.3 有环链表入口问题
代码：
// 快慢指针
public class CircleListInTest {
public static void main(String[] args) throws Exception{
// 创建结点
Node<String> first = new Node<String>("aa",null);
Node<String> second = new Node<String>("bb",null);
Node<String> third = new Node<String>("cc",null);
Node<String> fourth = new Node<String>("dd",null);
Node<String> fifth = new Node<String>("ee",null);
Node<String> sixth = new Node<String>("ff",null);
Node<String> seventh = new Node<String>("gg",null);
// 完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = sixth;
sixth.next = seventh;
// 产生环
seventh.next = third;
// 查找环的入口结点
Node<String> entrance = getEntrance(first);
System.out.println("环的入口元素是："+entrance.item);
}
/**
* 查找有环链表的入口结点
* @param first 链表首结点
* @return 环的入口结点
*/
public static Node getEntrance(Node<String> first) {
// 定义快慢指针
Node<String> fast = first;
Node<String> slow = first;
Node<String> temp = null;
// 遍历链表，先找到环(快慢指针相遇)，准备一个临时指针，指向链表的首结点，继续遍历，直到慢指针和临时指针相遇，相遇时所指向的结点就是环的入口
while (fast != null && fast.next != null) {
// 变换快慢指针
fast = fast.next.next;
slow = slow.next;
if (fast.equals(slow)) {
temp = first;
continue;
}
// 让临时结点变换
if (temp != null) {
temp = temp.next;
// 判断临时指针是否和慢指针是否相遇
if (temp.equals(slow)) {
break;
}
}
}
return temp;
}
// 结点类
private static class Node<T> {
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item,Node next) {
this.item = item;
this.next = next;
}
}
}分析：
当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样为1，则慢指针与“新”指针相遇的地方就是环的入口。证明这一结论需要涉及到数论的知识，这里略，只讲实现。
代码：
/**
* 查找有环链表的入口结点
* @param first 链表首结点
* @return 环的入口结点
*/
public static Node getEntrance(Node<String> first) {
// 定义快慢指针
Node<String> fast = first;
Node<String> slow = first;
Node<String> temp = null;
// 遍历链表，先找到环(快慢指针相遇)，准备一个临时指针，指向链表的首结点，继续遍历，直到慢指针和临时指针相遇，相遇时所指向的结点就是环的入口
while (fast != null && fast.next != null) {
// 变换快慢指针
fast = fast.next.next;
slow = slow.next;
if (fast.equals(slow)) {
temp = first;
continue;
}
// 让临时结点变换
if (temp != null) {
temp = temp.next;
// 判断临时指针是否和慢指针是否相遇
if (temp.equals(slow)) {
break;
}
}
}
return temp;
}1.2.5 循环链表
循环链表，顾名思义，链表整体要形成一个圆环状，在单向链表中，最后一个结点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个结点的指针指向头结点即可。
循环链表的构建：
public class Test {
public static void main(String[] args) {
// 构建节点
Node<Integer> first = new Node<Integer>(1,null);
Node<Integer> second = new Node<Integer>(2,null);
Node<Integer> third = new Node<Integer>(3,null);
Node<Integer> fourth = new Node<Integer>(4null);
Node<Integer> fifth = new Node<Integer>(5null;
Node<Integer> sixth = new Node<Integer>(6null);
Node<Integer> seventh = new Node<Integer>(7null);
// 构建单链表
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = sixth;
sixth.next = seventh;
// 构建循环链表，让最后一个结点指向第一个结点
seventh.next = firth;
}1.2.5 约瑟夫问题
问题描述：
传说有这样一个故事，在罗马人占领乔塔帕特后，39个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，从而逃过了这场死亡游戏。
问题转换：
41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。
1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；
2.自退出那个人开始的下一个人再次从1开始报数，以此类推；
3.求出最后退出的那个人的编号。
解题思路：
-
构建含有41个结点的单向循环链表，分别存储1-41的值，分别代表着41个人
-
使用计数器count，记录当前报数的值
-
遍历链表，没训话那一次，count++
-
判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0
代码：
public class JosephTest {
public static void main(String[] args) {
// 解决约瑟夫问题
// 1. 构建循环链表,包含41个结点，分别存储1-41之间的值
// first用来记录首结点
Node<Integer> first = null;
// 用来记录前一个结点
Node<Integer> pre = null;
for (int i=1;i<=41;i++) {
// 如果是第一个结点
if (i==1) {
first = new Node<>(i,null);
pre = first;
continue;
}
// 如果不是第一个结点
Node<Integer> newNode = new Node<>(i, null);
pre.next = newNode;
pre = newNode;
// 如果是最后一个结点，需要让最后一个结点的下一个结点变为first,变为循环链表了
if (i==41) {
pre.next = first;
}
}
// 2. 需要count计数器，模拟报数
int count = 0;
// 3. 遍历循环链表
// 记录每次遍历拿到的结点，默认从首结点开始
Node<Integer> n = first;
// 记录当前结点的上一个结点
Node<Integer> before = null;
while (n != n.next){
// 模拟报数
count++;
// 判断当前报数是否为3
if (count == 3) {
// 如果是3，把当前结点删除掉，打印当前结点，重置count=0，让当前结点n后移
before.next = n.next;
System.out.print(n.item+" ");
count = 0;
n = n.next;
}else {
// 如果不是3，让before变为当前结点，让当前结点后移
before = n;
n = n.next;
}
}
System.out.println();
// 打印最后一个元素
System.out.println(n.item);
}
// 结点类
private static class Node<T> {
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item,Node next) {
this.item = item;
this.next = next;
}
}
}1.3 栈
1.3.1 栈概述
1.3.1.1 生活中的栈
存储货物或供旅客住宿的地方，可引申为仓库、中转站。例如我们现在在生活中的酒店，在古时候叫客栈，是供旅客休息的地方，旅客可以进客栈休息，休息完毕后就离开客栈。
1.3.1.2 计算机中的栈
我们把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，又可以从栈中出去。
栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)
我们称数据进入到栈的动作压栈，数据从栈中出去的动作为弹栈
1.3.2 栈的实现
1.3.2.1 栈的API设计
| 类名 | Stack<T> |
|---|---|
| 构造方法 | Stack()：创建Stack对象 |
| 成员方法 | 1.public boolean isEmpty()：判断栈是否为空，是返回true，否返回false 2.public int size():获取栈中元素的个数 3.public T pop():弹出栈顶元素 4.public void push(T t)：向栈中压入元素t |
| 成员变量 | 1.private Node head:记录首结点 2.private int N:当前栈的元素个数 |
| 成员内部类 | private class Node：结点类 |
1.3.2.2 栈代码实现
public class Stack<T> implements Iterable<T>{
// 记录首结点
private Node head;
// 栈中元素的个数
private int N;
private class Node {
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
public Stack() {
this.head = new Node(null,null);
this.N = 0;
}
// 判断当前栈中元素是否为0
public boolean isEmpty() {
return this.N == 0;
}
// 获取栈中元素个数
public int size() {
return N;
}
// 把t元素压入栈
public void push(T t) {
// 找到首结点指向的第一个结点
Node oldFirst = head.next;
// 创建新结点，让首结点指向新结点,让新结点指向原来的第一个结点
Node newNode = new Node(t, oldFirst);
head.next = newNode;
// 元素个数+1
N++;
}
// 弹出栈元素
public T pop() {
// 找到首结点指向的第一个结点
Node oldFirst = head.next;
if (oldFirst==null) {
return null;
}
// 让首节点指向原来第一个结点指向的第一个结点
head.next = oldFirst.next;
// 元素个数-1
N--;
return oldFirst.item;
}
// 迭代器，方便打印
@Override
public Iterator<T> iterator() {
return new SIterator();
}
private class SIterator implements Iterator{
private Node n;
public SIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}1.3.3 案例
1.3.3.1 括号匹配问题
问题描述：
给定一个字符串，里面可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现 例如： "(上海)(长安)"：正确匹配 "上海((长安))"：正确匹配 "上海(长安)(北京)(深圳)(南京)"：正确匹配 "上海(长安))"：错误匹配 "((上海)长安"：错误匹配
分析：
1. 创建一个栈用来存储左括号 2. 从左往右遍历字符串，拿到每一个字符 3. 判断该字符是不是左括号，如果是，存入栈中 4. 判断该字符串是不是右括号，如果不是，继续下一次循环 5. 如果该字符是右括号，则从栈中弹出一个元素t 6. 判断元素t是否是null，如果不是，则证明有对相应的左括号，如果不是，则证明没有对应的左括号 7. 循环结束后，判断栈中有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
代码：
public class BracketMatchTest {
public static void main(String[] args) {
String str = "(上海(长安)()";
boolean match = isMatch(str);
System.out.println(str+"中的括号是否匹配："+match);
}
/**
* 判断str中的括号是否匹配
* @param str 括号组成的字符串
* @return 如果匹配，则返回true，如果不匹配，返回false
*/
private static boolean isMatch(String str) {
// 1. 创建栈对象，用来存储左括号
Stack<String> chars = new Stack<>();
// 2. 从左往右遍历字符串
for (int i = 0; i < str.length(); i++) {
String currChar = str.charAt(i)+ "";
// 3. 判断当前字符是否为左括号，如果是，则存入栈中
if (currChar.equals("(")) {
chars.push(currChar);
} else if (currChar.equals(")")) {
// 4. 继续判断当前字符是否是右括号，如果是，则从栈中弹出一个左括号，并判断弹出的结果是否为null，如果为null，则证明没有匹配的左括号
// 如果不为null，则证明有匹配的左括号
String pop = chars.pop();
if (pop == null) {
return false;
}
}
}
// 判断栈中还有没有剩余的左括号，如果有，则证明括号不匹配
return chars.size() == 0;
}
}1.3.3.2 逆波兰表达式求值问题
逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起
中缀表达式：
中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间
中缀表达式是人们最喜欢的表达式，但是对于计算机而言，中缀表达式的运算顺序不具有规律性。不同的运算符具有不同的优先级。如果计算机执行中缀表达式，需要解析表达式语义，做大量的优先级相关操作。
逆波兰表达式(后缀表达式)：
逆波兰表达式是波兰逻辑学家与1929年首先提出的一种表达式的表示方法，后缀表达式的特点：运算符总是放在跟他相关的操作数之后
| 中缀表达式 | 逆波兰表达式 |
|---|---|
| a+b | ab+ |
| a+(b-c) | abc-+ |
| a+(b-c)*d | abc-d*+ |
| a*(b-c)+d | abc-*d+ |
1.4 队列
队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入，在另一端进行删除操作的特殊线性表，它按照先进先出的原则存储数据，先进入的数据，在读取数据时先被读出来
1.4.1 队列的API设计
| 类名 | Queue<T> |
|---|---|
| 构造方法 | Queue()：创建Queue对象 |
| 成员方法 | 1. public boolean isEmpty()：判断队列是否为空，是返回true，否返回false 2. public int size()：获取队列中元素的个数 3. public T dequeue()：从队列中拿出一个元素 4. public void enqueue(T t)：往队列中插入一个元素 |
| 成员变量 | 1. private Node head：记录首节点 2. private int N：当前栈的元素个数 3. private Node last：记录最后一个结点 |
| 成员内部类 | private class Node：结点类 |
1.4.2 队列的实现
public class Queue<T> {
// 记录首节点
private Node head;
// 记录最后一个结点
private Node last;
// 记录队列中元素个数
private int N;
// 结点类
private class Node {
T item;
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
public Queue() {
this.head = new Node(null,null);
this.last = null;
this.N = 0;
}
// 判断队列是否为空
public boolean isEmpty() {
return this.N == 0;
}
// 返回队列中元素的个数
public int size() {
return this.N;
}
// 向队列中插入元素t
public void enqueue(T t) {
if (last == null) {
// 当前尾结点为null
last = new Node(t,null);
head.next = last;
}else {
// 当前尾结点不为null
Node oldLast = last;
last = new Node(t, null);
oldLast.next = last;
}
// 元素个数+1
N++;
}
// 从队列中拿出一个元素
public T dequeue() {
if (isEmpty()) {
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
N--;
// 因为出队列其实是在删除元素，因此如果队列中的元素被删除完了，需要重置last=null
if (isEmpty()) {
last = null;
}
return oldFirst.item;
}
}
扫一扫
1791
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
