数据结构之线性表 顺序表 链表

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结

构，常见的线性表：顺序表、链表、栈、队列、字符串...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物

理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组

上完成数据的增删查改。

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储。

2. 动态顺序表：使用动态开辟的数组存储。

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多

了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下

面我们实现动态顺序表。

学习顺序表接口时，不能只看代码地实现，最主要的是接口增，删，查，改时所对应的逻辑结构图，一定要将所对应的图以及步骤理解清楚，代码中size的代表，为什么要扩容，这都是很重要的问题。

下面来看代码：

// 顺序表的元素类型 int
public class MyArrayList {
	// 属性是什么
	private int[] array;		// 代表的是存在数据的数组
								// array.length 代表的是数组的容量
	private int size;			// 记录顺序表的已有数据个数
	
	// 构造方法
	public MyArrayList() {
		// 1. 申请空间
		array = new int[2];
		// 2. 初始化数据个数
		size = 0;
	}
	
	// 增（重点）
	// 平均 O(1)
	public void pushBack(int element) {
		ensureCapacity();
		array[size++] = element;
	}
	
	public void pushFront(int element) {
		ensureCapacity();
		for (int i = size; i >= 1; i--) {
			array[i]  = array[i - 1];
		}
		
		array[0] = element;
		size++;
	}
	
	public void insert(int index, int element) {
		if (index < 0 || index > size) {
			System.err.println("下标错误");
			return;
		}
		
		ensureCapacity();
		
		for (int i = size - 1; i >= index; i--) {
			array[i + 1] = array[i];
		}
		array[index] = element;
		size++;
	}
	
	// 删（重点)
	public void popBack() {
		if (size <= 0) {
			System.err.println("顺序表为空");
			return;
		}
		array[--size] = 0;
	}
	
	public void popFront() {
		if (size <= 0) {
			System.err.println("顺序表为空");
			return;
		}
		
		for (int i = 0; i < size - 1; i++) {
			array[i] = array[i + 1];
		}
		
		array[--size] = 0;
	}
	
	public void earse(int index) {
		if (size <= 0) {
			System.err.println("顺序表为空");
			return;
		}
		
		if (index < 0 || index >= size) {
			System.err.println("下标错误");
			return;
		}
		
		for (int i = index + 1; i < size; i++) {
			array[i - 1] = array[i];
		}
		
		array[--size] = 0;
	}
	
	// 查
	// 改
	// 打印
	public void print() {
		System.out.println("打印顺序表: 当前容量: " + array.length);
		for (int i = 0; i < size; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
	}
	
	// 保证容量够用，否则进行扩容
	private void ensureCapacity() {
		if (size < array.length) {
			return;
		}
		
		int newCapacity = array.length * 2;
		int[] newArray = new int[newCapacity];
		for (int i = 0; i < size; i++) {
			newArray[i] = array[i];
		}
		array = newArray;
	}
	
	public static void main(String[] args) {
		MyArrayList list = new MyArrayList();
		list.print();
		list.pushBack(1);
		list.pushBack(2);
		list.pushBack(3);
		list.print();	// 1 2 3
		list.pushFront(10);
		list.pushFront(20);
		list.pushFront(30);
		list.print();	// 30 20 10 1 2 3
		list.insert(3, 100);
		list.print();	// 30 20 10 100 1 2 3
		list.insert(20, 200);	// 报错
		
		list.earse(2);
		list.earse(2);
		list.print();	// 30 20 1 2 3
		list.popFront();
		list.popFront();
		list.popFront();
		list.print();	// 2 3
		list.popBack();
		list.popBack();
		list.print();	// 空的
		list.popBack();	// 报错
	}
}

3.链表

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的引用链

接次序实现的 。

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向、双向

2. 带头、不带头

3. 循环、非循环

虽然链表的类型很多，我们还是把它分为了三种：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结

构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

2. 带头循环单链表：结构较无头单向非循环链表简单。实际操作当中使用较少。

3. 不带头双向循环链表：在Java的集合框架库中LinkedList底层实现就是不带头双向循环链表。

链表的实现应该注意结点和引用的问题，搞清head以及node包括后面的.next可以帮助我们清晰理解链表。

下面是代码：

// 前驱 prev	previous
// 后继 next
class Node {
	int val;	// data | element
	Node next;	// 如果 next == null 表示是最后一个结点

	Node(int val) {
		this.val = val;
		this.next = null;
	}
	
	public String toString() {
		return String.format("Node(%d)", val);
	}
}

 
public class MyLinkedList {
	public static void main(String[] args) {
		Node head = null;
		// head 的意思是链表的第一个结点
		// 通过第一个结点，就可以找到完整的链表的所有结点
		// 所以，链表的第一个结点往往代表整个链表
		
		// 空的链表，就是一个结点都没有的链表
		// 也就没有第一个结点
		// head == null 表示第一个结点不存在
		// 也就是整个链表为空
		
		
		
		// 头插
		/*
		int val = 0;
		// 1. 结点
		Node node = new Node(val);
		// 2. 让原来的 head 成为 node 的下一个结点
		node.next = head;
		// 3. 更新第一个结点的引用
		head = node;
		
		pushFront(head, 0);
		*/
		
		head = pushFront(head, 0);
		head = pushFront(head, 1);
		head = pushFront(head, 2);
		
		// 打印
		print(head);	// 2 1 0
		
		// 尾插
		head = popFront(head);
		print(head);	// 1 0
		
		head = pushBack(head, 10);
		head = pushBack(head, 20);
		head = pushBack(head, 30);
		print(head);	// 1 0 10 20 30
		head = popBack(head);
		head = popBack(head);
		head = popBack(head);
		head = popBack(head);
		head = popBack(head);
		
		head = popBack(head);	// 报错
		print(head);		// 空
		
		head = pushBack(head, 100);
		print(head);		// 100
	}
	
	// 打印
	private static void print(Node head) {
		System.out.println("打印链表：");
		for (Node cur = head; cur != null; cur = cur.next) {
			System.out.print(cur + " --> ");
		}
		System.out.println("null");
	}
	
	// 头插
	// head: 原来的第一个结点
	// val：要插入的值
	// 返回：新的第一个结点
	private static Node pushFront(Node head, int val) {
		// 1. 结点
		Node node = new Node(val);
		// 2. 让原来的 head 成为 node 的下一个结点
		node.next = head;
		// 3. 更新第一个结点的引用
		return node;
	}
	
	private static Node pushBack(Node head, int val) {
		Node node = new Node(val);
		if (head == null) {
			return node;
		} else {
			Node last = head;
			while (last.next != null) {
				last = last.next;
			}
			last.next = node;
			
			return head;
		}
	}
	
	private static Node popFront(Node head) {
		if (head == null) {
			System.err.println("空链表无法删除");
			return null;
		}
		
		// 原来第一个结点，会因为没有引用指向而被回收
		return head.next;
	}
	
	private static Node popBack(Node head) {
		if (head == null) {
			System.err.println("空链表无法删除");
			return null;
		}
		
		if (head.next == null) {
			return null;
		} else {
			Node lastSecond = head;
			while (lastSecond.next.next != null) {
				lastSecond = lastSecond.next;
			}
			
			lastSecond.next = null;
			return head;
		}
	}
}

线性表在数据结构中比较抽象，希望大家能够慢慢去理解，用画图的方式为自己加深印象，慢慢去体育代码的实行过程，从中找出自己的学习方式。