Java数据结构与算法之数据结构-逻辑结构-线性结构(9)------Java线性结构概念及其基本操作
2017-10-12 10:15
951 查看
Java数据结构与算法结构图如下:
图1:
这个系列的博文中前半部分主要学习总结了Java逻辑结构中的集合部分(Java集合类),这部分主要学习总结的就是图1中红色框框起来的部分知识点。这篇博文将会从
Java的线性结构的定义和内容逐一展开系统化的学习。
基本概念的理解:
一、数据结构:
数据结构由数据和结构两部分组成,就是将数据按照一定的结构组合起来,这样不同的组合方式有不同的效率,可根据需求选择不同的结构应用在相应在场景。
数据结构大致
分为两类:
线性结构(如数组,链表,队列,栈等),非线性结构(如树,图,表,多维数组等)。本文介绍下线性结构,下章介绍非线性结构。
二、数组:
数组表示一组有限个相同类型的数据的集合,顺序存储,下标从0开始,其特点是可以根据下标快速的查找到元素,但在增加和删除元素时会导致大量的数据
位置的变动,即这
种情况下性能不高,故数组一般多用于查找频繁,增,删较少的情况。
下图为一个二维数组的结构图:
插入元素:
当往数组某位置上插入元素时,需要将位置后的所有元素往后移动一个位置。
删除元素:
当删除数组上的某个元素时,需要将该元素后的所有元素的位置往前移动一个位置。
下面简单实现数组中插入元素和删除元素功能:
public class ArrayDemo<T> {
private Object[] array ;
private int length = 0;
private final static int DEFAULT_CAPACITY = 10;
public ArrayDemo(){
super();
this.array = new Object[DEFAULT_CAPACITY];
this.length = DEFAULT_CAPACITY;
}
public ArrayDemo(int length){
super();
if(length < 0){
throw new IllegalArgumentException("error length:"+length);
}
this.array = new Object[length];
this.length = length;
}
public ArrayDemo(Collection<? extends T> c){
array = c.toArray();
length = c.size();
if(array.getClass() != Object[].class){
array = Arrays.copyOf(array, length, Object[].class);
}
}
/**
* 在数组array的index位置处插入一个元素t,如果已经满了,则移除最后一个元素
* @param array
* @param t
* @param indext
*/
public void insert(T t, int index){
if(null == t){
throw new NullPointerException("null Pointer!");
}
if(index < 0 || index > length-1){
throw new IndexOutOfBoundsException("index is error");
}
for(int pos = length-1; pos>index; pos--){
array[pos] = array[pos-1];
}
array[index] = t;
}
/**
* 删除指定位置上的数组元素
* @param array
* @param index
*/
public void delete(int index){
if(null == array){
throw new NullPointerException("null Pointer!");
}
int length = array.length;
if(index < 0 || index > length-1){
throw new IndexOutOfBoundsException("index is error");
}
for(int pos = index; pos < length-1; pos++){
array[pos] = array[pos+1];
}
array[length-1] = null;
}
/**
* 遍历输出数组中所有元素
*/
public void trans(){
if(null == array){
throw new NullPointerException("null Pointer!");
}
for(int pos=0; pos< length; pos++){
System.out.println(array[pos]);
}
}
}
测试类:
public class TestArray {
public static void main(String[] args) {
ArrayDemo<Person> array = new ArrayDemo<>();
Person p = new Person("张三", "m");
array.insert(p, 0);
array.trans();
array.delete(0);
System.out.println("---");
array.trans();
}
}
三、链表:
表是一种有序的列表。链表的内容通常存储在内存中分散的位置上。链表由节点组成,每个节点的结构都是相同的。节点分为数据域和链域,
数据域顾名思义,就是存放节点
节点的内容,链域存放的是下一个节点的指针或引用。如果是双向链表的话,链域中还会有前一个节点的指针或引用。下图为单向链表各节
点间的关系图。
下面来实现一个简单的链表结构
public class Node<T> {
private T data;
private Node<T> pre;
private Node<T> next;
public Node(){
super();
this.pre = null;
this.next = null;
}
public Node(T data){
super();
this.data = data;
this.pre = null;
this.next = null;
}
public Node(T data, Node<T> pre, Node<T> next){
super();
this.data = data;
this.pre = pre;
this.next = next;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node<T> getPre() {
return pre;
}
public void setPre(Node<T> pre) {
this.pre = pre;
}
public Node<T> getNext() {
return next;
}
public void setNext(Node<T> next) {
this.next = next;
}
}
链表类:
public class LinkedListDemo<T> {
private Node<T> head;//头结点
private Node<T> tail;//尾节点
private int size;//链表大小
public LinkedListDemo(){
head = new Node<T>(null, null, null);
tail = new Node<T>(null, head, null);
head.setNext(tail);
size = 0;
}
public MyIterator<T> iterator(){
return new MyIterator<T>();
}
public void add(T data){
Node<T> node = new Node<T>(data);
node.setPre(tail.getPre());
tail.getPre().setNext(node);
tail.setPre(node);
node.setNext(tail);
size++;
}
public void remove(T data){
Node<T> node = head;
while(tail != node.getNext()){
Node<T> currentNode = node.getNext();
if(currentNode.getData().equals(data)){
currentNode.getPre().setNext(currentNode.getNext());
currentNode.getNext().setPre(currentNode.getPre());
size--;
break;
}
node = currentNode;
}
}
public void print(){
Node<T> node = head;
while(tail != node.getNext()){
Node<T> currentNode = node.getNext();
System.out.println(currentNode.getData().toString());
node = currentNode;
}
}
/**
*
* 项目名: adt
* 类名: LinkedListDemo.java
* 类描述: 定义一个该链表的迭代器来访问
* 备注:
* 创建日期:2014-10-10
* 创建时间:上午12:10:46
* @param <T>
*/
@SuppressWarnings("hiding")
private class MyIterator<T> implements Iterator<T>{
@SuppressWarnings("unchecked")
private Node<T> currentNode = (Node<T>) head.getNext();//节点读取当前位置
private Node<T> returnedNode = currentNode;//返回节点的位置
@Override
public boolean hasNext() {
return currentNode == tail? false:true;
}
@Override
public T next() {
if(!hasNext()){
throw new IndexOutOfBoundsException();
}
returnedNode = currentNode;
currentNode = currentNode.getNext();
return returnedNode.getData();
}
@Override
public void remove() {
if(!hasNext()){
throw new NoSuchElementException();
}
returnedNode.getPre().setNext(returnedNode.getNext());
returnedNode.getNext().setPre(returnedNode.getPre());
returnedNode = returnedNode.getNext();
currentNode = returnedNode;
size--;
}
}
}
测试类:
public class TestDemo {
public static void main(String[] args) {
LinkedListDemo<Person> list = new LinkedListDemo<Person>();
//往链表中加入10个元素
for(int i=0; i<10;i++){
Person p = new Person("zhang"+i, "m");
list.add(p);
}
list.print();
System.out.println("========");
Person p = new Person("zhang1", "m");
list.remove(p);//移除自定的元素
list.print();
System.out.println("========");
Person p1 = new Person("zhang4", "m");
Iterator<Person> iterator = list.iterator();
while(iterator.hasNext()){
Person person = iterator.next();
if(person.equals(p1)){
iterator.remove();//迭代器移除制定元素
break;
}
}
list.print();
}
}
测试结果:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
========
Person [name=zhang0, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
========
Person [name=zhang0, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
四、队列
队列数据结构类似于生活中队列,有一个很重要的特性:先进先出。即增加元素肯定是在队列的尾部添加,删除元素肯定是删除队列
头部的元素。队列的实现可以用数据结构,
也可以用链表结构。
下面简单是一个用数组结构实现的队列结构:
public class QueueDemo<T> {
private Object[] object;
/**
* 队列容量
*/
private int capicity;
/**
* 队列中元素的个数
*/
private int size;
private final static int DEFAULT_CAPICAL = 10;
public QueueDemo(){
capicity = DEFAULT_CAPICAL;
object = new Object[capicity];
}
public QueueDemo(int capicity){
this.capicity = capicity;
object = new Object[this.capicity];
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
/**
* 往队列中添加元素
* @param t
*/
public void add(T t){
if(size == capicity){
throw new IndexOutOfBoundsException("queue is full");
}
object[size++]=t;
}
/**
* 移除队列中的元素
*/
public void remove(){
if(isEmpty()){
throw new IndexOutOfBoundsException("queue is empty");
}
for(int pos = 0; pos < size-1; pos++){//将整个数组往前以一个位置
object[pos] = object[pos+1];
}
size--;
}
public void clear(){
Arrays.fill(object, null);
size=0;
}
public void print(){
for(int i=0; i<size; i++){
System.out.println(object[i].toString());
}
}
}
测试类:
public class TestQueue {
/**
* @param args
*/
public static void main(String[] args) {
QueueDemo<Person> queue = new QueueDemo<Person>();
for(int i=0; i<10; i++){
Person p = new Person("zhang"+i, "m");
queue.add(p);
}
queue.print();
System.out.println("=====");
while(queue.size() > 0){//依次删除队列头元素
queue.remove();
queue.print();
System.out.println("=====");
}
}
}
输出:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang9, sex=m]
=====
=====
五、栈
栈结构与队列类似,不过区别在于栈是先进后出的。即最先进栈的元素是最后一个出栈的。栈的结构也可以用数组或链表来实现。
下面简单实现一个基于数组结构的栈,实现只是稍微修改下上面队列结构的代码。
public class StackDemo<T> {
private Object[] object;
private int capicity;
private int size;
private final static int DEFAULT_CAPICAL = 10;
public StackDemo(){
capicity = DEFAULT_CAPICAL;
object = new Object[capicity];
}
public StackDemo(int capicity){
this.capicity = capicity;
object = new Object[this.capicity];
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
public void add(T t){
if(size == capicity){
throw new IndexOutOfBoundsException("queue is full");
}
object[size++]=t;
}
/**
* 修改移除元素的代码
*/
public void remove(){
if(isEmpty()){
throw new IndexOutOfBoundsException("queue is empty");
}
object[--size]=null;
}
public void clear(){
Arrays.fill(object, null);
size=0;
}
public void print(){
for(int i=0; i<size; i++){
System.out.println(object[i].toString());
}
}
}
测试类:
public class TestStack {
/**
* @param args
*/
public static void main(String[] args) {
StackDemo<Person> queue = new StackDemo<Person>();
for(int i=0; i<10; i++){
Person p = new Person("zhang"+i, "m");
queue.add(p);
}
queue.print();
System.out.println("=====");
while(queue.size() > 0){
queue.remove();
queue.print();
System.out.println("=====");
}
}
}
结果:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
=====
Person [name=zhang0, sex=m]
=====
=====
六、几种简单的线性结构介绍完了,在实际的应用环境中需要参考各种数据结构的特点来选择。
数组:查找速度很快,但长度固定,增,删效率较低。
链表:增删效率较高,长度不固定,但查找需要从头遍历整个链表,效率较低。
队列:可用数组,链表实现,先进先出。
栈:可用数组,链表实现,先进后出。
博文以上内容学习自:http://blog.csdn.net/xianymo/article/details/39942611
图1:
这个系列的博文中前半部分主要学习总结了Java逻辑结构中的集合部分(Java集合类),这部分主要学习总结的就是图1中红色框框起来的部分知识点。这篇博文将会从
Java的线性结构的定义和内容逐一展开系统化的学习。
基本概念的理解:
一、数据结构:
数据结构由数据和结构两部分组成,就是将数据按照一定的结构组合起来,这样不同的组合方式有不同的效率,可根据需求选择不同的结构应用在相应在场景。
数据结构大致
分为两类:
线性结构(如数组,链表,队列,栈等),非线性结构(如树,图,表,多维数组等)。本文介绍下线性结构,下章介绍非线性结构。
二、数组:
数组表示一组有限个相同类型的数据的集合,顺序存储,下标从0开始,其特点是可以根据下标快速的查找到元素,但在增加和删除元素时会导致大量的数据
位置的变动,即这
种情况下性能不高,故数组一般多用于查找频繁,增,删较少的情况。
下图为一个二维数组的结构图:
插入元素:
当往数组某位置上插入元素时,需要将位置后的所有元素往后移动一个位置。
删除元素:
当删除数组上的某个元素时,需要将该元素后的所有元素的位置往前移动一个位置。
下面简单实现数组中插入元素和删除元素功能:
public class ArrayDemo<T> {
private Object[] array ;
private int length = 0;
private final static int DEFAULT_CAPACITY = 10;
public ArrayDemo(){
super();
this.array = new Object[DEFAULT_CAPACITY];
this.length = DEFAULT_CAPACITY;
}
public ArrayDemo(int length){
super();
if(length < 0){
throw new IllegalArgumentException("error length:"+length);
}
this.array = new Object[length];
this.length = length;
}
public ArrayDemo(Collection<? extends T> c){
array = c.toArray();
length = c.size();
if(array.getClass() != Object[].class){
array = Arrays.copyOf(array, length, Object[].class);
}
}
/**
* 在数组array的index位置处插入一个元素t,如果已经满了,则移除最后一个元素
* @param array
* @param t
* @param indext
*/
public void insert(T t, int index){
if(null == t){
throw new NullPointerException("null Pointer!");
}
if(index < 0 || index > length-1){
throw new IndexOutOfBoundsException("index is error");
}
for(int pos = length-1; pos>index; pos--){
array[pos] = array[pos-1];
}
array[index] = t;
}
/**
* 删除指定位置上的数组元素
* @param array
* @param index
*/
public void delete(int index){
if(null == array){
throw new NullPointerException("null Pointer!");
}
int length = array.length;
if(index < 0 || index > length-1){
throw new IndexOutOfBoundsException("index is error");
}
for(int pos = index; pos < length-1; pos++){
array[pos] = array[pos+1];
}
array[length-1] = null;
}
/**
* 遍历输出数组中所有元素
*/
public void trans(){
if(null == array){
throw new NullPointerException("null Pointer!");
}
for(int pos=0; pos< length; pos++){
System.out.println(array[pos]);
}
}
}
public class Person { private String name; private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } @Override public String toString() { return "Person [name=" + name + ", sex=" + sex + "]"; } public Person(String name, String sex) { super(); this.name = name; this.sex = sex; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); result = prime * result + ((sex == null) ? 0 : sex.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (sex == null) { if (other.sex != null) return false; } else if (!sex.equals(other.sex)) return false; return true; } }
测试类:
public class TestArray {
public static void main(String[] args) {
ArrayDemo<Person> array = new ArrayDemo<>();
Person p = new Person("张三", "m");
array.insert(p, 0);
array.trans();
array.delete(0);
System.out.println("---");
array.trans();
}
}
三、链表:
表是一种有序的列表。链表的内容通常存储在内存中分散的位置上。链表由节点组成,每个节点的结构都是相同的。节点分为数据域和链域,
数据域顾名思义,就是存放节点
节点的内容,链域存放的是下一个节点的指针或引用。如果是双向链表的话,链域中还会有前一个节点的指针或引用。下图为单向链表各节
点间的关系图。
下面来实现一个简单的链表结构
public class Node<T> {
private T data;
private Node<T> pre;
private Node<T> next;
public Node(){
super();
this.pre = null;
this.next = null;
}
public Node(T data){
super();
this.data = data;
this.pre = null;
this.next = null;
}
public Node(T data, Node<T> pre, Node<T> next){
super();
this.data = data;
this.pre = pre;
this.next = next;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node<T> getPre() {
return pre;
}
public void setPre(Node<T> pre) {
this.pre = pre;
}
public Node<T> getNext() {
return next;
}
public void setNext(Node<T> next) {
this.next = next;
}
}
链表类:
public class LinkedListDemo<T> {
private Node<T> head;//头结点
private Node<T> tail;//尾节点
private int size;//链表大小
public LinkedListDemo(){
head = new Node<T>(null, null, null);
tail = new Node<T>(null, head, null);
head.setNext(tail);
size = 0;
}
public MyIterator<T> iterator(){
return new MyIterator<T>();
}
public void add(T data){
Node<T> node = new Node<T>(data);
node.setPre(tail.getPre());
tail.getPre().setNext(node);
tail.setPre(node);
node.setNext(tail);
size++;
}
public void remove(T data){
Node<T> node = head;
while(tail != node.getNext()){
Node<T> currentNode = node.getNext();
if(currentNode.getData().equals(data)){
currentNode.getPre().setNext(currentNode.getNext());
currentNode.getNext().setPre(currentNode.getPre());
size--;
break;
}
node = currentNode;
}
}
public void print(){
Node<T> node = head;
while(tail != node.getNext()){
Node<T> currentNode = node.getNext();
System.out.println(currentNode.getData().toString());
node = currentNode;
}
}
/**
*
* 项目名: adt
* 类名: LinkedListDemo.java
* 类描述: 定义一个该链表的迭代器来访问
* 备注:
* 创建日期:2014-10-10
* 创建时间:上午12:10:46
* @param <T>
*/
@SuppressWarnings("hiding")
private class MyIterator<T> implements Iterator<T>{
@SuppressWarnings("unchecked")
private Node<T> currentNode = (Node<T>) head.getNext();//节点读取当前位置
private Node<T> returnedNode = currentNode;//返回节点的位置
@Override
public boolean hasNext() {
return currentNode == tail? false:true;
}
@Override
public T next() {
if(!hasNext()){
throw new IndexOutOfBoundsException();
}
returnedNode = currentNode;
currentNode = currentNode.getNext();
return returnedNode.getData();
}
@Override
public void remove() {
if(!hasNext()){
throw new NoSuchElementException();
}
returnedNode.getPre().setNext(returnedNode.getNext());
returnedNode.getNext().setPre(returnedNode.getPre());
returnedNode = returnedNode.getNext();
currentNode = returnedNode;
size--;
}
}
}
测试类:
public class TestDemo {
public static void main(String[] args) {
LinkedListDemo<Person> list = new LinkedListDemo<Person>();
//往链表中加入10个元素
for(int i=0; i<10;i++){
Person p = new Person("zhang"+i, "m");
list.add(p);
}
list.print();
System.out.println("========");
Person p = new Person("zhang1", "m");
list.remove(p);//移除自定的元素
list.print();
System.out.println("========");
Person p1 = new Person("zhang4", "m");
Iterator<Person> iterator = list.iterator();
while(iterator.hasNext()){
Person person = iterator.next();
if(person.equals(p1)){
iterator.remove();//迭代器移除制定元素
break;
}
}
list.print();
}
}
测试结果:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
========
Person [name=zhang0, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
========
Person [name=zhang0, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
四、队列
队列数据结构类似于生活中队列,有一个很重要的特性:先进先出。即增加元素肯定是在队列的尾部添加,删除元素肯定是删除队列
头部的元素。队列的实现可以用数据结构,
也可以用链表结构。
下面简单是一个用数组结构实现的队列结构:
public class QueueDemo<T> {
private Object[] object;
/**
* 队列容量
*/
private int capicity;
/**
* 队列中元素的个数
*/
private int size;
private final static int DEFAULT_CAPICAL = 10;
public QueueDemo(){
capicity = DEFAULT_CAPICAL;
object = new Object[capicity];
}
public QueueDemo(int capicity){
this.capicity = capicity;
object = new Object[this.capicity];
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
/**
* 往队列中添加元素
* @param t
*/
public void add(T t){
if(size == capicity){
throw new IndexOutOfBoundsException("queue is full");
}
object[size++]=t;
}
/**
* 移除队列中的元素
*/
public void remove(){
if(isEmpty()){
throw new IndexOutOfBoundsException("queue is empty");
}
for(int pos = 0; pos < size-1; pos++){//将整个数组往前以一个位置
object[pos] = object[pos+1];
}
size--;
}
public void clear(){
Arrays.fill(object, null);
size=0;
}
public void print(){
for(int i=0; i<size; i++){
System.out.println(object[i].toString());
}
}
}
测试类:
public class TestQueue {
/**
* @param args
*/
public static void main(String[] args) {
QueueDemo<Person> queue = new QueueDemo<Person>();
for(int i=0; i<10; i++){
Person p = new Person("zhang"+i, "m");
queue.add(p);
}
queue.print();
System.out.println("=====");
while(queue.size() > 0){//依次删除队列头元素
queue.remove();
queue.print();
System.out.println("=====");
}
}
}
输出:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang9, sex=m]
=====
=====
五、栈
栈结构与队列类似,不过区别在于栈是先进后出的。即最先进栈的元素是最后一个出栈的。栈的结构也可以用数组或链表来实现。
下面简单实现一个基于数组结构的栈,实现只是稍微修改下上面队列结构的代码。
public class StackDemo<T> {
private Object[] object;
private int capicity;
private int size;
private final static int DEFAULT_CAPICAL = 10;
public StackDemo(){
capicity = DEFAULT_CAPICAL;
object = new Object[capicity];
}
public StackDemo(int capicity){
this.capicity = capicity;
object = new Object[this.capicity];
}
public int size(){
return size;
}
public boolean isEmpty(){
return size==0;
}
public void add(T t){
if(size == capicity){
throw new IndexOutOfBoundsException("queue is full");
}
object[size++]=t;
}
/**
* 修改移除元素的代码
*/
public void remove(){
if(isEmpty()){
throw new IndexOutOfBoundsException("queue is empty");
}
object[--size]=null;
}
public void clear(){
Arrays.fill(object, null);
size=0;
}
public void print(){
for(int i=0; i<size; i++){
System.out.println(object[i].toString());
}
}
}
测试类:
public class TestStack {
/**
* @param args
*/
public static void main(String[] args) {
StackDemo<Person> queue = new StackDemo<Person>();
for(int i=0; i<10; i++){
Person p = new Person("zhang"+i, "m");
queue.add(p);
}
queue.print();
System.out.println("=====");
while(queue.size() > 0){
queue.remove();
queue.print();
System.out.println("=====");
}
}
}
结果:
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
Person [name=zhang9, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
Person [name=zhang8, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
Person [name=zhang7, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
Person [name=zhang6, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
Person [name=zhang5, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
Person [name=zhang4, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
Person [name=zhang3, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
Person [name=zhang2, sex=m]
=====
Person [name=zhang0, sex=m]
Person [name=zhang1, sex=m]
=====
Person [name=zhang0, sex=m]
=====
=====
六、几种简单的线性结构介绍完了,在实际的应用环境中需要参考各种数据结构的特点来选择。
数组:查找速度很快,但长度固定,增,删效率较低。
链表:增删效率较高,长度不固定,但查找需要从头遍历整个链表,效率较低。
队列:可用数组,链表实现,先进先出。
栈:可用数组,链表实现,先进后出。
博文以上内容学习自:http://blog.csdn.net/xianymo/article/details/39942611
相关文章推荐
- 线性表基本概念及其基本操作实现
- 二维数组的定义(动态初始化、静态初始化)、初始化格式及其操作、java中的参数传递方式,面向对象的基本概念
- 线性表的概念、结构与基本操作
- Java数据结构与算法之数据结构-逻辑结构-集合(三)------集合之Iterable接口
- 数据结构笔记(一)线性表的顺序表示和基本操作及其顺序表实现的集合运算(A-B)U(B-A)实例
- 2.1 线性表的定义、逻辑结构、基本操作
- Java数据结构与算法之数据结构-逻辑结构-集合(八)------Java集合类总结
- 爹地的实验:实验一: 数据结构实验一线性表的基本操作实现及其应用
- 数据结构――堆的基本概念及其操作
- Java数据结构与算法之数据结构-逻辑结构-集合(七)------集合之Set接口和HashSet和TreeSet、LinkedHashSet实现类总结
- Java数据结构与算法之数据结构-逻辑结构-集合(四)------集合之Collection接口
- [数据结构]堆的基本概念及其操作
- 数据结构基本概念和术语:位、字节、字、位串、元素、数据域、物理结构、逻辑结构
- 该文简要描述了DOM概念和内部逻辑结构,给出了DOM文档操作和XML文件互相转换java实现过程。
- 基本数据结构——堆(Heap)的基本概念及其操作
- Java数据结构与算法之数据结构-逻辑结构-集合(一)------集合类简析
- Java数据结构与算法之数据结构-逻辑结构-集合(五)------集合之List接口
- 数据结构的逻辑结构和物理结构的基本概念
- 【Java数据结构学习笔记之一】线性表的存储结构及其代码实现
- 数据结构大学教程之数据结构及其基本概念(1)