java中线性结构的例子_java数据结构--线性结构
一、數據結構
數據結構由數據和結構兩部分組成，就是將數據按照一定的結構組合起來，這樣不同的組合方式有不同的效率，可根據需求選擇不同的結構應用在相應在場景。數據結構大致
分為兩類：線性結構(如數組，鏈表，隊列，棧等)，非線性結構(如樹，圖，表等)。本文介紹下線性結構，下章介紹非線性結構。
二、數組
數組表示一組有限個相同類型的數據的集合，順序存儲，下標從0開始，其特點是可以根據下標快速的查找到元素，但在增加和刪除元素時會導致大量的數據位置的變動，即這
種情況下性能不高，故數組一般多用于查找頻繁，增，刪較少的情況。
下圖為一個二維數組的結構圖：
插入元素：
當往數組某位置上插入元素時，需要將位置后的所有元素往后移動一個位置。
刪除元素：
當刪除數組上的某個元素時，需要將該元素后的所有元素的位置往前移動一個位置。
下面簡單實現數組中插入元素和刪除元素功能：
public class ArrayDemo {
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 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 {
private T data;
private Node pre;
private Node 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 pre, Node 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 getPre() {
return pre;
}
public void setPre(Node pre) {
this.pre = pre;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
鏈表類
public class LinkedListDemo {
private Node head;//頭結點
private Node tail;//尾節點
private int size;//鏈表大小
public LinkedListDemo(){
head = new Node(null, null, null);
tail = new Node(null, head, null);
head.setNext(tail);
size = 0;
}
public MyIterator iterator(){
return new MyIterator();
}
public void add(T data){
Node node = new Node(data);
node.setPre(tail.getPre());
tail.getPre().setNext(node);
tail.setPre(node);
node.setNext(tail);
size++;
}
public void remove(T data){
Node node = head;
while(tail != node.getNext()){
Node 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 node = head;
while(tail != node.getNext()){
Node currentNode = node.getNext();
System.out.println(currentNode.getData().toString());
node = currentNode;
}
}
/**
*
* 項目名： adt
* 類名： LinkedListDemo.java
* 類描述： 定義一個該鏈表的迭代器來訪問
* 備注：
* 創建日期：2014-10-10
* 創建時間：上午12:10:46
* @param
*/
@SuppressWarnings("hiding")
private class MyIterator implements Iterator{
@SuppressWarnings("unchecked")
private Node currentNode = (Node) head.getNext();//節點讀取當前位置
private Node 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 list = new LinkedListDemo();
//往鏈表中加入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 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 {
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
System.out.println(object[i].toString());
}
}
}
測試類：
public class TestQueue {
/**
* @param args
*/
public static void main(String[] args) {
QueueDemo queue = new QueueDemo();
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 {
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
System.out.println(object[i].toString());
}
}
}
測試類：
public class TestStack {
/**
* @param args
*/
public static void main(String[] args) {
StackDemo queue = new StackDemo();
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]
=====
=====
六、幾種簡單的線性結構介紹完了，在實際的應用環境中需要參考各種數據結構的特點來選擇。
數組：查找速度很快，但長度固定，增，刪效率較低。
鏈表：增刪效率較高，長度不固定，但查找需要從頭遍歷整個鏈表，效率較低。
隊列：可用數組，鏈表實現，先進先出。
棧：可用數組，鏈表實現，先進后出。
總結
以上是生活随笔為你收集整理的java中线性结构的例子_java数据结构--线性结构的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 个人Icp备案主办单位怎么写（个人icp
- 下一篇： java相关技术简介_java技术简介？