java数据结构和算法源码

Ⅰ java 常用数据结构

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

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│ └Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

Ⅱ 求程序代码（java版的数据结构）

3个class，运行UI.java。
******
public class CircuitException extends Exception {public CircuitException(){}}
*****
import java.util.LinkedList;
public class GPS {
public static final int MAX = 65535;
public GPS(int maxSize){
graph = new Graph(maxSize);
}
public GPS(){
graph = new Graph();
}
public Graph graph;
public static void main(String args[]){
GPS gps = new GPS();
try {
gps.graph.addEdge("a", "b", 1);
gps.graph.addEdge("a", "c", 1);
gps.graph.addEdge("b","d" , 1);
gps.graph.addEdge("c","d" , 1);
gps.graph.addEdge("d","e" , 1);
gps.graph.addEdge("d","f" , 1);
gps.graph.addEdge("e","t" , 2);
gps.graph.addEdge("f","t" , 1);
LinkedList list = gps.graph.getPath("a", "d");
for(int i = 0 ; i < list.size() ; i++){
System.out.print(list.get(i));

}System.out.println();
} catch (CircuitException e) {
System.out.println("出现了自环！");
}
gps.graph.showGraph();
System.out.println(gps.graph.gap);
}
public class Graph{
public int Zuida = 50;
public int chang = 0;
public Jiao[] vertex;
public double gap;
public Graph(){
vertex = new Jiao[Zuida];
}
public Graph(int maxSize){
this.Zuida = maxSize;
vertex = new Jiao[maxSize];
}
public void addVertex(String name){
vertex[chang++] = new Jiao(name);
}
public void addEdge(String v1, String v2,double edge) throws CircuitException{
//先找到v1；
if(v1.equals(v2))
throw new CircuitException();
Jiao from = null;
Jiao to = null;
for(int i = 0 ; i < chang ; i++){
if(vertex[i].name.equals(v1)){
from = vertex[i];
}else if(vertex[i].name.equals(v2)){
to = vertex[i];
}
}
if(from == null){
this.addVertex(v1);
from = this.vertex[chang-1];
}
if(to == null){
this.addVertex(v2);
to = this.vertex[chang-1];
}//已经找到v1和v2；
//没有检测是否v1 v2边已经存在！
//加入边。
Jiao v1adj = new Jiao(v2);
v1adj.edge = edge;
Jiao v2adj = new Jiao(v1);
v2adj.edge = edge;
//添加联系
//检查联系是否已经存在
Jiao temp = from;
while(temp.next!=null){
Jiao temppar = temp;
temp = temp.next;
if(temp.name.equals(v1adj.name)){
temppar.next = temp.next;
}
}
v1adj.next = from.next;
from.next = v1adj;
//v2adj.next = to.next;
//to.next = v2adj;
}
//假设要找的必然存在，不用想是否不在
public LinkedList getPath(String v1 ,String v2){
int count = 0;
//System.out.println(count++);
boolean found[] = new boolean[chang];
double distance[] = new double[chang];
int to = 0;
Jiao from = null;
for(int i = 0 ; i < chang ; i++){
found[i] = false;
distance[i] = MAX;
}
for(int i = 0 ; i < chang ; i++){
if(vertex[i].name.equals(v1)){//找到始发地
from = vertex[i];
distance[i] = 0;
found[i] = true;
//System.out.println(count++);
}
if(vertex[i].name.equals(v2)){//找到目的地
to = i;
//System.out.println(count++);
}
}
//必须先准备好路径！
Jiao forCount = from;
int degree = 0;
while(forCount!=null){
degree++;
forCount=forCount.next;
}
LinkedList[] list = new LinkedList[degree];
int [] mark = new int[degree];
for(int i = 0 ; i < degree ; i++){
list[i]=new LinkedList();
mark[i]=MAX;
}
int test=0;
int count2 = 0;
int count3 = 0;
//System.out.println(count+++"xx");
while(!found[to]&&test++<100){
//System.out.println(count+++"FIRST");

//开始时from到所有都是最大值。
//找到标记了的节点
//找标记了的节点邻接的未标记的节点。
//得到最短的边，并标记。
//更新现有路径
double min = MAX;
int address = -1;
int father = -1;
for(int i = 0 ; i < chang ; i++){//对于已经找到的顶点寻找最小的往后的距离。
if(found[i]){//找到了的。
Jiao temp = vertex[i];
while(temp!=null){//vertex的邻接顶点~~

//先看temp的号码~
int tempNumber = -1;
for(int j = 0 ; j < chang ; j++){
if(vertex[j].name.equals(temp.name)){
tempNumber = j;
break;
}
}
if(!found[tempNumber]){//如果是还没有找到的~
double dist = distance[i]+temp.edge;
if(dist < min){
min = dist;
father = i;
//System.out.println(" "+min);
address = tempNumber;
}
}
temp = temp.next;
}

}

}found[address] = true;
distance[address] = min;
//添加到已有路径中去！
//知道father
for(int i = 0 ; i < degree ; i++){
if(list[i].isEmpty()||list[i].getLast().equals(vertex[father].name)){
list[i].addLast(vertex[address].name);
break;
}
}
}
for(int i = 0 ; i < degree ; i++){
if(list[i].isEmpty())
continue;
else{
if(list[i].getLast().equals(v2)){
gap=0;
//先求出gap
Jiao pre = from;
Jiao nex = null;
for(int j = 0 ; j < list[i].size() ; j++){
for(int k = 0 ; k < chang ; k++){
if(vertex[k].name.equals(list[i].get(j))){
nex = vertex[k];break;
}
}

while(pre.next!=null){//找到下一个的长度
pre = pre.next;
//System.out.println(nex.name +"nex.name");
if(pre.name.equals(nex.name)){
gap+=pre.edge;
//System.out.println(" gap2 "+gap);
}
}
pre = nex;
}
//System.out.println(gap+"gap");
return list[i];
}
}
}
return null;
}
public void showGraph(){
Jiao temp;
for(int i = 0 ; i < chang ; i++){
temp = vertex[i];
while(temp!=null){
System.out.print(temp.name+temp.edge+" ");
temp = temp.next;
}System.out.println();
}System.out.println("Show Over!");
}
}

public class Jiao{
public String name;
public Jiao next = null;
public double edge;
public Jiao(String name){
this.name = name;
}
}
}
******
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;
import javax.swing.JButton;
import javax.swing.DefaultListModel;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

public class UI extends JFrame implements ActionListener{

private JTextField textField_5;
private JTextField textField_4;
private JList list_1;
private JList list;
private JTextField textField_1;
private JTextField textField_3;
private JTextField textField_2;
private JTextField textField;
private DefaultListModel model = new DefaultListModel();
private DefaultListModel model_1 = new DefaultListModel();
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
UI frame = new UI();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public UI() {
super();
setTitle("GPS寻路");
getContentPane().setLayout(null);
setBounds(100, 100, 500, 375);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(11, 36, 221, 193);
getContentPane().add(scrollPane);

list = new JList(model);
scrollPane.setViewportView(list);

final JScrollPane scrollPane_1 = new JScrollPane();
scrollPane_1.setBounds(253, 36, 218, 193);
getContentPane().add(scrollPane_1);

list_1 = new JList(model_1);
scrollPane_1.setViewportView(list_1);

final JLabel label = new JLabel();
label.setText("从");
label.setBounds(10, 249, 24, 18);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("到");
label_1.setBounds(11, 273, 24, 18);
getContentPane().add(label_1);

textField = new JTextField();
textField.setBounds(50, 247, 103, 22);
getContentPane().add(textField);

textField_2 = new JTextField();
textField_2.setBounds(50, 271, 103, 22);
getContentPane().add(textField_2);

final JLabel label_2 = new JLabel();
label_2.setText("距离");
label_2.setBounds(11, 297, 37, 18);
getContentPane().add(label_2);

textField_3 = new JTextField();
textField_3.setBounds(50, 295, 103, 22);
getContentPane().add(textField_3);

final JButton button = new JButton();
button.setText("添加");
button.setBounds(155, 250, 73, 28);
getContentPane().add(button);

final JButton button_1 = new JButton();
button_1.setText("删除");
button_1.setBounds(155, 285, 73, 28);
getContentPane().add(button_1);

final JLabel label_3 = new JLabel();
label_3.setText("距离：");
label_3.setBounds(253, 297, 39, 18);
getContentPane().add(label_3);

textField_1 = new JTextField();
textField_1.setBounds(293, 295, 86, 22);
getContentPane().add(textField_1);

final JButton button_2 = new JButton();
button_2.setText("显示路径");
button_2.setBounds(385, 249, 86, 68);
getContentPane().add(button_2);

final JLabel label_4 = new JLabel();
label_4.setText("路径表示");
label_4.setBounds(11, 10, 66, 18);
getContentPane().add(label_4);

final JLabel label_5 = new JLabel();
label_5.setText("最佳路径");
label_5.setBounds(253, 12, 66, 18);
getContentPane().add(label_5);
//
button.addActionListener(this);
button_1.addActionListener(this);
button_2.addActionListener(this);

final JLabel label_6 = new JLabel();
label_6.setText("从");
label_6.setBounds(253, 249, 24, 18);
getContentPane().add(label_6);

textField_4 = new JTextField();
textField_4.setBounds(293, 247, 86, 22);
getContentPane().add(textField_4);

final JLabel label_7 = new JLabel();
label_7.setText("到");
label_7.setBounds(253, 273, 24, 18);
getContentPane().add(label_7);

textField_5 = new JTextField();
textField_5.setBounds(293, 271, 86, 22);
getContentPane().add(textField_5);

final JSeparator separator = new JSeparator();
separator.setOrientation(SwingConstants.VERTICAL);
separator.setBounds(239, 10, 8, 317);
getContentPane().add(separator);
}

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand().equals("添加")){

try{String from = textField.getText();
String to = textField_2.getText();
if(from.equals(to)){
JOptionPane.showMessageDialog(null, "始点与终点不能相同");
return;
}
if(from.equals("")||to.equals("")){
JOptionPane.showMessageDialog(null, "添加不能为空");
return;
}for(int i = 0 ; i < model.size() ; i ++){
if(model.get(i).toString().substring(0, model.get(i).toString().indexOf(":")).equals(
from+"->"+to))
model.remove(i);
}
double length = Double.parseDouble(textField_3.getText());
model.addElement(from+"->"+to+": "+length);

}catch(Exception e1){
JOptionPane.showMessageDialog(null, "距离为数字值");
}
}
if(e.getActionCommand().equals("删除")){
for(int i = 0 ; i < model.size() ; i++){
if(list.isSelectedIndex(i))
model.remove(i);
}
}
if(e.getActionCommand().equals("显示路径")){
try{
model_1.removeAllElements();
GPS gps = new GPS();
String full,from,to;
double length;
for(int i = 0 ; i < model.size() ; i++){
full = model.get(i).toString();
from = full.substring(0,full.indexOf("-"));
to = full.substring(full.indexOf("-")+2,full.lastIndexOf(":"));
length = Double.parseDouble(full.substring(full.indexOf(":")+1, full.length()-1));
//System.out.println(from);
//System.out.println(to);
try {
gps.graph.addEdge(from, to, length);
System.out.println(from +" "+ to);
} catch (CircuitException e1) {
System.out.println("有环存在");
}
}LinkedList list = gps.graph.getPath(textField_4.getText(), textField_5.getText());
model_1.addElement(textField_4.getText());
for(int i = 0 ; i < list.size() ; i++){
model_1.addElement(list.get(i));
}//计算路径长度
textField_1.setText(""+gps.graph.gap);
}catch(Exception e1){
JOptionPane.showMessageDialog(null, "没有找到有关节点");
}
}
}
}

Ⅲ JAVA数据结构与算法

给你写了答案如下，有问题再追问。

1. B

2. A

3. C

4. 确切性

5. 3

6. infexOf

7. 队头指针指向队尾

8. 对

9. 对

10. 顺序表：查找方便，但插入困难；

    链表：查找困难，但插入方便。

11. //最大值
    publicstaticintgetMax(intn,int[]arr){//n是数组最后一个元素的index
    	if(n==0)
    		returnarr[0];
    	if(arr[n]>getMax(n-1,arr))
    		returnarr[n];
    	returngetMax(n-1,arr);
    }

    //平均值
    publicstaticintgetAverage(intn,int[]arr){//n是数组最后一个元素的index
    	if(n==1)
    		returnarr[0];
    	return(arr[n]+getAverage(n-1,arr)*(n-1))/n;
    }

12. //删除节点
    publicstaticNodermNode(Nodehead,Nodenode){
    	Nodetemp=head;
    	while(temp.next!=null){
    		if(temp.next==node){
    			temp.next=node.next;
    			break;
    		}
    		else
    			temp=temp.next;
    	}
    	returnhead;
    }

    //数组元素逆置
    publicstaticint[]inverseArray(int[]arr){
    	intstart=0;
    	intend=arr.length-1;
    		
    	for(;start<arr.length/2;start++,end--){
    		inttemp=arr[start];
    		arr[start]=arr[end];
    		arr[end]=temp;
    	}
    	returnarr;

Ⅳ 我需要一本数据结构的算法JAVA代码实现的书。

java数据结构和算法中文版(pdf)附源码
http://58.251.57.206/down1?cid=&t=2&fmt=&usrinput=数据结构和算法java&dt=2002000&ps=0_0&rt=0kbs&plt=0

迅雷试了下能下:http://www.winu.cn/attachment.php?aid=92883

Ⅳ 初学java什么书好

Java初学者，应该学习那些书籍那？

在这里给你推荐几本书，非常优秀的书籍：

当然在推荐之前，你可以在B站内搜索我们的名字，观看一下我们的学习视频；

我校名师高淇讲述的Java300集课程，非常适合刚入门的零基础学者哦！

这几本书相当不错，推荐给你：

1.《Java编程规范》 适合对象：初级、中级

介绍：这本书的作者是被誉为Java之父的James Gosling，入门者推荐阅读，对基础的讲解很不错。

2.《Java编程思想》 适合对象：初级、中级

介绍：豆瓣给出了9.1的评分，全球程序员广泛赞誉。有人说这本书不适合初学者，不过小编认为作者并没有对读者已有的知识经验有过多要求，只是要求读者需要知道基本的程序语言。作者以通俗易懂及小而直接的示例解释了一个个晦涩抽象的概念，需要花时间细细研读。

3.《Java核心技术：卷I基础知识》 适合对象：初级、中级

介绍：官方机构图书，备一本总是没错的。这本书比较全面也通俗易懂。可以当字典的功能来用，学习入门必备。

4.《Java数据结构和算法》 适合对象：初级、中级、高级

介绍：这本书目前基本断货，足以说明抢手程度。作者主要使用Java语言描述了我们常用的数据结构，值得一看。

5.《Java与模式》 适合对象：中级、高级

介绍：难得一见的国人写的Java好书。主要讲解设计原则以及最为常见的设计模式的实用教材。这本书出现的比较早，是初级到中高级必读的图书之一。

6.《SCJP学习指南》 适合对象：初级、中级

介绍：官方考试的必备图书，对检验自己的Java学习情况很有帮助。这本书特别适合学生阅读，这本书理解透了，找工作面试Java题目不会有任何问题。一些工作多年的工程师都会在里边遇到一些不会做的题目。

最后：学习的过程中，编程视频的弥补是不可缺失的，需要的话点个赞吧！

Ⅵ 用Java实现一个地铁票价计算程序，希望给出主要算法与数据结构

根据某市地铁线路图写一个地铁票价计算程序

需求描述：

1.计费规则：最低2元，超过专5站以上每站加收0.5元，换乘重属新起算，例如L1先坐4站，换乘L2再坐6站，结果就是2+2.5=5.5元

2.程序启动以后读取输入文件（in.txt），内容格式如：

L2-8,L2-2

X3,L3-8

....

每行表示一次行程，起点站和终点站之间用逗号分隔，行数不限

4.系统按最短路径方案（尽量少换乘且站数少，假设乘 客换乘一次用的时间相当于坐4个站）规划路线，计算票价，并把路线和票价输出到文件(out.txt)，内容格式如：

L2-8,L2-2=2.5:L2-8,L2-7,L2-6,L2-5,L2-4,L2-3,L2-2

X3,L3-8=4:X3,X4,L3-8

....

等号后面的表示票价和路径

地铁线路图如下：共有5条线路，X开头的站点表示 换乘车站

Ⅶ java数据结构和算法

首先看存储方式, 这个list, 只保存一个link的引用, 作为链表的头, 然后通过这个头.next, 得到第二个, 第二个.next得到第三个, 一次类推, 知道.next == null 的时候, 说明list结束.

那么现在分两种情况看:
1. 当当前链表里面没有元素的时候, 那么就添加一个, 然后让它的next = first, 也就是为null, 那么链表在遍历的时候, 访问了第一个, 然后第一个.next == null, 链表就到头了.

2.当当前链表里面有元素的时候, 那么因为方法叫做firstinsert, 也就是添加头元素, 所以先声明一个link = newlink, 然后让newlink, 的next 指向之前list.first素, 那么现在newlink就变成了第一个, 而之前那个变成了第二个, 然后再把newlink的引用赋给first, 这样, 链表的头就变成了newlink, 达到了first insert的目的.

first的引用就是我上面分析的两种情况, 一种是没有元素就是null, 另一种情况是有, 变成了第二个, 因为这个list要有结束的位置, 否则就无限长了, 结束的条件就是遍历list的时候, 最后一个元素.next == null, 这样list就停住了我大体画个图吧, 你看看:

第一种情况: 当队列中没有元素的时候
列表中什么都没有 : [ (head)null ]
有一个newlink {nl}
执行完newlink.next=first; {nl} -> null
执行完first=newlink; [ (head){nl} -> null ];
这样list的头就是newlist, 只有它一个元素.

第二中情况: 当队列中有元素的时候:
假设当前头元素为{oldhead}
[ (head){oldhead} -> {obj1} -> {obj2} ... {objn} -> null]
有一个newlink {nl}
执行完newlink.next=first; {nl} -> {oldhead}
执行完first=newlink; [ (head){nl} -> {oldhead} -> {obj1} -> {obj2} ... {objn} -> null]
这样list的头就是newlist, 而oldhead就变成了第二个元素, 后面的元素以此类推.