数据结构学习

二叉树

//结点类
public class BiNode<T> {
    T data;
    BiNode<T> lchild, rchild;

    public BiNode(T d, BiNode<T> lch, BiNode<T> rch) {
        this.data = d;
        this.lchild = lch;
        this.rchild = rch;
    }

    public BiNode(T d) {
        this(d, null, null);
    }
}

//树类
public class BiTree<T> {
    BiNode<T> root;
    public BiTree(){
       this.root=null;
    }
    private int i=0;
    public BiNode<T> create(T[] preList){
        BiNode<T> p=null;
        if (i< preList.length){
            T elem=preList[i];
            i++;
            if (elem!=null){
                p=new BiNode<T>(elem);
                p.lchild=create(preList);
                p.rchild=create(preList);
            }
        }
        return p;
    }
    public BiTree(T[] preList){
        root=create(preList);
    }
    //先序遍历
    public void DLR(BiNode<T> p){
        if (p!=null){
            System.out.print(p.data);
            DLR(p.lchild);
            DLR(p.rchild);
        }
    }
    //中序
    public void LDR(BiNode<T> p){
        if (p!=null){
            LDR(p.lchild);
            System.out.print(p.data);
            LDR(p.rchild);
        }
    }
    //后序
    public void LRD(BiNode<T> p){
        if (p!=null){
            LRD(p.lchild);
            LRD(p.rchild);
            System.out.print(p.data);
        }
    }
}

//测试类
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        BiTree<Character> tree;
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入二叉树的先序排列：");
        String s=sc.next();
        Character[] preList=new Character[s.length()];
        for (int i = 0; i < preList.length; i++) {
            if (s.charAt(i)=='#')
                preList[i]=null;
            else
                preList[i]=s.charAt(i);
        }
        tree=new BiTree<Character>(preList);
        System.out.print("先序遍历序列为：");
        tree.DLR(tree.root);
        System.out.println();
        System.out.print("中序遍历序列为：");
        tree.LDR(tree.root);
        System.out.println();
        System.out.print("后序遍历序列为：");
        tree.LRD(tree.root);
        System.out.println();
    }
}

哈希表查询

查询时要注意要查询文档的路径，并确定文档中有数据

import java.io.*;
import java.util.StringTokenizer;
//学生类
class Stu {
    String id;
    String name;

    public Stu(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String toString() {
        return id.toString() + "\t" + name.toString();
    }
}
//哈希表类
class HashTable {
    Stu[] HT;
    int p;

    public HashTable(int m) {
        HT = new Stu[m];
        for (int i = 0; i < m; i++) {
            HT[i] = null;
            setP();
        }
    }

    public void setP() {
        int i;
        for (int p = HT.length; p > 1; p--) {
            for (i = 2; i < p / 2 && p % i != 0; i++) ;
            if (i >= p / 2) {
                this.p = p;
                break;
            }

        }
    }

    public int hash(String id) {
        int len = id.length();
        return (id.charAt(len - 1) - '0' + (id.charAt(len - 2) - '0') * 10 + (id.charAt(len - 3) - '1') * HT.length / 2) % p;
    }

    public void createTable(String filename) {
        try {
            BufferedReader br = new BufferedReader(new FileReader(filename));
            String s = br.readLine();
            while (s != null) {
                StringTokenizer r = new StringTokenizer(s);
                String id = r.nextToken();
                String name = r.nextToken();
                int addr = hash(id);
                if (HT[addr] == null) {
                    HT[addr] = new Stu(id, name);
                } else {
                    for (int i = 1; i < HT.length; i++) {
                        int Hi = (addr + i) % HT.length;
                        if (HT[Hi] == null) {
                            HT[Hi] = new Stu(id, name);
                            break;
                        }
                    }
                }
                s = br.readLine();
            }
        } catch (IOException e) {
            System.out.println("文件访问异常" + e);
            e.printStackTrace();
        }

    }
    public int searchTable(String id){
        int addr=hash(id);
        if (HT[addr]!=null&&HT[addr].id.equals(id))
            return addr;
        else if(HT[addr]==null)
            return -1;
        else {
            for (int i = 1; i < HT.length; i++) {
                int Hi=(addr+i)%HT.length;
                if (HT[Hi]!=null&&HT[Hi].id.equals(id))
                    return Hi;
                else if(HT[Hi]==null)
                    return -1;
            }
            return -1;
        }
    }
    public void print(int d){
        System.out.println(HT[d]);
    }
    public void printTable(){
        for (int i = 0; i < HT.length; i++) {
            System.out.print(i+":");
            print(i);
        }
    }
}
测试类
public class Test {
    public static void main(String[] args) {
        HashTable t=new HashTable(96);
        t.createTable("E:\\java\\javaProject\\suanfa\\src\\学生");
        t.printTable();
        String id;
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                System.out.println("请输入要查找的学号:");
                id = br.readLine();
                int addr = t.searchTable(id);
                if (addr == -1) {
                    System.out.println("记录不存在");
                } else {
                    System.out.print(addr + "单元：");
                    t.print(addr);
                }
                System.out.println("是否继续查找？Y/N");
                String ch = br.readLine();
                if (ch.equalsIgnoreCase("N"))
                    break;
            }
        }catch (IOException e){
            System.out.println("输入异常"+e);
            e.printStackTrace();
        }
    }
}

图的遍历

import java.util.Scanner;
//图类
public class AMGraph<T> {
     static final int maxVexNum=20;
     T[] vexs;//顶点数组
    int[][] arcs;//边数组，即邻接矩阵
    int vexNum;
    int arcNum;
    boolean[] visited;
    public AMGraph(){
        vexs= (T[]) new Object[maxVexNum];
        arcs=new int[maxVexNum][maxVexNum];
        for (int i = 0; i < maxVexNum; i++) {
            for (int j = 0; j < maxVexNum; j++) {
                arcs[i][j]=0;
            }
        }
        vexNum=0;
        arcNum=0;
    }
    public int locateVex(T v){
        for (int i = 0; i < vexNum; i++) {
            if (v==vexs[i]){
                return i;
            }
        }
        return -1;
    }
    public void createAdj(){
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入顶点数和边数：");
        vexNum=sc.nextInt();
        arcNum= sc.nextInt();;
        System.out.print("请输入"+vexNum+"个顶点的值：");
        String str= sc.next();
        for (int i = 0; i < vexNum; i++) {
            vexs[i] = (T)(Object)str.charAt(i);
        }
        for (int k = 1; k <=arcNum ; k++) {
            System.out.print("请输入第"+k+"条边的两个顶点：");
            str=sc.next();
            T v1=(T)(Object)str.charAt(0);
            T v2=(T)(Object)str.charAt(1);
            int i=locateVex(v1);
            int j=locateVex(v2);
            if (i==-1||j==-1){
                System.out.println("顶点"+v1+"或"+v2+"不存在");
                k--;
            }else {
                arcs[i][j]=arcs[j][i]=1;
            }
        }

    }
    public void DFS(int v){
        System.out.print(vexs[v]+" ");
        visited[v]=true;
        for (int j = 0; j < vexNum; j++) {
            if (arcs[v][j]==1&& !visited[j]){
                DFS(j);
            }
        }
    }
    public void DFSTraverse(){
        visited=new boolean[vexNum];
        for (int i = 0; i < vexNum; i++) {
            visited[i]=false;
        }
        for (int v = 0; v < vexNum; v++) {
            if (!visited[v])DFS(v);
        }
    }
    public void BFS(int v){
        SequenceQueue<Integer> q = new SequenceQueue<Integer>();
        System.out.print(this.vexs[v]+" ");
        visited[v] = true;
        q.enQueue(v);
        while(!q.isEmpty())
        {
            int w = q.deQueue();
            for(int j = 0; j< this.vexNum; j++)
            {
                if(this.arcs[w][j]==1 && !visited[j])
                {
                    System.out.print(this.vexs[j]+" ");
                    visited[j] = true;
                    q.enQueue(j);
                }
            }
        }
    }
    public void BFSTraverse(){
        visited = new boolean[maxVexNum];
        for(int v=0;v<this.vexNum;v++) visited[v]=false;
        for(int v=0;v<this.vexNum;v++)
            if(!visited[v]) BFS(v);
    }
}

//队列类，存储图结点，边的信息
class SequenceQueue<T>{
    static final int defaultSize=10;
    T[] queueArray;
    int front;
    int	rear;

    public SequenceQueue(int size)
    {
        queueArray = (T[])new Object[size];
        front = rear = 0;
    }
    public SequenceQueue()
    {
        this(defaultSize);
    }
    public void enQueue(T x)
    {
        if ( (rear+1) %  queueArray.length ==  front  )
        { //׷�ӿռ�
            T[] p = (T[]) new Object [queueArray.length*2] ;
            int j=0;
            for(int i = this.front ; i!=this.rear; i=(i+1) % queueArray.length)
                p[j++] = queueArray [i];
            queueArray=p;
            this.front = 0; this.rear = j;
        }
        queueArray [rear] = x;
        rear = (rear + 1 ) %  queueArray.length;
    }
    public T deQueue()
    {
        if ( this.front == this.rear )   return null;
        T x= queueArray [front ] ;
        front=(front+1) % queueArray.length ;
        return x;
    } // DeQueue
    public boolean isEmpty()
    {
        return front==rear;
    }

}

//测试类
public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AMGraph<Character> g=new AMGraph<>();
        g.createAdj();
        System.out.print("深度优先遍历的结果为：");
        g.DFSTraverse();
        System.out.println();
        System.out.print("广度优先遍历的结果为：");
        g.BFSTraverse();
    }
}