java数据结构和算法源码
‘壹’ 求程序代码（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（算法与数据结构）tree
代码实现[一]部分
package ChapterEight;
class Tree {
class Node {
public long value;
public Node leftChild;
public Node rightChild;
public Node(long value) {
this.value = value;
leftChild = null;
rightChild = null;
}
}
public Node root;
public Tree() {
root = null;
}
// 向树中插入一个节点
public void insert(long value) {
Node newNode = new Node(value);
// 树是空的
if (root == null)
root = newNode;
else {
Node current = root;
Node parentNode;
while (true) {
parentNode = current;
if (value < current.value) {
current = current.leftChild;
// 要插入的节点为左孩子节点
if (current == null) {
parentNode.leftChild = newNode;
return;
}
} else {
// 要插入的节点为右孩子节点
current = current.rightChild;
if (current == null) {
parentNode.rightChild = newNode;
return;
}
}
}
}
}
// 先续遍历树中的所有节点
public void preOrder(Node currentRoot) {
if (currentRoot != null) {
System.out.print(currentRoot.value + " ");
preOrder(currentRoot.leftChild);
preOrder(currentRoot.rightChild);
}
}
// 中续遍历树中的所有节点
public void inOrder(Node currentNode) {
if (currentNode != null) {
inOrder(currentNode.leftChild);
System.out.print(currentNode.value + " ");
inOrder(currentNode.rightChild);
}
}
// 后续遍历树中的所有节点
public void postOrder(Node currentNode) {
if (currentNode != null) {
postOrder(currentNode.leftChild);
postOrder(currentNode.rightChild);
System.out.print(currentNode.value + " ");
}
}
public void traverse(int traverseType) {
switch (traverseType) {
case 1:
preOrder(root);
break;
case 2:
inOrder(root);
break;
case 3:
postOrder(root);
break;
default:
break;
}
// 依据树节点的值删除树中的一个节点
public boolean delete(int value) {
// 遍历树过程中的当前节点
Node current = root;
// 要删除节点的父节点
Node parent = root;
// 记录树的节点为左孩子节点或右孩子节点
boolean isLeftChild = true;
while (current.value != value) {
parent = current;
// 要删除的节点在当前节点的左子树里
if (value < current.value) {
isLeftChild = true;
current = current.leftChild;
}
// 要删除的节点在当前节点的右子树里
else {
isLeftChild = false;
current = current.rightChild;
}
// 在树中没有找到要删除的节点
if (current == null)
return false;
}
// 要删除的节点为叶子节点
if (current.leftChild == null && current.rightChild == null) {
// 要删除的节点为根节点
if (current == root)
root = null;
// 要删除的节点为左孩子节点
else if (isLeftChild)
parent.leftChild = null;
// 要删除的节点为右孩子节点
else
parent.rightChild = null;
}
// 要删除的节点有左孩子节点，没有右孩子节点
else if (current.rightChild == null) {
// 要删除的节点为根节点
if (current == null)
root = current.leftChild;
// 要删除的节点为左孩子节点
else if (isLeftChild)
parent.leftChild = current.leftChild;
// 要删除的节点为右孩子节点
else
parent.rightChild = current.leftChild;
}
// 要删除的节点没有左孩子节点，有右孩子节点
else if (current.leftChild == null) {
// 要删除的节点为根节点
if (current == root)
root = root.rightChild;
// 要删除的节点为左孩子节点
else if (isLeftChild)
parent.leftChild = current.rightChild;
// 要删除的节点为右孩子节点
else
parent.rightChild = current.rightChild;
}
// 要删除的接节点既有左孩子节点又有右孩子节点
else {
Node successor = getSuccessor(current);
// 要删除的节点为根节点
if (current == root)
root = successor;
// 要删除的节点为左孩子节点
else if (isLeftChild)
parent.leftChild = successor;
// 要删除的节点为右孩子节点
else
parent.rightChild = successor;
}
return true;
}
// 找到要删除节点的替补节点
private Node getSuccessor(Node delNode) {
// 替补节点的父节点
Node successorParent = delNode;
// 删除节点的替补节点
Node successor = delNode;
Node current = delNode.rightChild;
while (current != null) {
// successorParent指向当前节点的上一个节点
successorParent = successor;
// successor变为当前节点
successor = current;
current = current.leftChild;
}
// 替补节点的右孩子节点不为空
if (successor != delNode.rightChild) {
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
}
public class TreeApp {
public static void main(String[] args) {
Tree tree = new Tree();
tree.insert(8);
tree.insert(50);
tree.insert(45);
tree.insert(21);
tree.insert(32);
tree.insert(18);
tree.insert(37);
tree.insert(64);
tree.insert(88);
tree.insert(5);
tree.insert(4);
tree.insert(7);
System.out.print("PreOrder : ");
tree.traverse(1);
System.out.println();
System.out.print("InOrder : ");
tree.traverse(2);
System.out.println();
System.out.print("PostOrder : ");
tree.traverse(3);
System.out.println();
System.out.println(tree.delete(7));
System.out.print("PreOrder : ");
tree.traverse(1);
System.out.println();
System.out.print("InOrder : ");
tree.traverse(2);
System.out.println();
System.out.print("PostOrder : ");
tree.traverse(3);
System.out.println();
}
}
‘叁’ Java数据结构与算法有哪些
《Java数据结构和算法》（第2版）介绍了计算机编程中使用的数据结构和算法，对于在计算机应用中如何操作和管理数据以取得最优性能提供了深入浅出的讲解。全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、递归、进阶排序、二叉树、红黑树、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。《Java数据结构和算法》（第2版）提供了学完一门编程语言后进一步需要知道的知识。本书所涵盖的内容通常作为大学或学院中计算机系二年级的课程，在学生掌握了编程的基础后才开始本书的学习。
‘肆’ JAVA数据结构与算法
给你写了答案如下，有问题再追问。
B
A
C
确切性
3
infexOf
队头指针指向队尾
对
对
顺序表：查找方便，但插入困难；
链表：查找困难，但插入方便。
//最大值
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;
}//删除节点
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实现一个地铁票价计算程序，希望给出主要算法与数据结构
根据某市地铁线路图写一个地铁票价计算程序
需求描述：
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实现一个数据结构！
import java.io.IOException;
import java.util.Scanner;
public class LinkList {
private static Scanner san = new Scanner(System.in);
public static void main(String[] args) throws IOException {
List list = new List();
for (int i = 1; i <= 10; i++) {
System.out.print("请输入第" + i + "个数: ");
list.add(san.nextInt());
list.print();
}
System.out.println("输入的数据如下: ");
list.print();
}
}
class node {
int data;
node next = this; // 指向自己
}
class List {
private node header = new node();
// 循环链表的尾部添加数据
public node add(int data) {
node current = new node();
node temp = header;
while (temp.next != header)
temp = temp.next;
current.data = data;
current.next = temp.next;
temp.next = current;
return current;
}
// 查询某个数字的位置 如果不在 返回-1；
public int search(int data) {
node temp = header;
int n = 0;
while (temp.next != header) {
temp = temp.next;
n++;
if (temp.data == data)
break;
}
if (temp.data == data)
return n;
else
return -1;
}
// 打印出整个链表
public void print() {
node temp = header;
while (temp.next != header) {
temp = temp.next;
System.out.print(temp.data + " ");
}
System.out.println();
}
// 插入数据
public node Insert(int pos, int data) {
node temp = header;
node current = new node();
for (int i = 0; i < pos - 1; i++) {
if (temp.next != header) {
temp = temp.next;
} else
return null;
}
current.data = data;
if (temp.next != header) {
current.next = temp.next;
}
temp.next = current;
return current;
}
// 删除某个数据
public node del(int data) {
node temp = header;
node oldtemp = null;
node current = null;
while (temp.next != header) {
oldtemp = temp;
temp = temp.next;
if (temp.data == data) {
current = temp;
break;
}
}
if (current == header)
return null;
oldtemp.next = current.next;
return current;
}
}
‘捌’ 数据结构JAVA编程求教
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
#define N 9 /* 数据元素个数 */
typedef char KeyType; /* 设关键字域为字符型 */
typedef struct /* 数据元素类型 */
{
KeyType key;
int weight;
}ElemType;
ElemType r[N]={{'A',1},{'B',1},{'C',2},{'D',5},{'E',3},
{'F',4},{'G',4},{'H',3},{'I',5}}; /* 数据元素(以教科书例9-1为例),全局变量 */
int sw[N+1]; /* 累计权值，全局变量 */
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)<(b))
typedef struct
{
ElemType *elem; /* 数据元素存储空间基址，建表时按实际长度分配，0号单元留空 */
int length; /* 表长度 */
}SSTable;
Status Creat_Seq(SSTable *ST,int n)
{ /* 操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r) */
int i;
(*ST).elem=(ElemType *)calloc(n+1,sizeof(ElemType)); /* 动态生成n个数据元升缺素空间(0号单元不用) */
if(!(*ST).elem)
return ERROR;
for(i=1;i<=n;i++)
*((*ST).elem+i)=r[i-1]; /* 将全局数组r的值依次赋给ST */
(*ST).length=n;
return OK;
}
void Ascend(SSTable *ST)
{ /* 重建静态查找表为按关键字非降序排序 */
int i,j,k;
for(i=1;i<(*ST).length;i++)
{
k=i;
(*ST).elem[0]=(*ST).elem[i]; /* 待比较值存[0]单元 */
for(j=i+1;j<=(*ST).length;j++)
if LT((*ST).elem[j].key,(*ST).elem[0].key)
{
k=j;
(*ST).elem[0]=(*ST).elem[j];
}
if(k!=i) /* 有更小的值则交换 */
{
(*ST).elem[k]=(*ST).elem[i];
(*ST).elem[i]=(*ST).elem[0];
}
}
}
Status Creat_Ord(SSTable *ST,int n)
{ /* 操作结果: 构造一个含n个数据元素的静态按关键字非降序查找表ST */
/* 数据来自全局数组r */
Status f;
f=Creat_Seq(ST,n);
if(f)
Ascend(ST);
return f;
}
Status Traverse(SSTable ST,void(*Visit)(ElemType))
{ /* 初始条件: 静态查找表ST存在，Visit()是对元素操作的应用函数 */
/* 操作结果: 按顺序对ST的每个元素调用函数Visit()一次且仅一次。 */
/* 一旦Visit()失败，则槐逗操作失败 */
ElemType *p;
int i;
p=++ST.elem; /* p指向第一个元素铅笑卖 */
for(i=1;i<=ST.length;i++)
Visit(*p++);
return OK;
}
typedef ElemType TElemType;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode,*BiTree;
Status SecondOptimal(BiTree *T, ElemType R[],int sw[],int low,int high)
{ /* 由有序表R[low..high]及其累计权值表sw(其中sw[0]==0)递归构造 */
/* 次优查找树T。*/
int i,j;
double min,dw;
i=low;
min=fabs(sw[high]-sw[low]);
dw=sw[high]+sw[low-1];
for(j=low+1;j<=high;++j) /* 选择最小的△Pi值 */
if(fabs(dw-sw[j]-sw[j-1])<min)
{
i=j;
min=fabs(dw-sw[j]-sw[j-1]);
}
*T=(BiTree)malloc(sizeof(BiTNode));
if(!*T)
return ERROR;
(*T)->data=R[i]; /* 生成结点 */
if(i==low)
(*T)->lchild=NULL; /* 左子树空 */
else
SecondOptimal(&(*T)->lchild,R,sw,low,i-1); /* 构造左子树 */
if(i==high)
(*T)->rchild=NULL; /* 右子树空 */
else
SecondOptimal(&(*T)->rchild,R,sw,i+1,high); /* 构造右子树 */
return OK;
}
void FindSW(int sw[],SSTable ST)
{ /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */
int i;
sw[0]=0;
for(i=1;i<=ST.length;i++)
sw[i]=sw[i-1]+ST.elem[i].weight;
}
typedef BiTree SOSTree; /* 次优查找树采用二叉链表的存储结构 */
Status CreateSOSTree(SOSTree *T,SSTable ST)
{ /* 由有序表ST构造一棵次优查找树T。ST的数据元素含有权域weight。*/
if(ST.length==0)
*T=NULL;
else
{
FindSW(sw,ST); /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */
SecondOptimal(T,ST.elem,sw,1,ST.length);
}
return OK;
}
Status Search_SOSTree(SOSTree *T,KeyType key)
{ /* 在次优查找树T中查找关键字等于key的元素。找到则返回OK，否则返回FALSE */
while(*T) /* T非空 */
if((*T)->data.key==key)
return OK;
else if((*T)->data.key>key)
*T=(*T)->lchild;
else
*T=(*T)->rchild;
return FALSE; /* 顺序表中不存在待查元素 */
}
void print(ElemType c) /* Traverse()调用的函数 */
{
printf("(%c %d) ",c.key,c.weight);
}
void main()
{
SSTable st;
SOSTree t;
Status i;
KeyType s;
Creat_Ord(&st,N); /* 由全局数组产生非降序静态查找表st */
Traverse(st,print);
CreateSOSTree(&t,st); /* 由有序表构造一棵次优查找树 */
printf(" 请输入待查找的字符: ");
scanf("%c",&s);
i=Search_SOSTree(&t,s);
if(i)
printf("%c的权值是%d ",s,t->data.weight);
else
printf("表中不存在此字符 ");
}
运行结果：
这个是数据结构上的一个源码，你用这个自己改一改试试吧
‘玖’ java数据结构与算法分析
于之前面试android的时候考到了很多关于java的知识，所以这次重温数据结构知识就打算用java来学习，毕竟android是以java为基础的，而且我现在学习的j2ee架构也是以java为基础的。
java中的类就是对现实世界的对象的一种抽象，例如人就是一个类别，人有名字，联系电话，住址等成员属性，人拥有说话，吃饭，走路等成员方法。类就是这样，定义了一种对象，它有什么，会做什么。
继承——子类就是父类的一种特定类别。例如学生就是人的子类，学生属于人，是特定的一类人。所以我们让学生继承人，这样学生可以拥有人的属性和方法，也就是说，学生也有了名字，联系电话，住址等成员属性，拥有说话，吃饭，走路等成员方法。但是学生还有特定的一些方法（读书，上课），或者特定的一些属性（学号，年级），这些可以添加在子类中。
因为每个子类都属于父类，例如每个学生都属于人，所以可以用父类来引用子类的对象:People p = new Student();反过来不行。
java中一个类只能继承一个父类，也就是单继承。
但一个类可以实现多个接口，间接地实现了多继承。接口就是一系列方法的声明，没有实现。于之前面试android的时候考到了很多关于java的知识，所以这次重温数据结构知识就打算用java来学习，毕竟android是以java为基础的，而且我现在学习的j2ee架构也是以java为基础的。
java中的类就是对现实世界的对象的一种抽象，例如人就是一个类别，人有名字，联系电话，住址等成员属性，人拥有说话，吃饭，走路等成员方法。类就是这样，定义了一种对象，它有什么，会做什么。
继承——子类就是父类的一种特定类别。例如学生就是人的子类，学生属于人，是特定的一类人。所以我们让学生继承人，这样学生可以拥有人的属性和方法，也就是说，学生也有了名字，联系电话，住址等成员属性，拥有说话，吃饭，走路等成员方法。但是学生还有特定的一些方法（读书，上课），或者特定的一些属性（学号，年级），这些可以添加在子类中。
因为每个子类都属于父类，例如每个学生都属于人，所以可以用父类来引用子类的对象:People p = new Student();反过来不行。
java中一个类只能继承一个父类，也就是单继承。
但一个类可以实现多个接口，间接地实现了多继承。接口就是一系列方
‘拾’ 工作一到五年的Java程序员遇到瓶颈应该如何提升
工作了5年的Java程序员，该如何提升,做了3~5年Java开发，你已经积累了不少项目经验，扩宽了技术广度，也许已发力成为团队管理者。到了这个阶段，大家却常有这种感受：感觉自己卡在瓶颈进步缓慢，技术水平很难像早期一样实现大幅突破？
其实大家往往忽略了这一点——提升自己的架构认知（工作5年左右程序员必须重视架构认知的提升，这会很大程度上推动你今后的成长）。架构的本质在于面对业务场景给出优雅的解决方案，使得业务能够快速迭代和持续交付，从而达到降本增效的目标。提升架构认知高度，就像达克效应所描述的一样，要敢于从愚昧之巅跳到绝望之谷，通过爬升开悟之坡，从而达到架构认知的巅峰时刻。到达巅峰时刻也就掌握了架构背后设计的哲学，面对具体业务场景在架构层面你便能够轻松应对，以无招胜有招。
提升架构认知，要紧抓3个关键点：业务洞察力、技术视野、原创力（执行力）。
1.业务洞察力是技术战略层面的问题，在当下能够做出合理的判断，清楚公司做什么事情收益最大；
2. 技术视野即技术选型能力，是技术战术层面的问题，在清楚做什么事情后，需要进一步解决怎么做的问题，也就是能够给出合理的技术选型方案：是完全基于开源的方案，还是基于开源二次开发的方案，还是完全自研的方案；
3. 原创力（执行力）是技术落地执行层面的问题，一旦技术设计方案确定后，需要能够快速Rush完成。
这3点层层递进，最重要的是先把技术战略问题思考清楚，然后再进一步解决技术战术问题，最后是快速落地执行的问题。
工作5年左右的程序员，在原创力（执行力）层面比较有竞争力，往往欠缺技术视野以及业务洞察力。后面2点更加重要，这2点解决的是架构设计哲学问题，是架构师能够持续拥有竞争力和影响力的立身之道。
举个场景的例子来详细说明：一提到分布式锁问题，大多数人想到的方案是基于Redis的Master-Slave模式来实现。这个实现方案行不行？分布式锁本质是一个CP需求，基于Redis的实现是一个AP需求，乍一看基于Redis的实现是无法满足的。脱离业务场景来谈架构都是耍流氓。
从技术战略的需求层面来看，如果分布式锁在极端情况下获取锁的不一致，社交业务场景能够接受，那么基于Redis的实现是完全可行的。如果业务是交易场景，分布式锁在极端情况下获取锁的不一致性无法接受，那么基于Redis的实现方案是不可行的。在锁强一致性的场景下，需要采取基于CP模型的etcd等方案来实现。