Java 数据结构

最新推荐文章于 2022-08-06 18:03:21 发布
最新推荐文章于 2022-08-06 18:03:21 发布
阅读量81 收藏
点赞数
文章标签： java 数据结构与算法 后端
原文链接：http://www.cnblogs.com/Mr-Feng/p/11379810.html
版权

数字求和运算

以下实例演示了使用do...while结构求0~100的整数数字之和：

public class Main {
    public static void main(String[] args) {
        int limit=100;
        int sum=0;
        int i=1;
        do
        {
            sum=sum+i;
            i++;
        }
        while(i<=limit);
        System.out.println("sum="+sum);
    }
}
View Code

利用堆栈将中缀表达式转换成后缀表达式

以下实例演示了如何使用堆栈进行表达式的堆栈将中缀（Infix）表达式转换成后缀（postfix）表达式：

  
import java.io.IOException;
 
public class InToPost {
   private Stack theStack;
   private String input;
   private String output = "";
   public InToPost(String in) {
      input = in;
      int stackSize = input.length();
      theStack = new Stack(stackSize);
   }
   public String doTrans() {
      for (int j = 0; j < input.length(); j++) {
         char ch = input.charAt(j);
         switch (ch) {
            case '+': 
            case '-':
            gotOper(ch, 1); 
            break; 
            case '*': 
            case '/':
            gotOper(ch, 2); 
            break; 
            case '(': 
            theStack.push(ch);
            break;
            case ')': 
            gotParen(ch); 
            break;
            default: 
            output = output + ch; 
            break;
         }
      }
      while (!theStack.isEmpty()) {
         output = output + theStack.pop();
      }
      System.out.println(output);
      return output; 
   }
   public void gotOper(char opThis, int prec1) {
      while (!theStack.isEmpty()) {
         char opTop = theStack.pop();
         if (opTop == '(') {
            theStack.push(opTop);
            break;
         }
         else {
            int prec2;
            if (opTop == '+' || opTop == '-')
            prec2 = 1;
            else
            prec2 = 2;
            if (prec2 < prec1) { 
               theStack.push(opTop);
               break;
            }
            else
            output = output + opTop;
         }
      }
      theStack.push(opThis);
   }
   public void gotParen(char ch){ 
      while (!theStack.isEmpty()) {
         char chx = theStack.pop();
         if (chx == '(') 
         break; 
         else
         output = output + chx; 
      }
   }
   public static void main(String[] args) 
   throws IOException {
      String input = "1+2*4/5-7+3/6";
      String output;
      InToPost theTrans = new InToPost(input);
      output = theTrans.doTrans(); 
      System.out.println("Postfix is " + output + '\n');
   }
   class Stack {
      private int maxSize;
      private char[] stackArray;
      private int top;
      public Stack(int max) {
         maxSize = max;
         stackArray = new char[maxSize];
         top = -1;
      }
      public void push(char j) {
         stackArray[++top] = j;
      }
      public char pop() {
         return stackArray[top--];
      }
      public char peek() {
         return stackArray[top];
      }
      public boolean isEmpty() {
         return (top == -1);
     }
   }
}
View Code

以上代码运行输出结果为：

 

124*5/+7-36/+
Postfix is 124*5/+7-36/+
View Code

在链表（LinkedList）的开头和结尾添加元素

以下实例演示了如何使用 LinkedList 类的 addFirst() 和 addLast() 方法在链表的开头和结尾添加元素：

  
import java.util.LinkedList;
 
public class Main {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("1");
        lList.add("2");
        lList.add("3");
        lList.add("4");
        lList.add("5");
        System.out.println(lList);
        lList.addFirst("0");
        System.out.println(lList);
        lList.addLast("6");
        System.out.println(lList);
    }
}
View Code

以上代码运行输出结果为：

 

1, 2, 3, 4, 5
0, 1, 2, 3, 4, 5
0, 1, 2, 3, 4, 5, 6
View Code

获取链表（LinkedList）的第一个和最后一个元素

以下实例演示了如何使用 LinkedList 类的 linkedlistname.getFirst() 和 linkedlistname.getLast() 来获取链表的第一个和最后一个元素：

  
import java.util.LinkedList;
 
public class Main {
    public static void main(String[] args) {
        LinkedList<String> lList = new LinkedList<String>();
        lList.add("100");
        lList.add("200");
        lList.add("300");
        lList.add("400");
        lList.add("500");
        System.out.println("链表的第一个元素是：" + lList.getFirst());
        System.out.println("链表的最后一个元素是：" + lList.getLast());
    }
}
View Code

以上代码运行输出结果为：

 

链表的第一个元素是：100
链表的最后一个元素是：500
View Code

删除链表中的元素

以下实例演示了使用 clear() 方法来删除链表中的元素：

  
import java.util.*;
 
public class Main {
   public static void main(String[] args) {
      LinkedList<String> lList = new LinkedList<String>();
      lList.add("1");
      lList.add("8");
      lList.add("6");
      lList.add("4");
      lList.add("5");
      System.out.println(lList);
      lList.subList(2, 4).clear();
      System.out.println(lList);
   }
}
View Code

以上代码运行输出结果为：

 

[1, 8, 6, 4, 5]
[1, 8, 5]
View Code

获取链表的元素

以下实例演示了使用 top() 和 pop() 方法来获取链表的元素：

  
import java.util.*;
 
public class Main {
   private LinkedList list = new LinkedList();
   public void push(Object v) {
      list.addFirst(v);
   }
   public Object top() {
      return list.getFirst();
   }
   public Object pop() {
      return list.removeFirst();
   }
   public static void main(String[] args) {
      Main stack = new Main();
      for (int i = 30; i < 40; i++)
         stack.push(new Integer(i));
      System.out.println(stack.top());
      System.out.println(stack.pop());
      System.out.println(stack.pop());
      System.out.println(stack.pop());
   }
}
View Code

以上代码运行输出结果为：

 

39
39
38
37
View Code

获取向量元素的索引值

以下实例演示了使用 Collections 类的 sort() 方法对向量进行排序并使用 binarySearch() 方法来获取向量元素的索引值：

  
import java.util.Collections;
import java.util.Vector;
 
public class Main {
   public static void main(String[] args) {
      Vector v = new Vector();
      v.add("X");
      v.add("M");
      v.add("D");
      v.add("A");
      v.add("O");
      Collections.sort(v);
      System.out.println(v);
      int index = Collections.binarySearch(v, "D");
      System.out.println("元素索引值为 : " + index);
   }
}
View Code

以上代码运行输出结果为：

 

[A, D, M, O, X]
元素索引值为 : 1
View Code

 

栈的实现

以下实例演示了用户如何通过创建用于插入元素的自定义函数 push() 方法和用于弹出元素的 pop() 方法来实现栈：

  
public class MyStack {
   private int maxSize;
   private long[] stackArray;
   private int top;
   public MyStack(int s) {
      maxSize = s;
      stackArray = new long[maxSize];
      top = -1;
   }
   public void push(long j) {
      stackArray[++top] = j;
   }
   public long pop() {
      return stackArray[top--];
   }
   public long peek() {
      return stackArray[top];
   }
   public boolean isEmpty() {
      return (top == -1);
   }
   public boolean isFull() {
      return (top == maxSize - 1);
   }
   public static void main(String[] args) {
      MyStack theStack = new MyStack(10); 
      theStack.push(10);
      theStack.push(20);
      theStack.push(30);
      theStack.push(40);
      theStack.push(50);
      while (!theStack.isEmpty()) {
         long value = theStack.pop();
         System.out.print(value);
         System.out.print(" ");
      }
      System.out.println("");
   }
}
View Code

以上代码运行输出结果为：

 

50 40 30 20 10
View Code

链表元素查找

以下实例演示了使用 linkedlistname.indexof(element) 和 linkedlistname.Lastindexof(elementname) 方法在链表中获取元素第一次和最后一次出现的位置：

import java.util.LinkedList;
 
public class Main {
   public static void main(String[] args) {
      LinkedList lList = new LinkedList();
      lList.add("1");
      lList.add("2");
      lList.add("3");
      lList.add("4");
      lList.add("5");
      lList.add("2");
      System.out.println("元素 2 第一次出现的位置：" + lList.indexOf("2"));
      System.out.println("元素 2 最后一次出现的位置："+ lList.lastIndexOf("2"));
   }
}
View Code

压栈出栈的方法实现字符串反转

以下实例演示了使用用户自定义的方法 StringReverserThroughStack() 来实现字符串反转：

  
import java.io.IOException;
 
public class StringReverserThroughStack {
   private String input; 
   private String output;
   public StringReverserThroughStack(String in) {
      input = in;
   }
   public String doRev() {
      int stackSize = input.length(); 
      Stack theStack = new Stack(stackSize); 
      for (int i = 0; i < input.length(); i++) {
         char ch = input.charAt(i); 
         theStack.push(ch); 
      }
      output = "";
      while (!theStack.isEmpty()) {
         char ch = theStack.pop(); 
         output = output + ch; 
      }
      return output;
   }
   public static void main(String[] args) 
   throws IOException {
      String input = "www.w3cschool.cc";
      String output;
      StringReverserThroughStack theReverser = 
      new StringReverserThroughStack(input);
      output = theReverser.doRev();
      System.out.println("反转前： " + input);
      System.out.println("反转后： " + output);
   }
   class Stack {
      private int maxSize;
      private char[] stackArray;
      private int top;
      public Stack(int max) {
         maxSize = max;
         stackArray = new char[maxSize];
         top = -1;
      }
      public void push(char j) {
         stackArray[++top] = j;
      }
      public char pop() {
         return stackArray[top--];
      }
      public char peek() {
         return stackArray[top];
      }
      public boolean isEmpty() {
         return (top == -1);
      }
   }
}
View Code

队列（Queue）用法

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。

LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

以下实例演示了队列（Queue）的用法：

import java.util.LinkedList;
import java.util.Queue;
 
public class Main {
    public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }
}
View Code

获取向量的最大元素

以下实例演示了使用 Vector 类的 v.add() 方法及 Collection 类的 Collections.max() 来获取向量的最大元素：

  
import java.util.Collections;
import java.util.Vector;
 
public class Main {
   public static void main(String[] args) {
      Vector v = new Vector();
      v.add(new Double("3.4324"));
      v.add(new Double("3.3532"));
      v.add(new Double("3.342"));
      v.add(new Double("3.349"));
      v.add(new Double("2.3"));
      Object obj = Collections.max(v);
      System.out.println("最大元素是："+obj);
   }
}
View Code

链表修改

以下实例演示了使用 listname.add() 和 listname.set() 方法来修改链接中的元素：

  
import java.util.LinkedList;
 
public class Main {
   public static void main(String[] a) {
      LinkedList officers = new LinkedList();
      officers.add("B");
      officers.add("B");
      officers.add("T");
      officers.add("H");
      officers.add("P");
      System.out.println(officers);
      officers.set(2, "M");
      System.out.println(officers);
   }
}
View Code

以上代码运行输出结果为：

 

[B, B, T, H, P]
[B, B, M, H, P]
View Code

旋转向量

以下实例演示了使用 swap() 函数来旋转向量：

  
import java.util.Collections;
import java.util.Vector;
 
public class Main {
   public static void main(String[] args) {
      Vector<String> v = new Vector();
      v.add("1");
      v.add("2");
      v.add("3");
      v.add("4");
      v.add("5");
      System.out.println(v);
      Collections.swap(v, 0, 4);
      System.out.println("旋转后");
      System.out.println(v);
   }
}
View Code

 

转载于:https://www.cnblogs.com/Mr-Feng/p/11379810.html

weixin_30847271
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java-demo:普通的Java演示
04-06
java-demo normal java demo 用来演示github action，手动执行以下命令可以构建镜像： cd demowebapp && mkdir -p build/dependency && (cd build/dependency; jar -xf ../libs/*.jar) mkdir -p demowebapp/build/dependency && (cd demowebapp/build/dependency; jar -xf ../libs/*.jar) cd demowebapp && docker build -t springio/demowebapp-docker . && cd .. 启动命令如下： docker run --rm -p 8080:8080 springio/demowebapp-docker
Java基础 超详细（4）
A1435900388的博客
02-17 347
String类的使用及常用发方法
1.java基础学习笔记
qq_50790795的博客
01-18 162
1：java 1Helloworld .java中必须有一个类包括public static void main(String arg[])方法，这个类是程序的主类，arg[]是main方法的一个参数，是一个字符串类型的数组。 public class Hello { public static void main(String arg[]){ System.out.println("大家好"); System.out.println("nice to meet yo
JAVA练习--第四章第一次作业
仙王狂虐战神
03-26 1万+
下面程序运行的结果是( ) class Demo{ public static void main(String[] args){ try{ int x = div(1,2); }catch(Exception e){ System.out.println(e); } System.out.println(x) } public static int div(int a,int b){ retur...
Java基础类库
m0_52596096的博客
03-04 679
StringBuffer类 作用：实现字符串内容的修改 构造方法：public StringBuffer() 构造方法：public StringBuffer(String str),可以接受字符串初始化内容 数据追加：public StringBuffer append(数据类型 变量)，相当于字符串中的“+”操作 public class Demo { public static void main(String[] args) { StringBuffer buf = ne
java数据结构全套
04-09
《Java数据结构全套》是针对Java编程语言深入学习数据结构的重要资源集合，涵盖了从基本概念到高级应用的全面知识体系。这个压缩包包含了四部分关键内容：叶核亚编著的《数据结构（Java版）（第3版）》电子教案、...
java 数据结构 PPT课件
07-25
第2章 线性表(java版） 第3章 栈与队列(java版） 第4章 串与数组(Java版) 第5章 树与二叉树(java版） 第6章 图(Java版) 第7章 排序(Java版) 第8章 查找(Java版)
Java数据结构和Java算法
08-22
本套Java课程采用理论与实践并重的方式，讲练结合，帮助学员更牢固地对所学知识进行掌握Java数据结构与算法。课程内容全面，涉及Java数据结构和Java算法的各个方面，包括数组、链表、递归、队列、栈、堆、二叉树、...
Java 数据结构详细教程
最新发布
12-21
JavaJava 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java 数据结构详细教程Java ...
java中String类详解
qq_49529322的博客
01-17 348
String类 这里对java中的String(字符串)类做一个详解! String 字符串类: 代码引入: public class Demo1 { public static void main(String[] args) { String str1 = "hello"; String str2 = "hello"; String str3 = new String("hello"); String str4 = new String("hello"); System
java基礎04
qq_44423114的博客
09-15 249
循环__判断语句 语句结构 顺序结构 分支结构 循环结构 分支结构 单if语句 if-else语句 多重if语句 嵌套if语句 switch语句 单if语句 例： 需求: 张三Java成绩大于98分，而且音乐成绩大于80分，老师奖励他苹果； 或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他还是苹果。 Java成绩大于98分，而且音乐成绩大于80分 ...
Java基础练习题2
qq_51733711的博客
05-05 1054
今天再来更新一期Java基础的练习题，今天的题更多的是关于循环或者是利用循环去解决的，当然也可以使用其他方法，但是我们今天的重点是使用循环。话不多说，让我们进入今天的练习叭。 看程序写结果 1.写出输出结果 class Demo{ public static void main(String[] args){ Demo.show(0); Demo.show(1); } public static void ...
Java练习题: Demo01 - Demo31
weixin_52058789的博客
03-19 615
public class Demo01{ public static void main(String[] args){ System.out.println((9.5 * 4.5 - 2.5 * 3) / (45.5 - 3.5)); } } public class Demo02{ public static void main(String[] args){ System.out.println(4 * (1.0 - 1.0 / 3 + 1.
Java基础Demo
weixin_45180536的博客
07-24 1288
Demo 01 public class Demo1 { public static void main(String[] args) { //二元运算符 int a = 10; int b = 20; int c = 25; int d = 25; System.out.println(a+b); System.out.println(a-b); System.out.
Java之集合(15个demo)
nuist_NJUPT的博客
08-06 1318
本节主要介绍java的集合，主要包括List、Set和Map，其中List的子类ArrayList和LinkedList，Set的子类HashSet和TreeSet，Map的字类HashMap等，介绍了集合的常用方法，Collections工具类以及Comparable和Comparator排序方法,同时介绍了泛型和集合的嵌套使用等。...
Java——18个Demo带你玩转Java中的I/O流
★★光亭★★
06-02 7755
Java——18个Demo带你玩转Java中的I/O流
Java 23种设计模式Demo案例大全 ☞ 【已完结】
热门推荐
Appleyk的专栏
11-06 11万+
注：已经延期好久好久了，从去年11月份到今年8月份，卧槽，不敢想啊，博主真是没时间整啊，太忙没时间？那都是借口，主要是坚持很难，我尽量有时间续更下！这个必须完成，太TM经典了，必须完成！！！ 俗话说，古有<孙子兵法>，掌握之，能打胜仗也，今有<23种设计模式代码案列大全>，学习之，能敲出骇世惊俗的代码；不信吗，若不信的话，那是你没有真正掌握其中的思想精髓； ...
一个demo学会java
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
10-01 1万+
全栈工程师开发手册 （作者：栾鹏） 快捷链接： java系列教程1-数据库操作全解 java系列教程2-IO数据流全解 java系列教程3-网络协议全解 java系列教程4-web服务全解 java系列教程5-网络安全全解 java系列教程6-系统操作全解 java系列教程7-jsp全解 java系列教程8-数据结构全解 java系列教程9-算法全解 java系列教程10-DOM
深入探索Java数据结构与算法
"Java数据结构和算法相关学习资料与资源" 在深入探讨Java数据结构和算法之前，首先要明白数据结构和算法的重要性。数据结构是组织和存储数据的方式，它直接影响到程序的效率和可读性。而算法是解决问题的步骤或过程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值