源码 javaData
分析数组的局限性
通过上面的代码，我们发现数组是能完成一个数据结构所有的功能的，而且实现起来也不难，那数据既然能完成所有的工作，我们实际应用中为啥不用它来进行所有的数据存储呢？那肯定是有原因呢。
数组的局限性分析：
①、插入快，对于无序数组，上面我们实现的数组就是无序的，即元素没有按照从大到小或者某个特定的顺序排列，只是按照插入的顺序排列。无序数组增加一个元素很简单，只需要在数组末尾添加元素即可，但是有序数组却不一定了，它需要在指定的位置插入。
public boolean add(int value){
if(elems == length){
return false;
}else{
intArray[elems] = value;
elems++;
}
return true;
}②对于无序数组来说，查找慢，当然如果根据下标来查找是很快的。但是通常我们都是根据元素值来查找，给定一个元素值，对于无序数组，我们需要从数组第一个元素开始遍历，直到找到那个元素。有序数组通过特定的算法查找的速度会比无需数组快，后面我们会讲各种排序算法。
③、删除慢，根据元素值删除，我们要先找到该元素所处的位置，然后将元素后面的值整体向前面移动一个位置。也需要比较多的时间。
④、数组一旦创建后，大小就固定了，不能动态扩展数组的元素个数。如果初始化你给一个很大的数组大小，那会白白浪费内存空间，如果给小了，后面数据个数增加了又添加不进去了。
很显然，数组虽然插入快，但是查找和删除都比较慢，而且扩展性差，所以我们一般不会用数组来存储数据，那有没有什么数据结构插入、查找、删除都很快，而且还能动态扩展存储个数大小呢，答案是有的，但是这是建立在很复杂的算法基础上，后面我们也会详细讲解。
栈的底层实现就是数组
package ch03;
public class MyStack {
//底层实现是一个数组
private long[] arr;
private int top;
/**
* 默认的构造方法
*/
public MyStack() {
arr = new long[10];
top = -1;
}
/**
* 带参数构造方法，参数为数组初始化大小
*/
public MyStack(int maxsize) {
arr = new long[maxsize];
top = -1;
}
/**
* 添加数据
*/
public void push(int value) {
arr[++top] = value;
}
/**
* 移除数据
*/
public long pop() {
return arr[top--];
}
/**
* 查看数据
*/
public long peek() {
return arr[top];
}
/**
* 判断是否为空
*/
public boolean isEmpty() {
return top == -1;
}
/**
* 判断是否满了
*/
public boolean isFull() {
return top == arr.length - 1;
}
}
package ch03;
public class TestMyStack {
public static void main(String[] args) {
MyStack ms = new MyStack(4);
ms.push(23);
ms.push(12);
ms.push(1);
ms.push(90);
System.out.println(ms.isEmpty());
System.out.println(ms.isFull());
System.out.println(ms.peek());
System.out.println(ms.peek());
while(!ms.isEmpty()) {
System.out.print(ms.pop() + ",");
}
}
}
队列的实现
package ch03;
/*
* 列队类
*/
public class MyQueue {
//底层使用数组
private long[] arr;
//有效数据的大小
private int elements;
//队头
private int front;
//队尾
private int end;
/**
* 默认构造方法
*/
public MyQueue() {
arr = new long[10];
elements = 0;
front = 0;
end = -1;
}
/**
* 带参数的构造方法，参数为数组的大小
*/
public MyQueue(int maxsize) {
arr = new long[maxsize];
elements = 0;
front = 0;
end = -1;
}
/**
* 添加数据,从队尾插入
*/
public void insert(long value) {
arr[++end] = value;
elements++;
}
/**
* 删除数据，从队头删除
*/
public long remove() {
elements--;
return arr[front++];
}
/**
* 查看数据，从队头查看
*/
public long peek() {
return arr[front];
}
/**
* 判断是否为空
*/
public boolean isEmpty() {
return elements == 0;
}
/**
* 判断是否满了
*/
public boolean isFull() {
return elements == arr.length;
}
}
package ch03;
public class TestMyQueue {
public static void main(String[] args) {
MyCycleQueue mq = new MyCycleQueue(4);
mq.insert(23);
mq.insert(45);
mq.insert(13);
mq.insert(1);
System.out.println(mq.isFull());
System.out.println(mq.isEmpty());
System.out.println(mq.peek());
while (!mq.isEmpty()) {
System.out.print(mq.remove() + " ");
}
}
}
链表
链表必须有一个头，有一个尾，除了第一位每一个都有一个前驱，除了最后一位，每一个都有一个后继
1、链表（Linked List）
链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
2、单向链表（Single-Linked List）
单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。
单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。
在表头增加节点：
删除节点：
package ch04;
/*
* 链结点，相当于是车厢
*/
public class Node {
//数据域
public long data;
//指针域
public Node next;
public Node(long value) {
this.data = value;
}
/**
* 显示方法
*/
public void display() {
System.out.print(data + " ");
}
}
package ch04;
/*
* 链表，相当于火车
*/
public class LinkList {
//头结点
private Node first;
public LinkList() {
first = null;
}
/**
* 插入一个结点，在头结点前面进行插入
*/
public void insertFirst(long value) {
Node node = new Node(value);
node.next = first;
first = node;
}
/**
* 删除一个结点，在头结点后进行删除
*/
public Node deleteFirst() {
Node tmp = first;
first = tmp.next;
return tmp;
}
/**
* 显示方法
*/
public void display() {
Node current = first;
while(current != null) {
current.display();
current = current.next;
}
System.out.println();
}
/**
* 查找方法
*/
public Node find(long value) {
Node current = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
current = current.next;
}
return current;
}
/**
* 删除方法，根据数据域来进行删除
*/
public Node delete(long value) {
Node current = first;
Node previous = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
previous = current;
current = current.next;
}
if(current == first) {
first = first.next;
} else {
previous.next = current.next;
}
return current;
}
}
package ch04;
public class TestLinkList {
public static void main(String[] args) {
LinkList linkList = new LinkList();
linkList.insertFirst(34);
linkList.insertFirst(23);
linkList.insertFirst(12);
linkList.insertFirst(0);
linkList.insertFirst(-1);
// linkList.display();
//
// linkList.deleteFirst();
// linkList.display();
//
// Node node = linkList.find(23);
// node.display();
Node node1 = linkList.delete(0);
node1.display();
System.out.println();
linkList.display();
}
}
双端链表
对于单项链表，我们如果想在尾部添加一个节点，那么必须从头部一直遍历到尾部，找到尾节点，然后在尾节点后面插入一个节点。这样操作很麻烦，如果我们在设计链表的时候多个对尾节点的引用，那么会简单很多。
注意和后面将的双向链表的区别！！！
package com.ys.link;
public class DoublePointLinkedList {
private Node head;//头节点
private Node tail;//尾节点
private int size;//节点的个数
private class Node{
private Object data;
private Node next;
public Node(Object data){
this.data = data;
}
}
public DoublePointLinkedList(){
size = 0;
head = null;
tail = null;
}
//链表头新增节点
public void addHead(Object data){
Node node = new Node(data);
if(size == 0){//如果链表为空，那么头节点和尾节点都是该新增节点
head = node;
tail = node;
size++;
}else{
node.next = head;
head = node;
size++;
}
}
//链表尾新增节点
public void addTail(Object data){
Node node = new Node(data);
if(size == 0){//如果链表为空，那么头节点和尾节点都是该新增节点
head = node;
tail = node;
size++;
}else{
tail.next = node;
tail = node;
size++;
}
}
//删除头部节点，成功返回true，失败返回false
public boolean deleteHead(){
if(size == 0){//当前链表节点数为0
return false;
}
if(head.next == null){//当前链表节点数为1
head = null;
tail = null;
}else{
head = head.next;
}
size--;
return true;
}
//判断是否为空
public boolean isEmpty(){
return (size ==0);
}
//获得链表的节点个数
public int getSize(){
return size;
}
//显示节点信息
public void display(){
if(size >0){
Node node = head;
int tempSize = size;
if(tempSize == 1){//当前链表只有一个节点
System.out.println("["+node.data+"]");
return;
}
while(tempSize>0){
if(node.equals(head)){
System.out.print("["+node.data+"->");
}else if(node.next == null){
System.out.print(node.data+"]");
}else{
System.out.print(node.data+"->");
}
node = node.next;
tempSize--;
}
System.out.println();
}else{//如果链表一个节点都没有，直接打印[]
System.out.println("[]");
}
}
}有序链表
前面的链表实现插入数据都是无序的，在有些应用中需要链表中的数据有序，这称为有序链表。
在有序链表中，数据是按照关键值有序排列的。一般在大多数需要使用有序数组的场合也可以使用有序链表。有序链表优于有序数组的地方是插入的速度（因为元素不需要移动），另外链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小中。
package com.ys.datastructure;
public class OrderLinkedList {
private Node head;
private class Node{
private int data;
private Node next;
public Node(int data){
this.data = data;
}
}
public OrderLinkedList(){
head = null;
}
//插入节点，并按照从小打到的顺序排列
public void insert(int value){
Node node = new Node(value);
Node pre = null;
Node current = head;
while(current != null && value > current.data){
pre = current;
current = current.next;
}
if(pre == null){
head = node;
head.next = current;
}else{
pre.next = node;
node.next = current;
}
}
//删除头节点
public void deleteHead(){
head = head.next;
}
public void display(){
Node current = head;
while(current != null){
System.out.print(current.data+" ");
current = current.next;
}
System.out.println("");
}
}双向链表
我们知道单向链表只能从一个方向遍历，那么双向链表它可以从两个方向遍历。
package com.ys.datastructure;
public class TwoWayLinkedList {
private Node head;//表示链表头
private Node tail;//表示链表尾
private int size;//表示链表的节点个数
private class Node{
private Object data;
private Node next;
private Node prev;
public Node(Object data){
this.data = data;
}
}
public TwoWayLinkedList(){
size = 0;
head = null;
tail = null;
}
//在链表头增加节点
public void addHead(Object value){
Node newNode = new Node(value);
if(size == 0){
head = newNode;
tail = newNode;
size++;
}else{
head.prev = newNode;
newNode.next = head;
head = newNode;
size++;
}
}
//在链表尾增加节点
public void addTail(Object value){
Node newNode = new Node(value);
if(size == 0){
head = newNode;
tail = newNode;
size++;
}else{
newNode.prev = tail;
tail.next = newNode;
tail = newNode;
size++;
}
}
//删除链表头
public Node deleteHead(){
Node temp = head;
if(size != 0){
head = head.next;
head.prev = null;
size--;
}
return temp;
}
//删除链表尾
public Node deleteTail(){
Node temp = tail;
if(size != 0){
tail = tail.prev;
tail.next = null;
size--;
}
return temp;
}
//获得链表的节点个数
public int getSize(){
return size;
}
//判断链表是否为空
public boolean isEmpty(){
return (size == 0);
}
//显示节点信息
public void display(){
if(size >0){
Node node = head;
int tempSize = size;
if(tempSize == 1){//当前链表只有一个节点
System.out.println("["+node.data+"]");
return;
}
while(tempSize>0){
if(node.equals(head)){
System.out.print("["+node.data+"->");
}else if(node.next == null){
System.out.print(node.data+"]");
}else{
System.out.print(node.data+"->");
}
node = node.next;
tempSize--;
}
System.out.println();
}else{//如果链表一个节点都没有，直接打印[]
System.out.println("[]");
}
}
}每个链表都包括一个LinikedList对象和许多Node对象，LinkedList对象通常包含头和尾节点的引用，分别指向链表的第一个节点和最后一个节点。而每个节点对象通常包含数据部分data，以及对上一个节点的引用prev和下一个节点的引用next，只有下一个节点的引用称为单向链表，两个都有的称为双向链表。next值为null则说明是链表的结尾，如果想找到某个节点，我们必须从第一个节点开始遍历，不断通过next找到下一个节点，直到找到所需要的。栈和队列都是ADT，可以用数组来实现，也可以用链表实现。
扫一扫
651
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
