线性表
线性表：一个线性表是n个具有相同特性的数据元素的有限序列。
相关概念：
- 前驱元素、后继元素
- 头结点、尾结点
线性表分类：顺序表和链表
1、顺序表
顺序表：顺序表是在计算机内存中以数组的形式保存的线性表。
- 例子：ArrayList
1.1 顺序表的实现
package com.example.algorithm.linear;
public class SequenceList<T> {
//存储元素的数组
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];
}
public void insert(T t) {
eles[N++] = 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++;
}
public T remove(int i) {
T current = eles[i];
for (int index = i; index < N - 1; index++) {
eles[index] = eles[index + 1];
}
N--;
return current;
}
public int indexOf(T t) {
for (int i = 0; i < N; i++) {
if (eles[i].equals(t)) {
return i;
}
}
return -1;
}
}
1.2 顺序表的遍历
1.让SequenceList实现Iterable接口，重写iterator方法；
2.在SequenceList内部提供一个内部类SIterator,实现Iterator接口，重写hasNext方法和next方法；
@Override
public Iterator<T> iterator() {
return new SIterator();
}
private class SIterator implements Iterator {
private int cursor;
public SIterator() {
this.cursor = 0;
}
@Override
public boolean hasNext() {
return cursor < N;
}
@Override
public Object next() {
return eles[cursor++];
}
}
1.3 顺序表容量可变
//容量可变方法
private void resize(int newSize) {
T[] temp = eles;
eles = (T[]) new Object[newSize];
for (int i = 0; i < N; i++) {
eles[i] = temp[i];
}
}
public void insert(T t) {
if (N == eles.length) {
resize(2 * eles.length);
}
eles[N++] = t;
}
public void insert(int i, T t) {
if (N == eles.length) {
resize(2 * eles.length);
}
//先把i索引及其后面的元素依次向后移动一位
for (int index = N; index > i; i--) {
eles[index] = eles[index - 1];
}
//再把t元素放到i索引处即可
eles[i] = t;
N++;
}
public T remove(int i) {
T current = eles[i];
for (int index = i; index < N - 1; index++) {
eles[index] = eles[index + 1];
}
N--;
if (N < eles.length / 4) {
resize(eles.length / 2);
}
return current;
}
1.4 顺序表的时间复杂度
- get(i):不难看出，不论数据元素量N有多大，只需要一次eles[i]就可以获取到对应的元素，所以时间复杂度为O(1);
- insert(int i,T t):每一次插入，都需要把i位置后面的元素移动一次，随着元素数量N的增大，移动的元素也越多，时间复杂为O(n);
- remove(int i):每一次删除，都需要把i位置后面的元素移动一次，随着数据量N的增大,移动的元素也越多，时间复杂度为O(n);
- 由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题越明显
1.5 ArrayLsit实现
ArrayLsit集合底层是顺序表，使用数组实现。
2、链表
虽然顺序表的查询很快，时间复杂度为O(1),但是增删的效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以使用另外一种存储结构实现线性表，链式存储结构。
链表:是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，结点可以在运行时动态生成。
Node.java
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) {
//构建结点
Node<Integer> first = new Node<>(11, null);
Node<Integer> second = new Node<>(5, null);
Node<Integer> third = new Node<>(8, null);
Node<Integer> fourth = new Node<>(2, null);
Node<Integer> fifth = new Node<>(74, null);
//生成链表
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
}
2.1 单向链表
数据域+指针域
单向链表的实现
package com.example.algorithm.linear;
public class LinkList<T> {
//记录头结点
private Node head;
//记录链表的长度
private int length;
//结点类
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.length = 0;
}
public void clear() {
this.head = null;
this.length = 0;
}
public int size() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public T get(int i) {
//通过循环，从头结点开始往后找，依次找i次，就可以找到对应的元素
Node n = head.next;
for (int index = 0; index < i; index++) {
n = n.next;
}
return n.item;
}
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
length++;
}
public void insert(T t, int i) {
//找到i位置前一个结点
Node pre = head;
for (int index = 0; index < i; index++) {
pre = pre.next;
}
//找到i位置结点
Node curr = pre.next;
//创建新结点，并且新结点需要指向原来i位置的结点
Node newNode = new Node(t, curr);
//原来i位置前一个结点指向新结点即可
pre.next = newNode;
//元素个数+1
length++;
}
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
length--;
return curr.item;
}
public int indexOf(T t) {
Node n = head;
for (int i = 0; n.next != null; i++) {
n = n.next;
if (n.item.equals(t)) {
return i;
}
}
return -1;
}
}
单向链表的遍历
@Override
public Iterator<T> iterator() {
return new Itr();
}
private class Itr implements Iterator {
private Node n;
public Itr() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
2.2 双向链表
例子：LinkedList：使用双向链表实现
一个数据域+两个指针域
双向链表的实现
package com.example.algorithm.linear;
import java.util.Iterator;
public class TwoWayLinkList<T> implements Iterable<T> {
//首结点
private Node head;
//最后一个结点
private Node last;
//链表的长度
private int length;
@Override
public Iterator iterator() {
return new Itr();
}
private class Itr implements Iterator<T> {
private Node n;
public Itr() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
//结点类
private class Node {
//存储数据
public T item;
//指向上一个结点
public Node pre;
//指向下一个结点
public Node next;
public Node(T item, Node pre, Node next) {
this.item = item;
this.pre = pre;
this.next = next;
}
}
public TwoWayLinkList() {
//初始化头结点、尾结点
this.head = new Node(null, null, null);
this.last = null;
//初始化元素个数
this.length = 0;
}
public void clear() {
this.head.next = null;
this.last = null;
this.length = 0;
}
public int size() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public T getFirst() {
return isEmpty() ? null : head.next.item;
}
public T getLast() {
return isEmpty() ? null : last.item;
}
public void insert(T t) {
if (isEmpty()) {
last = new Node(t, head, null);
head.next = last;
} else {
Node oldLast = last;
Node newNode = new Node(t, oldLast, null);
oldLast.next = newNode;
last = newNode;
}
length++;
}
public void insert(T t, int i) {
Node pre = head;
for (int index = 0; index < i; index++) {
pre = pre.next;
}
Node next = pre.next;
Node newNode = new Node(t, pre, next);
pre.next = newNode;
next.pre = newNode;
length++;
}
public T get(int i) {
Node n = head.next;
for (int index = 0; index < i; index++) {
n = n.next;
}
return n.item;
}
public int indexOf(T t) {
Node n = head;
for (int i = 0; n.next != null; i++) {
n = n.next;
if (n.next.equals(t)) {
return i;
}
}
return -1;
}
public T remove(int i) {
Node pre = head;
for (int index = 0; index < i; index++) {
pre = pre.next;
}
Node curr = pre.next;
Node nextNode = curr.next;
pre.next = nextNode;
nextNode.pre = pre;
length--;
return curr.item;
}
}
2.3 链表的应用场景
1、单链表反转
1、递归反转
递归反转法在反转当前节点之前先反转后续节点。这样从头结点开始，层层深入直到尾结点才开始反转指针域的指向。简单的说就是从尾结点开始，
public static Node reverse(Node head) {
if (head == null || head.next == null) {
return head;
}
Node pre = reverse(head.next);
head.next.next = head;
head.next = null;
return pre;
}
2、遍历反转
递归反转法是从后往前逆序反转指针域的指向，而遍历反转法是从前往后反转各个结点的指针域的指向。
基本思路是：将当前节点cur的下一个节点 cur.getNext()缓存到temp后，然后更改当前节点指针指向上一结点pre。也就是说在反转当前结点指针指向前，先把当前结点的指针域用tmp临时保存，以便下一次使用.
public static Node reverse(Node head) {
if (head == null || head.next == null) {
return head;
}
Node pre = null;
Node next = null;
while (head != null) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
2、快慢指针
快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以然我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍
2.1中间值问题
如下图，最开始，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 = fast.next.next;
slow = slow.next;
}
return slow.item;
}
2.2 单向链表是否有环问题
/**
* 判断链表中是否有环
*
* @param first 链表首结点
* @return ture为有环，false为无环
*/
public static boolean isCircle(Node<String> first) {
//定义快慢指针
Node<String> fast = first;
Node<String> slow = first;
//遍历链表，如果快慢指针指向头一个结点，那么证明有环
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if (fast.equals(slow)) {
return true;
}
}
return false;
}
2.3 有环链表入口问题
当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样为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;
break;
}
}
while (temp != null) {
temp = temp.next;
slow = slow.next;
if (temp.equals(slow)) {
break;
}
}
return temp;
}
3、循环链表
循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可。
4、约瑟夫问题
循环链表解决约瑟夫问题
问题描述：
传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，从而逃过了这场死亡游戏 。
问题转换：
41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。
1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；
2.自退出那个人开始的下一个人再次从1开始报数，以此类推；
3.求出最后退出的那个人的编号。
package study.algorithm.sort;
public class Joseph {
public static void main(String[] args) {
JosephMethod(41, 3);
}
public static void JosephMethod(int totalNum, int countNum) {
//1、构建单向循环链表
//first用来记录首结点，pre记录上一个结点
Node<Integer> pre = null;
Node<Integer> first = null;
for (int i = 1; i <= totalNum; i++) {
if (i == 1) {
first = new Node<>(i, null);
pre = first;
continue;
}
//如果不是第一个结点
Node newNode = new Node(i, null);
pre.next = newNode;
pre = newNode;
//如果是最后一个结点，那么需要让最后一个结点的下一个结点变为first，变为循环链表了
if (i == totalNum) {
pre.next = first;
}
}
//2、需要count计数器，模拟报数
int count = 0;
//3、遍历循环链表
//记录每次遍历拿到的结点，默认从首结点开始
Node<Integer> n = first;
//记录当前结点的上一个结点
Node<Integer> before = null;
while (n != n.next) {
//模拟报数
count++;
if (count == totalNum) {
before.next = n.next;
System.out.print(n.item + ",");
count = 0;
} else {
before = n;
}
n = n.next;
}
//打印最后一个元素
System.out.print(n.item);
}
private static class Node<T> {
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
}
3、栈
线性表两种特殊数据结构：
栈
- 顺序栈
- 两栈共享空间
- 链栈
队列
- 顺序队列
- 循环队列
- 链队列
栈：先进后出。只能在一端进行插入和删除操作的特殊线性表。
栈既可以通过链式数据结构实现，也可以用顺序数据结构实现
栈的实现
package com.example.algorithm.linear;
import java.util.Iterator;
public class Stack<T> implements Iterable<T> {
//记录首结点
private Node head;
//栈中元素的个数
private int N;
@Override
public Iterator<T> iterator() {
return new Itr();
}
private class Itr implements Iterator<T> {
private Node n;
public Itr() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
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;
}
public boolean isEmpty() {
return N == 0;
}
public int size() {
return N;
}
//压栈
public void push(T t) {
//找到首结点指向的第一个结点
Node oldFirst = head.next;
//创建新结点
Node newNode = new Node(t, null);
//让首结点指向新结点
head.next = newNode;
//让新结点指向原来的第一个结点
newNode.next = oldFirst;
//元素个数+1
N++;
}
//弹栈
public T pop() {
//找到首结点指向的第一个结点
Node oldFirst = head.next;
//让首结点指向原来第一个结点的下一个结点
if (oldFirst == null) {
return null;
}
head.next = oldFirst.next;
//元素个数-1
N--;
return oldFirst.item;
}
}
数组实现栈
package com.example.algorithm.linear;
import java.util.Iterator;
public class Stack2<T> implements Iterable<T> {
private T[] items;
private int N;
public Stack2(int capacity) {
this.items = (T[]) new Object[capacity];
this.N = 0;
}
public boolean isEmpty() {
return N == 0;
}
public int size() {
return N;
}
public void push(T t) {
if (N == items.length) {
resize(2 * items.length);
}
items[N++] = t;
}
public T pop() {
T pop = items[--N];
items[N] = null;
if (N < items.length / 4) {
resize(items.length / 2);
}
return pop;
}
private void resize(int capacity) {
T[] temp = items;
items = (T[]) new Object[capacity];
for (int i = 0; i < N; i++) {
items[i] = temp[i];
}
}
@Override
public Iterator<T> iterator() {
return new Itr();
}
private class Itr implements Iterator<T> {
private int cursor;
public Itr() {
this.cursor = 0;
}
@Override
public boolean hasNext() {
return cursor < N;
}
@Override
public T next() {
return items[cursor++];
}
}
}
栈的应用
1、括号匹配问题
问题描述：
给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。
例如：
"(上海)(长安)"：正确匹配
"上海((长安))"：正确匹配
"上海(长安(北京)(深圳)南京)":正确匹配
"上海(长安))"：错误匹配
"((上海)长安"：错误匹配
/**
* 判断str中的括号是否匹配
*
* @param str 括号组成的字符串
* @return 如果匹配，返回true，如果不匹配，返回false
*/
public static boolean isMatch(String str) {
String[] strings = str.split("");
Stack<String> stack = new Stack<>();
for (String string : strings) {
if ("(".equals(string)) {
stack.push(str);
} else if (")".equals(string)) {
String pop = stack.pop();
if (pop == null) {
return false;
}
}
}
return stack.size() == 0;
}
2、逆波兰表达式求值问题
中缀表达式
中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总是置于两个操作数中间。
逆波兰表达式(后缀表达式)
后缀表达式的特点：运算符总是放在跟它相关的操作数之后。
需求
给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。
package com.example.algorithm.linear;
public class ReversePolishNotation {
public static void main(String[] args) {
//中缀表达式3*（17-15）+18/6的逆波兰表达式如下
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
int result = calculate(notation);
System.out.println("逆波兰表达式的结果为：" + result);
}
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int calculate(String[] notaion) {
Stack<Integer> operators = new Stack<>();
for (String s : notaion) {
Integer o1 = 0;
Integer o2 = 0;
switch (s) {
case "+":
o1 = operators.pop();
o2 = operators.pop();
operators.push(o2 + o1);
break;
case "-":
o1 = operators.pop();
o2 = operators.pop();
operators.push(o2 - o1);
break;
case "*":
o1 = operators.pop();
o2 = operators.pop();
operators.push(o2 * o1);
break;
case "/":
o1 = operators.pop();
o2 = operators.pop();
operators.push(o2 / o1);
break;
default:
operators.push(Integer.parseInt(s));
break;
}
}
return operators.pop();
}
}
前缀、后缀、中缀表达式
例：
中缀表达式：a+b*c+(d*e+f)*g
前缀表达式：++a*bc*+*defg
后缀表达式：abc*+de*f+g*+
中缀表达式便于人们的理解与计算，但是前缀、后缀表达式更方便计算机的运算
中缀转前缀、后缀的三种方式：
1、基于堆栈的算法（比较复杂，用于计算机实现）
2、括号法
3、语义树
括号法：
-
按照运算符的优先级对所有的运算单位加括号
((a+(b*c))+(((d*e)+f)*g)) -
转换成前缀表达式与后缀表达式
- 前缀：把运算符号移动到对应的括号前面
- 后缀：把运算符号移动到对应的括号后面
语义树
- 中缀：先左，后中，再右
- 前缀：先中，后左，再右
- 后缀：先左，后右，在中
两栈共享空间
对于数组实现栈来说，如果是两个相同数据类型的栈，可以使用数组的两端作栈底的方法来让两个栈共享数据，就可以最大化的利用数组的空间。
- 两栈共享空间，通常是在两个栈的空间需求有相反关系时，也就是一个栈增长，另一个栈在缩短的情况。这样使用两栈共享空间才有意义。
package com.example.algorithm.linear;
import org.omg.CORBA.Object;
public class TwoStack<T> {
private T[] items;
private int n1;
private int n2;
public TwoStack(int capacity) {
this.items = (T[]) new Object[capacity];
this.n1 = 0;
this.n2 = capacity - 1;
}
public void push(T t, int stackNum) {
if (stackNum != 1 && stackNum != 2 || n1 == n2) {
return;
}
if (stackNum == 1) {
items[n1++] = t;
} else {
items[n2--] = t;
}
}
public T pop(int stackNum) {
if (stackNum != 1 && stackNum != 2) {
return null;
}
if (stackNum == 1) {
if (n1 == 0) {
return null;
} else {
return items[--n1];
}
} else {
if (n2 == items.length - 1) {
return null;
} else {
return items[++n2];
}
}
}
}
4、队列
队列：先进先出。是一种只能在一端进行插入，在另一端进行删除操作的特殊线性表。
即可以顺序数据结构实现，也可以链式数据结构实现
队列的实现
package com.example.algorithm.linear;
import java.util.Iterator;
public class Queue<T> implements Iterable<T> {
//记录首结点
private Node head;
//记录最后一个结点
private Node last;
//记录队列中元素的个数
private int N;
@Override
public Iterator<T> iterator() {
return new Itr();
}
private class Itr implements Iterator<T> {
private Node n;
public Itr() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
private class Node {
public T item;
public 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 N == 0;
}
public int size() {
return N;
}
//向队列中插入元素t
public void enqueue(T t) {
if (last == null) {
last = new Node(t, null);
head.next = last;
} else {
Node oldLast = last;
last = new Node(t, null);
oldLast.next = last;
}
N++;
}
//从队列中拿出一个元素
public T dequeue() {
if (isEmpty()) {
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
N--;
return oldFirst.item;
}
}
循环队列相关问题（C语言，数组实现）
- front指向队头元素，rear指向队尾元素的下一个位置（在Java中，即front=0,rear=arr.length）
- 空队列时，front=rear=0
循环队列
队列“假溢出”时，就再从头开始，头尾相接的循环。即假溢出时，rear=1
此时问题来了：空队列时，front=rear，那么满队列时，front=rear。如何判断队满还是队空？
- 方法一：设置一个变量flag。当front=rear，flag=0时队列为空；front=rear，flag=1时队列为满
- 方法二：修改队满条件，保留一个元素空间。即：队列满时，数组中还有一个空闲单元。即front+rear+1==queueSize
- (rear+1)%queueSize==front
- 队列通用计算公式：(rear-front+queueSize)%queueSize
1870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
