java數據結構和演算法代碼

『壹』 《數據結構與演算法分析java語言描述（英文版·第3版）》pdf下載在線閱讀，求百度網盤雲資源

《數據結構與演算法分析》（韋斯 (Mark Allen Weiss)）電子書網盤下載免費在線閱讀

資源鏈接：

鏈接：

書名：數據結構與演算法分析

作者：韋斯 (Mark Allen Weiss)

出版社：機械工業出版社

出版年份：2013-2-1

頁數：614

內容簡介：

本書是國外數據結構與演算法分析方面的經典教材，使用卓越的Java編程語言作為實現工具討論了數據結構（組織大量數據的方法）和演算法分析（對演算法運行時間的估計）。

隨著計算機速度的不斷增加和功能的日益強大，人們對有效編程和演算法分析的要求也不斷增長。本書將演算法分析與最有效率的Java程序的開發有機地結合起來，深入分析每種演算法，並細致講解精心構造程序的方法，內容全面、縝密嚴格。

第3版的主要更新如下：

 第4章包含AVL樹刪除演算法的實現。

 第5章進行了全面修訂和擴充，現在包含兩種較新的演算法—cuckoo散列和hopscotch散列。

 第7章包含基數排序的相關內容，並給出了下界證明。

 第12章增加了後綴樹和後綴數組的相關材料，包括Karkkainen和Sanders的線性時間後綴數組構造演算法。

 更新書中的代碼，使用了Java 7中的菱形運算符。

作者簡介：

Mark Allen Weiss佛羅里達國際大學計算與信息科學學院教授、副院長，本科教育主任和研究生教育主任。他於1987年獲得普林斯頓大學計算機科學博士學位，師從Bob Sedgewick。 他曾經擔任全美AP（Advanced Placement）考試計算機學科委員會的主席（2000—2004）。他的主要研究興趣是數據結構、演算法和教育學。

『貳』 關於數據結構（java）的一個代碼

描述棧抽象數據類型的SStack介面的聲明
public interfaceSStack<E> //棧介面
{
boolean isEmpty(); //判斷是否空棧，若空棧返回true
boolean push(E element); //元素element入棧，若操作成功返回true
E pop(); //出棧，返回當前棧頂元素，若棧空返回null
E get(); //取棧頂元素值，未出棧，若棧空返回null
}
順序棧類具體操作方法的聲明：

importdataStructure.linearList.SStack;

public classSeqStack<E> implements SStack<E>
//順序棧類

{
private Object value[]; //存儲棧的數據元素
private int top; //top為棧頂元素下標

public SeqStack(int capacity) //構造指定容量的空棧
{
this.value = newObject[Math.abs(capacity)];
this.top=-1;
}
public SeqStack() //構造默認容量的空棧
{
this(10);
}

public boolean isEmpty() //判斷是否空棧，若空棧返回true
{
return this.top==-1;
}

public boolean push(E element) //元素element入棧，若操作成功返回true
{
if (element==null)
return false; //空對象（null）不能入棧

if (this.top==value.length-1) //若棧滿，則擴充容量
{
Object[] temp = this.value;
this.value = newObject[temp.length*2];
for (int i=0; i<temp.length;i++)
this.value[i] = temp[i];
}
this.top++;
this.value[this.top] = element;
return true;
}

public E pop() //出棧，返回當前棧頂元素，若棧空返回null
{
if (!isEmpty())
return (E)this.value[this.top--];
else
return null;
}

public E get() //取棧頂元素值，未出棧，棧頂元素未改變
{
if (!isEmpty())
return (E)this.value[this.top];
else
return null;
}

public String toString() //返回棧中各元素的字元串描述
{
String str="{";
if (this.top!=-1)
str +=this.value[this.top].toString();
for (int i=this.top-1; i>=0; i--)
str += ","+this.value[i].toString();
return str+"} ";
}
實例引用public static void main(String args[])
{
SeqStack<String> stack = newSeqStack<String>(20);
System.out.print("Push: ");
char ch='a';
for(int i=0;i<5;i++)
{
String str =(char)(ch+i)+"";
stack.push(str);
System.out.print(str+" ");
}
System.out.println("\n"+stack.toString());

System.out.print("Pop : ");
while(!stack.isEmpty()) //全部出棧
System.out.print(stack.pop().toString()+" ");
System.out.println();
}

『叄』 java（樹的內容）演算法與數據結構

其實有兩種方式：
第一種就是遞歸 就像現在比較老的樹形菜單。這種方式應該string類型應該是存不了的。就是自定義一個類型A 裡面有一個成員變數 list<A>。 這種結構就是list裡面嵌套list，你有多少級就有多少層。
第二種其實要做處理，就是把原數據按一定規則排序放到一個list裡面，這裡面不會再嵌套list。list排完序就如你的效果圖一樣。第一個 一級節點 》》其子節點；然後第二個一級節點》》其子節點，etc。 但是這種結構要有存的時候要循環一遍排成上述的順序，取的時候還需要判斷哪個是下一個不同級節點的開始。

js前台展示比較簡單，根據父id直接添加就行了，原數據什麼都不用做。但是java里這種方式不行。

『肆』 演算法 數據結構編程（java語言）

private void sort(int[] list)
{
int[] sortlist=new int[21];
for(int i=1;i<=20;i++)
sortlist[i]=-1;
for(int i=0;i<list.Length;i++)
{
sortlist[list[i]]=list[i];
}
for(int i=0;i<sortlist.Length;i++)
{
if(sortlist[i]!=-1)
{
輸出sortlist[i];
}
}
因為已知最大值，所以遍歷演算法計算次數為常數，所以演算法復雜度為1

『伍』 求程序代碼（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數據結構和演算法

首先看存儲方式, 這個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就變成了第二個元素, 後面的元素以此類推.

『捌』 Java數據結構與演算法有哪些

《Java數據結構和演算法》（第2版）介紹了計算機編程中使用的數據結構和演算法，對於在計算機應用中如何操作和管理數據以取得最優性能提供了深入淺出的講解。全書共分為15章，分別講述了基本概念、數組、簡單排序、堆和隊列、鏈表、遞歸、進階排序、二叉樹、紅黑樹、哈希表及圖形等知識。附錄中則提供了運行專題Applet和常式、相關書籍和問題解答。《Java數據結構和演算法》（第2版）提供了學完一門編程語言後進一步需要知道的知識。本書所涵蓋的內容通常作為大學或學院中計算機系二年級的課程，在學生掌握了編程的基礎後才開始本書的學習。

『玖』 Java 與 演算法+數據結構 （100分）

說數據結構沒用那是不可能的，但是要看你做什麼了。

比如說你要血java，如果你想搞網站方面的話就簡單了。

數據結構基本可以不用學，因為在web應用中，能用到的演算法的地方少之又少，幾乎就那麼幾個，想記不住都難。

但是如果你要往軟體方面和手軟方面發展的話就要學一部分了，但是這東西學是學不到的，能學到的只不過是思路，到時候自己發揮一下，想個演算法就行了，演算法這東西說難不難，難的東西有，但是沒有你能用到的。

像你這樣的情況我想說兩點：

首先，說你想從事演算法類的工作，那麼選擇什麼樣的語言都是一樣的，演算法肯定有，但是用到的都不多。剛進公司的時候一般是用不到演算法的，因為演算法都是別人想的，你也許有好的演算法，但是別人不一定採用，但是你的演算法基礎不要丟掉，因為等你當了項目經理後這個是必不可少的。

其次，你要知道，在學計算機的路上，很少有人能學什麼就做什麼，大家都在被社會潮流推動，想要不掉隊就只能隨波逐流。因為畢竟我們都不想一輩子寫代碼。大家都是拿這東西做個跳板。

學java的路很長，但是也很有趣，希望你能學好。我想以你的演算法基礎，以後想成為專業精英不是問題。加油吧。

『拾』 java冒泡排序法代碼

冒泡排序是比較經典的排序演算法。代碼如下：

for(int i=1;i<arr.length;i++){

for(int j=1;j<arr.length-i;j++){

//交換位置

}

拓展資料：

原理：比較兩個相鄰的元素，將值大的元素交換至右端。

思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重復第一趟步驟，直至全部排序完成。

第一趟比較完成後，最後一個數一定是數組中最大的一個數，所以第二趟比較的時候最後一個數不參與比較；

第二趟比較完成後，倒數第二個數也一定是數組中第二大的數，所以第三趟比較的時候最後兩個數不參與比較；

依次類推，每一趟比較次數-1；

……

舉例說明：要排序數組：int[]arr={6,3,8,2,9,1};

for(int i=1;i<arr.length;i++){

for(int j=1;j<arr.length-i;j++){

//交換位置

}