Java

• • • 稀疏数组
    • 队列
    • 单链表
    • 双链表
    • 约瑟夫环
    • 栈，栈实现计算器
    • 前缀表达式
    • 中缀表达式
    • 后缀表达式
    • 逆波兰计算器的实现
    • 递归
    • 迷宫回溯
    • 八皇后
    • 排序算法基础
    • 冒泡排序
    • 选择排序
    • 插入排序
    • 希尔排序
    • 快速排序
    • 归并排序
    • 基数排序
    • 各种排序的比较
    • 二叉排序树
    • 删除一颗树的节点
    • 二叉平衡树
    • 图
    • 图的深度优先和广度优先
    • 动态规划
    • 暴力匹配和KMP算法
    • 贪心算法

package 稀疏数组;

public class SparseArray {
    public static void main(String[] args) {
        int[][] array=ShuZu();
        int sum=0;
//        获取有效数据的个数:
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                if (array[i][j]!=0){
                    sum++;
                }
            }
        }
//        创建一个二维数组来存放数据 行和列 值
        int[][] arr=new int[sum+1][3];
        arr[0][0]=11;
        arr[0][1]=11;
        arr[0][2]=sum;

//        遍历原先的数组，把非0的数放入到稀疏数组中；
        int a =1;
        int b =0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j]!=0){

                   arr[a][b]=i;
                   arr[a][b+1]=j;
                   arr[a][b+2]=array[i][j];
                   a++;
                    }
                }
            }

//       新的数组
        System.out.println("-------------新的的二维数组--------------");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
                System.out.print(" ");
            }
            System.out.println();

    }
//    还原二维数组
        int[][] newarray=new int[arr[0][0]][arr[0][0]];
        for (int i = 1; i  
队列 
package 队列;

import java.util.Scanner;

public class 数组模拟环形队列 {
    public static void main(String[] args) {
        aa aa = new aa();
        aaa:
        for (; ; ) {
            System.out.println("----------###菜单栏###----------");
            System.out.println("----------1 存数据 -----------");
            System.out.println("----------2 取数据 ----------");
            System.out.println("----------3 显数据 ---------");
            System.out.println("----------4 退出   ------------");
            int bb = new Scanner(System.in).nextInt();
            switch (bb) {
                case 1:
                    aa.add();
                    break;
                case 2:
                    aa.get();
                    break;
                case 3:
                    aa.show();
                    break;
                case 4:
                    System.out.println("退出成功...");
                    break aaa;
                default:
                    System.out.println("你的输入有误...");

            }
        }


    }
}

class aa {
    int[] array = new int[4];
    int maxsize = array.length;
    int start = 0;
    int end = 0;


    //    判断是否为空
    public boolean isempty() {
        return start == end;
    }

    //    判断队列是否已满
    public boolean isfull() {
//        利用取余来判断是否满了
        return (end + 1) % maxsize == start;
    }

    //    添加数据
    public void add() {
        if (isfull()) {
            System.out.println("数据已经满了...");
        } else {
            System.out.println("输入你要存入的数据..");
            int num = new Scanner(System.in).nextInt();
            array[end] = num;
            end = (end + 1) % maxsize;
        }
    }

    //    显示数据
    public void show() {
        if (isempty()) {
            System.out.println("列表为空...");
        } else {
            for (int i = start; i < start + size(); i++) {
                System.out.printf("array[%d]=%dn", i % maxsize, array[i % maxsize]);
            }
        }
    }

    //    取出数据
    public void get() {
        if (isempty()) {
            System.out.println("你的列表为空，无法取出...");
        } else {
            int n = array[start];
            start = (start + 1) % maxsize;
            System.out.println("取出的数是：" + n);
        }
    }

    //    获取有效数据的个数
    public int size() {
        return (end + maxsize - start) % maxsize;
    }
}

 
单链表 
双链表 
约瑟夫环 
栈，栈实现计算器 
前缀表达式 
中缀表达式 
后缀表达式 
逆波兰计算器的实现 
递归 
迷宫回溯 
八皇后 
排序算法基础 
冒泡排序 
选择排序 
插入排序 
希尔排序 
快速排序 
归并排序 
基数排序 
各种排序的比较 
二叉排序树 
删除一颗树的节点 
二叉平衡树 
图 
图的深度优先和广度优先 
动态规划 
暴力匹配和KMP算法 
贪心算法					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: https://outofmemory.cn/zaji/5581864.html