数据结构java

㈠ java 全部的数据结构有哪些

数据结构不是java所特有的,任何一种编程语言都有数据结构,数据结构是数据在计算机中的存储方式.与其用什么语言来实现没什么关系.

㈡ java中都有哪些数据结构

数据结构：
①数组 (Array)
在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数
据元素的集合称为数组。在C语言中， 数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组
元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指
针数组、结构数组等各种类别。
②栈 (Stack)
栈是只能在某一端插入和删除的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后
的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。
③队列 (Queue)
一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行
插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
④链表 (Linked List)
一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：
一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
⑤树 (Tree)
树是包含n（n>0）个结点的有穷集合K，且在K中定义了一个关系N，N满足 以下条件：
（1）有且仅有一个结点 k0，他对于关系N来说没有前驱，称K0为树的根结点。简称为根（root）
（2）除K0外，k中的每个结点，对于关系N来说有且仅有一个前驱。
（3）K中各结点，对关系N来说可以有m个后继（m>=0）。
⑥堆 (Heap)
在计算机科学中，堆是一种特殊的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指
二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
⑦图 (Graph)
图是由结点的有穷集合V和边的集合E组成。其中，为了与树形结构加以区别，在图结构中常常将结点称为顶点，
边是顶点的有序偶对，若两个顶点之间存在一条边，就表示这两个顶点具有相邻关系。
⑧散列表 (Hash)
若结构中存在关键字和K相等的记录，则必定在f(K)的存储位置上。由此，不需比较便可直接取得所查记录。称
这个对应关系f为散列函数(Hash function)，按这个思想建立的表为散列表。
差不多我就知道这些了~

㈢ java 数据结构

List<String> srcStrList = new ArrayList<String>();
List<String> tarStrList = new ArrayList<String>();
String temp = "a";
for(int i = 0; i < 10; i ++) { //构建一个List
srcStrList.add(temp);
temp += temp;
}
int siz = srcStrList.size();
for(int i = 0; i < siz; i + 2) { //实现
tarStrList.add(srcStrList.get(i));
}

Java里，局部变量需要初始化，一楼的一句代码有问题，没有初始化
Vector[int] b; //没有初始化

㈣ 数据结构可以用Java写吗

可以的。
不过 最好你找一本java版本的数据结构来学。
如果数据结构教材本身是C或者C++版本的， 那么书上的样例和讲述都是按照C/C++方式， 自己改成java会很累的。
当然，不管是什么算法， 都是通用的， C/C++可以实现， 那么java就可以实现。无非是难度和效率不一样而已。

㈤ 数据结构（java版）

packagegame24.datastructure.list;

/**
*链表的结点
*@authorluoweifu
*
*/
classNode{
	Objectdata;	//数据元素
	Nodenext;		//后驱结点
	publicNode(){
		this(null);
	}
	publicNode(Objectdata){
		this.data=data;
		this.next=null;
	}
}
/**
*带头结点的链式链表,下标从0开始;
*@authorAdministrator
*
*/
publicclassSinglyLinkedList<E>{
	Nodehead;	//头结点
	intsize;	//链表的大小
	publicSinglyLinkedList(){
		head=newNode();
		size=0;
	}
	publicSinglyLinkedList(E[]datas){
		intn=datas.length;
		head=newNode();
		Nodep=head;
		for(inti=0;i<n;i++){
			p.next=newNode(datas[i]);
			p=p.next;
		}
		size=n;
	}
	publicSinglyLinkedList(SinglyLinkedListlist){
		head=list.head;
		size=list.size();
	}
	publicvoidadd(Objecte){
		Nodep;
		if(0==size){
			p=head;
		}else{
			p=index(size-1);
		}
		p.next=newNode(e);
		size++;
	}
	
	publicvoidconcat(SinglyLinkedListlist){
		NodelastNode=this.index(size-1);
		lastNode.next=list.index(0);
		size+=list.size();
	}

	publicvoidclear(){
		head.next=null;
		size=0;
	}

	publicObjectget(inti){
		Nodep=index(i);
		returnp.data;
	}
	
	privateNodeindex(inti){
		Nodep=null;
		if(i>=0&&i<size){
			p=head;
			for(intj=0;j<=i;j++){
				p=p.next;
			}
		}
		returnp;
	}

	publicintindexOf(Objecte){
		Nodep=head.next;
		inti=0;
		while(!p.data.equals(e)){
			p=p.next;
			i++;
		}
		if(i<size)
			returni;
		else
			return-1;
	}

	publicvoidinsert(inti,Objecte){
		Nodep=index(i);
		Nodep2=newNode(e);
		p2.next=p.next;
		p.next=p2;
		size++;
	}

	publicbooleanisEmpty(){
		if(size==0)
			returntrue;
		else
			returnfalse;
	}

	publicintlastIndexOf(Objecte){
		inti=size-1;
		while(!get(i).equals(e)){
			i--;
		}
		if(i>=0)
			returni;
		else
			return-1;
	}

	publicvoidremove(inti){
		if(i>=0&&i<size){
			Nodep=null;
			if(i==0)
				p=head;
			else{
				p=index(i-1);
			}
			p.next=index(i).next;
		}
		size--;
	}

	publicvoidset(inti,Objecte){
		Nodep=index(i);
		p.data=e;
	}

	publicintsize(){
		returnsize;
	}
	@Override
	publicbooleanequals(Objectobj){
		SinglyLinkedListlist=(SinglyLinkedList)obj;
		if(this==obj&&size==list.size){
			returntrue;
		}
		returnfalse;
	}
	/**
	*测试线性表
	*@paramargs
	*/
	publicstaticvoidmain(Stringargs[]){
		//Listlist=newLinkList();
		//Listlist=newDoubleLinkList();
		SinglyLinkedListlist1=newSinglyLinkedList();
		for(inti=0;i<10;i++){
			list1.add(newInteger(i));
		}
		Integer[]a={101,102,103,104,105,106,107,108,109,110};
		SinglyLinkedListlist=newSinglyLinkedList(a);
		list.remove(9);
		System.out.print("size:"+list.size()+"
");
		System.out.println("isEmpty:"+list.isEmpty());
		System.out.print("第7个位置的元素："+list.get(7)+"
");	
		list.concat(list1);
		for(inti=0;i<list.size();i++){
			System.out.print(list.get(i)+"");
		}
		
		list.add(21);
		list.add(22);
		list.insert(3,newInteger(5));
		System.out.print("size:"+list.size()+"
");
		System.out.print("第一次出现5的索引："+list.indexOf(5)+"
");
		System.out.print("最后一次出现5的索引："+list.lastIndexOf(5)+"
");
		list.set(0,newInteger(30));
		for(inti=0;i<list.size();i++){
			System.out.print(list.get(i)+"");
		}
		
		SinglyLinkedListlist2=list;
		System.out.println("
isequels?"+list2.equals(list));
	}
}

㈥ 什么是java数据结构

数据结构不是JAVA专有.
应该说数据结构是独立于某个具体语言的.
单从JAVA来说,就是用JAVA语言的语法方式,来表达一个对象应该具有什么样的表现形式.

㈦ java数据结构

B.push(A.pop());
A.pop()；

解释:
A.pop() 去掉A的最后一个，即4， 变成1,2,3。而且返回这个4
A.pop() 去掉3
B.push() 接受一个值，放在最后。
因为push接受的是A.pop()返回的4，所以，B就变成 5,6,7,8,4

㈧ Java 常用数据结构

线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│ └Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap