devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java经典算法题_java算法题

作者：小蓝xlanll | 2024-04-15 16:35:01

赞

踩

java算法题

目录

1.Java多线程：写一下两个线程交替打印 0~100 的奇偶数

2.线程安全的单例模式

3.用两个栈实现队列

4.实现单链表反转操作

5.Java实现二分查找

6.冒泡排序

7.快速排序

快速排序的基本思想：

8.Java单链表实现快速排序

9.二叉树的前序遍历

10.二叉树的中序遍历

11.二叉树的后序遍历

12.java实现逆波兰表达式

13.斐波那契数列及青蛙跳台阶问题

1.Java多线程：写一下两个线程交替打印 0~100 的奇偶数

这种实现方式的原理就是线程1打印之后唤醒其他线程，然后让出锁，自己进入休眠状态。因为进入了休眠状态就不会与其他线程抢锁，此时只有线程2在获取锁，所以线程2必然会拿到锁。线程2以同样的逻辑执行，唤醒线程1并让出自己持有的锁，自己进入休眠状态。这样来来回回，持续执行直到任务完成。就达到了两个线程交替获取锁的效果了。

  1. private int count = 0;
  2. private final Object lock = new Object();
  3.  
  4. public void turning() throws InterruptedException {
  5.    Thread even = new Thread(() -> {
  6.        while (count <= 100) {
  7.            synchronized (lock) {
  8.                System.out.println("偶数: " + count++);
  9.                lock.notifyAll();
  10.                try {
  11.                	   // 如果还没有结束，则让出当前的锁并休眠
  12.                    if (count <= 100) {
  13.                        lock.wait();
  14.                    }
  15.                } catch (InterruptedException e) {
  16.                    e.printStackTrace();
  17.                }
  18.            }
  19.        }
  20.    });
  21.    Thread odd = new Thread(() -> {
  22.        while (count <= 100) {
  23.            synchronized (lock) {
  24.                System.out.println("奇数: " + count++);
  25.                lock.notifyAll();
  26.                try {
  27.                    // 如果还没有结束，则让出当前的锁并休眠
  28.                    if (count <= 100) {
  29.                        lock.wait();
  30.                    }
  31.                } catch (InterruptedException e) {
  32.                    e.printStackTrace();
  33.                }
  34.            }
  35.        }
  36.    });
  37.    even.start();
  38.    // 确保偶数线程线先获取到锁
  39.    Thread.sleep(1);
  40.    odd.start();
  41. }

2.线程安全的单例模式

双锁判断机制创建单例模式

  1. public class DoubleCheckLockSinglenon {
  2.  
  3.     private static volatile DoubleCheckLockSinglenon doubleCheckLockSingleon = null;
  4.  
  5.     public DoubleCheckLockSinglenon(){}
  6.  
  7.  
  8.  
  9.     public static DoubleCheckLockSinglenon getInstance(){
  10.         if (null == doubleCheckLockSingleon) {
  11.             synchronized(DoubleCheckLockSinglenon.class){
  12.                 if(null == doubleCheckLockSingleon){
  13.                     doubleCheckLockSingleon = new DoubleCheckLockSinglenon();
  14.                 }
  15.             }
  16.         }
  17.         return doubleCheckLockSingleon;
  18.     }
  19.  
  20.  
  21.     public static void main(String[] args) {
  22.         System.out.println(DoubleCheckLockSinglenon.getInstance());
  23.  
  24.     }
  25.  
  26. }

3.用两个栈实现队列

题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

解题思路
两个栈stack1和stack2 。
开始时，每次添加队尾元素到stack1中。
如果需要弹出队头元素，则将stack1中的元素弹出并push到stack2中，再将stack2的栈顶元素弹出，即为弹出了队头元素。
如果stack2中是非空的，再在队尾中添加元素的时候仍然加到stack1中，从stack2中弹出队头元素。
只有当stack2为空的时候，弹出队头元素才需要将stack1中的元素转移到stack2中。

  1. import java.util.Stack;
  2.  
  3. public class Solution {
  4.     Stack<Integer> stack1 = new Stack<Integer>();
  5.     Stack<Integer> stack2 = new Stack<Integer>();
  6.     
  7.     public void push(int node) {
  8.         stack1.push(node);
  9.     }
  10.     
  11.     public int pop() {
  12.         if(stack2.size() == 0) {
  13.             while(!stack1.isEmpty()) {
  14.                 int temp = stack1.peek();
  15.                 stack2.push(temp);
  16.                 stack1.pop();
  17.             }
  18.         }
  19.         int res = stack2.peek();
  20.         stack2.pop();
  21.         return res;
  22.     }
  23. }

4.实现单链表反转操作

 单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。在Java中定义如下：

  1. public class Node {
  2.     
  3.     private Object data;//数据域
  4.     private Node next;//指针域
  5.  
  6.     public Node(Object data){
  7.         this.data = data;
  8.     }
  9.  
  10.     public Node(Object data,Node next){
  11.         this.data = data;
  12.         this.next = next;
  13.     }
  14.  
  15.     public Object getData() {
  16.         return data;
  17.     }
  18.  
  19.     public void setData(Object data) {
  20.         this.data = data;
  21.     }
  22.  
  23.     public Node getNext() {
  24.         return next;
  25.     }
  26.  
  27.     public void setNext(Node next) {
  28.         this.next = next;
  29.     }
  30.  
  31. }

先说下思路：所谓的单链表反转，就是把每个节点的指针域由原来的指向下一个节点变为指向其前一个节点。但由于单链表没有指向前一个节点的指针域，因此我们需要增加一个指向前一个节点的指针pre，用于存储每一个节点的前一个节点。此外，还需要定义一个保存当前节点的指针cur，以及下一个节点的next。定义好这三个指针后，遍历单链表，将当前节点的指针域指向前一个节点，之后将定义三个指针往后移动，直至遍历到最后一个节点停止。
 

  1. public static Node reverseListNode(Node head){
  2.         //单链表为空或只有一个节点，直接返回原单链表
  3.         if (head == null || head.getNext() == null){
  4.             return head;
  5.         }
  6.         //前一个节点指针
  7.         Node preNode = null;
  8.         //当前节点指针
  9.         Node curNode = head;
  10.         //下一个节点指针
  11.         Node nextNode = null;
  12.  
  13.         while (curNode != null){
  14.             nextNode = curNode.getNext();//nextNode 指向下一个节点
  15.             curNode.setNext(preNode);//将当前节点next域指向前一个节点
  16.             preNode = curNode;//preNode 指针向后移动
  17.             curNode = nextNode;//curNode指针向后移动
  18.         }
  19.  
  20.         return preNode;
  21.     }

5.Java实现二分查找

二分查找又称折半查找，查找效率不错

适用场景：顺序存储结构且按有序排列，这也是它的缺点。

  1.     /*
  2.      *递归实现二分算法
  3.      */
  4.     public static int binSearch_2(int key,int[] array,int low,int high){
  5.         //防越界
  6.         if (key < array[low] || key > array[high] || low > high) {
  7.             return -1;
  8.         }
  9.         int middle = (low+high)/2;
  10.         if(array[middle]>key){
  11.             //大于关键字
  12.             return  binSearch_2(key,array,low,middle-1);
  13.         }else if(array[middle]<key){
  14.             //小于关键字
  15.             return binSearch_2(key,array,middle+1,high);
  16.         }else{
  17.             return array[middle];
  18.         }
  19.     }

6.冒泡排序

N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数，即

  1. /*
  2.  * 冒泡排序
  3.  */
  4. public class BubbleSort {
  5. 　　public static void main(String[] args) {
  6. 　　　　int[] arr={6,3,8,2,9,1};
  7. 　　　　System.out.println("排序前数组为：");
  8. 　　　　for(int num:arr){
  9. 　　　　　　System.out.print(num+" ");
  10. 　　　　}
  11. 　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
  12. 　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
  13. 　　　　　　　　if(arr[j]>arr[j+1]){
  14. 　　　　　　　　　　int temp=arr[j];
  15. 　　　　　　　　　　arr[j]=arr[j+1];
  16. 　　　　　　　　　　arr[j+1]=temp;
  17. 　　　　　　　　}
  18. 　　　　　　}
  19. 　　　　} 
  20. 　　　　System.out.println();
  21. 　　　　System.out.println("排序后的数组为：");
  22.  　　　　for(int num:arr){
  23.  　　　　　　System.out.print(num+" ");
  24.  　　　　} 
  25. 　　}
  26.  }

用时间复杂度来说：

　　1.如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。

　　2.如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为：O(n2) 。

综上所述：冒泡排序总的平均时间复杂度为：O(n2) 。

7.快速排序

快速排序的基本思想：

  1. 1). 先从数列中取出一个数作为基准数。
  2. 2). 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
  3. 3). 再对左右区间重复第二步，直到各区间只有一个数。
  1. public class Main {
  2.     //快排实现方法
  3.     public static void quickRow(int[] array,int low,int high) {
  4.         int i,j,pivot;
  5.         //结束条件
  6.         if(low >= high) {
  7.             return;
  8.         }
  9.         i = low;
  10.         j = high;
  11.         //选择的节点，这里选择的数组的第一数作为节点
  12.         pivot = array[low];
  13.         while(i<j) {
  14.             //从右往左找比节点小的数，循环结束要么找到了，要么i=j
  15.             while(array[j] >= pivot && i<j) {
  16.                 j--;
  17.             }
  18.             //从左往右找比节点大的数，循环结束要么找到了，要么i=j
  19.             while(array[i] <= pivot && i<j) {
  20.                 i++;
  21.             }
  22.             //如果i!=j说明都找到了，就交换这两个数
  23.             if(i<j) {
  24.                 int temp = array[i];
  25.                 array[i] = array[j];
  26.                 array[j] = temp;
  27.             }
  28.         }
  29.         //i==j一轮循环结束，交换节点的数和相遇点的数
  30.         array[low] = array[i];
  31.         array[i] = pivot;
  32.         //数组“分两半”,再重复上面的操作
  33.         quickRow(array,low,i-1);
  34.         quickRow(array,i+1,high);
  35.     }
  36.     public static void main(String[] args) {
  37.         int[] array = {6,17,38,59,2,10};
  38.         int low = 0,high = array.length-1;
  39.         quickRow(array,low,high);
  40.         for (int i : array){
  41.             System.out.println(i);
  42.         }
  43.     }
  44. }

8.Java单链表实现快速排序

单链表的实现为：
（1）使第一个节点为中心点
（2）创建2个指针(p，q)，p指向头结点，q指向p的下一个节点
（3）q开始遍历,如果发现q的值比中心点的值小，则此时p=p->next，并且执行当前p的值和q的值交换，q遍历到链表尾即可
（4）把头结点的值和p的值执行交换。此时p节点为中心点,并且完成1轮快排
（5）使用递归的方法即可完成排序

  1. public static void main(String[] args) {
  2.         ListNode head = new ListNode(2);
  3.         ListNode l1 = new ListNode(2);
  4.         ListNode l2 = new ListNode(5);
  5.         ListNode l3 = new ListNode(3);
  6.         ListNode l4 = new ListNode(8);
  7.         ListNode l5 = new ListNode(4);
  8.         ListNode l6 = new ListNode(2);
  9.         ListNode l7 = new ListNode(1);
  10.  
  11.         /*ListNode p = l1;
  12.         System.out.println(p.equals(head));
  13.         System.out.println(p == head);*/
  14.  
  15.         head.next = l1;
  16.         l1.next = l2;
  17.         l2.next = l3;
  18.         l3.next = l4;
  19.         l4.next = l5;
  20.         l5.next = l6;
  21.         l6.next = l7;
  22.         l7.next = null;
  23.  
  24.         ListNode p = head;
  25.         while (p.next != null) {
  26.             System.out.print(p.val);
  27.             p = p.next;
  28.         }
  29.         System.out.print(p.val);
  30.         System.out.println();
  31.  
  32.         ListNode begin = head, end = p;
  33.         new SingleLinkedListSorting().quickSort(begin, end);
  34.  
  35.         p = head;
  36.         while (p != null) {
  37.             System.out.print(p.val);
  38.             p = p.next;
  39.         }
  40. }
  41.  
  42. public void quickSort(ListNode begin, ListNode end) {
  43.         //判断为空，判断是不是只有一个节点
  44.         if (begin == null || end == null || begin == end)
  45.             return;
  46.         //从第一个节点和第一个节点的后面一个几点
  47.         ListNode first = begin;
  48.         ListNode second = begin.next;
  49.  
  50.         int nMidValue = begin.val;
  51.         //结束条件，second到最后了
  52.         while (second != end.next && second != null) {
  53.             if (second.val < nMidValue) {
  54.                 first = first.next;
  55.                 //判断一下，避免后面的数比第一个数小，不用换的局面
  56.                 if (first != second) {
  57.                     int temp = first.val;
  58.                     first.val = second.val;
  59.                     second.val = temp;
  60.                 }
  61.             }
  62.             second = second.next;
  63.         }
  64.         //判断，有些情况是不用换的，提升性能
  65.         if (begin != first) {
  66.             int temp = begin.val;
  67.             begin.val = first.val;
  68.             first.val = temp;
  69.         }
  70.         //前部分递归
  71.         quickSort(begin, first);
  72.         //后部分递归
  73.         quickSort(first.next, end);
  74.     }

9.二叉树的前序遍历

  前序遍历（DLR，lchild,data,rchild），是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右。前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。

  1. package test;
  2. //前序遍历的递归实现与非递归实现
  3. import java.util.Stack;
  4. public class Test 
  5. {
  6. 	public static void main(String[] args)
  7. 	{
  8. 		TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
  9. 		for(int i = 0; i < 10; i++)
  10. 		{
  11. 			node[i] = new TreeNode(i);
  12. 		}
  13. 		for(int i = 0; i < 10; i++)
  14. 		{
  15. 			if(i*2+1 < 10)
  16. 				node[i].left = node[i*2+1];
  17. 			if(i*2+2 < 10)
  18. 				node[i].right = node[i*2+2];
  19. 		}
  20. 		
  21. 		preOrderRe(node[0]);
  22. 	}
  23. 	
  24. 	public static void preOrderRe(TreeNode biTree)
  25. 	{//递归实现
  26. 		System.out.println(biTree.value);
  27. 		TreeNode leftTree = biTree.left;
  28. 		if(leftTree != null)
  29. 		{
  30. 			preOrderRe(leftTree);
  31. 		}
  32. 		TreeNode rightTree = biTree.right;
  33. 		if(rightTree != null)
  34. 		{
  35. 			preOrderRe(rightTree);
  36. 		}
  37. 	}
  38. 	
  39. 	public static void preOrder(TreeNode biTree)
  40. 	{//非递归实现
  41. 		Stack<TreeNode> stack = new Stack<TreeNode>();
  42. 		while(biTree != null || !stack.isEmpty())
  43. 		{
  44. 			while(biTree != null)
  45. 			{
  46. 				System.out.println(biTree.value);
  47. 				stack.push(biTree);
  48. 				biTree = biTree.left;
  49. 			}
  50. 			if(!stack.isEmpty())
  51. 			{
  52. 				biTree = stack.pop();
  53. 				biTree = biTree.right;
  54. 			}
  55. 		}
  56. 	}
  57. }
  58.  
  59. class TreeNode//节点结构
  60. {
  61. 	int value;
  62. 	TreeNode left;
  63. 	TreeNode right;
  64. 	
  65. 	TreeNode(int value)
  66. 	{
  67. 		this.value = value;
  68. 	}
  69. }
  70.  
  71.

10.二叉树的中序遍历

中序遍历（LDR）是 二叉树遍历的一种，也叫做 中根遍历、中序周游。在二叉树中，先左后根再右。巧记：左根右。

  1. import java.util.Stack;
  2. public class Test 
  3. {
  4. 	public static void main(String[] args)
  5. 	{
  6. 		TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
  7. 		for(int i = 0; i < 10; i++)
  8. 		{
  9. 			node[i] = new TreeNode(i);
  10. 		}
  11. 		for(int i = 0; i < 10; i++)
  12. 		{
  13. 			if(i*2+1 < 10)
  14. 				node[i].left = node[i*2+1];
  15. 			if(i*2+2 < 10)
  16. 				node[i].right = node[i*2+2];
  17. 		}
  18. 		
  19. 		midOrderRe(node[0]);
  20. 		System.out.println();
  21. 		midOrder(node[0]);
  22. 	}
  23. 	
  24. 	public static void midOrderRe(TreeNode biTree)
  25. 	{//中序遍历递归实现
  26. 		if(biTree == null)
  27. 			return;
  28. 		else
  29. 		{
  30. 			midOrderRe(biTree.left);
  31. 			System.out.println(biTree.value);
  32. 			midOrderRe(biTree.right);
  33. 		}
  34. 	}
  35. 	
  36. 	
  37. 	public static void midOrder(TreeNode biTree)
  38. 	{//中序遍历费递归实现
  39. 		Stack<TreeNode> stack = new Stack<TreeNode>();
  40. 		while(biTree != null || !stack.isEmpty())
  41. 		{
  42. 			while(biTree != null)
  43. 			{
  44. 				stack.push(biTree);
  45. 				biTree = biTree.left;
  46. 			}
  47. 			if(!stack.isEmpty())
  48. 			{
  49. 				biTree = stack.pop();
  50. 				System.out.println(biTree.value);
  51. 				biTree = biTree.right;
  52. 			}
  53. 		}
  54. 	}
  55. }
  56.  
  57. class TreeNode//节点结构
  58. {
  59. 	int value;
  60. 	TreeNode left;
  61. 	TreeNode right;
  62. 	
  63. 	TreeNode(int value)
  64. 	{
  65. 		this.value = value;
  66. 	}
  67. }
  68.  
  69.

11.二叉树的后序遍历

后序遍历（LRD）是 二叉树遍历的一种，也叫做 后根遍历、后序周游，可记做左右根。后序遍历有 递归算法和非递归算法两种。在二叉树中，先左后右再根。巧记：左右根。

  1. import java.util.Stack;
  2. public class Test 
  3. {
  4. 	public static void main(String[] args)
  5. 	{
  6. 		TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
  7. 		for(int i = 0; i < 10; i++)
  8. 		{
  9. 			node[i] = new TreeNode(i);
  10. 		}
  11. 		for(int i = 0; i < 10; i++)
  12. 		{
  13. 			if(i*2+1 < 10)
  14. 				node[i].left = node[i*2+1];
  15. 			if(i*2+2 < 10)
  16. 				node[i].right = node[i*2+2];
  17. 		}
  18. 		
  19. 		postOrderRe(node[0]);
  20. 		System.out.println("***");
  21. 		postOrder(node[0]);
  22. 	}
  23. 	
  24. 	
  25. 	
  26. 	public static void postOrderRe(TreeNode biTree)
  27. 	{//后序遍历递归实现
  28. 		if(biTree == null)
  29. 			return;
  30. 		else
  31. 		{
  32. 			postOrderRe(biTree.left);
  33. 			postOrderRe(biTree.right);
  34. 			System.out.println(biTree.value);
  35. 		}
  36. 	}
  37. 	
  38. 	public static void postOrder(TreeNode biTree)
  39. 	{//后序遍历非递归实现
  40. 		 LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
  41.         // 指向上一个被访问的节点
  42.         TreeNode pre = null;
  43.         while(biTree!=null || !stack.isEmpty()){
  44.             // 遍历到左下
  45.             while(biTree!=null){
  46.                 stack.push(biTree);
  47.                 biTree = biTree.left;
  48.             }
  49.  
  50.             biTree = stack.pop();
  51.             if(biTree.right==null || biTree.right == pre){
  52.                 System.out.println(biTree.value);
  53.                 pre = biTree;
  54.                 // 保证了不会再次遍历已经遍历过的左子树
  55.                 biTree= null;
  56.             }else{
  57.                 stack.push(biTree);
  58.                 biTree= biTree.right;
  59.             }
  60.         }
  61. 	}
  62. }
  63.  
  64. class TreeNode//节点结构
  65. {
  66. 	int value;
  67. 	TreeNode left;
  68. 	TreeNode right;
  69. 	
  70. 	TreeNode(int value)
  71. 	{
  72. 		this.value = value;
  73. 	}
  74. }
  75.

12.java实现逆波兰表达式

逆波兰表达式把运算量写在前面,把算符写在后面。

  1.  private static List<String> sign=new ArrayList<>();
  2.  
  3.     static {
  4.         sign.add("+");
  5.         sign.add("-");
  6.         sign.add("*");
  7.         sign.add("/");
  8.     }
  9.  
  10.     public static void main(String[] args) {
  11.         String[] arrs={"2", "1", "+", "3", "*"};
  12.         System.out.println(evalRPN(arrs));  //9
  13.  
  14.         String[] arrs1={"4", "13", "5", "/", "+"};
  15.         System.out.println(evalRPN(arrs1));  //6
  16.  
  17.     }
  18.  
  19.     public static int evalRPN(String[] tokens) {
  20.         Stack<Integer> mathStack=new Stack<>();
  21.         for (int i = 0; i <tokens.length ; i++) {
  22.             String s=tokens[i];
  23.             if(sign.contains(s)){
  24.                 Integer sum=0;
  25.                 Integer num2=mathStack.pop();
  26.                 Integer num1=mathStack.pop();
  27.                 if("+".equals(s)){
  28.                     sum=num1+num2;
  29.                 }else if("-".equals(s)){
  30.                     sum=num1-num2;
  31.                 }else if("*".equals(s)){
  32.                     sum=num1*num2;
  33.                 }else if("/".equals(s)){
  34.                     sum=num1/num2;
  35.                 }
  36. //                System.out.println(num1+s+num2+"="+sum);
  37.                 mathStack.push(sum);
  38.             }else {
  39.                 mathStack.push(Integer.parseInt(s));
  40.             }
  41.         }
  42.  
  43.         return mathStack.pop();
  44.     }

13.斐波那契数列及青蛙跳台阶问题

递归方式：

  1. public int Fibonacci1(int n) {
  2.         if (n <= 0) return 0;
  3.         if (n == 1) return 1;
  4.         return Fibonacci1(n-1) + Fibonacci1(n - 2);
  5.     }

非递归：

  1. public int Fibonacci2(int n) {
  2.         if (n <= 0) return 0;
  3.         if (n == 1) return 1;
  4.         int i=0;int j=1;
  5.         int res=0;
  6.         for(int x=2;x<=n;x++){
  7.             res =  i+j;
  8.             i=j;
  9.             j=res;
  10.         }
  11.         return res;
  12.     }

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号