稳扎稳打，可攻可守。没抓在手里的成功都是不算的。

1.删除重复的数字

/*** 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。* <p>* 示例 1:* 输入: 1->1->2* 输出: 1->2* <p>* 示例 2:* 输入: 1->1->2->3->3* 输出: 1->2->3*/

链表结构

public class ListNode {int val;ListNode next;ListNode(int x) {val = x;}}

做过类似的题，只是现在换了一种数据结构。最笨的办法，取出所有值，存入LinkHashSet,然后由于它没有下标，还得存入List里面然后循环拼接

    public ListNode method2(ListNode head) {if (head==null||head.next==null)return head;LinkedHashSet<Integer> integerHashSet=new LinkedHashSet<>();while (head != null){integerHashSet.add(head.val);head=head.next;}ArrayList<ListNode> listNodes=new ArrayList<>();for (int i:integerHashSet){listNodes.add(new ListNode(i));}ListNode listNode=listNodes.get(0);ListNode temp=listNode;for (int i=1;i<listNodes.size();i++){listNode.next=listNodes.get(i);listNode=listNode.next;}return temp;}

上面这种写法真的很恶心，那另一种放法就比较人性化了，如果当前节点的下一个节点等于当前节点，那就让当前节点的下一个节点等于下下个节点。

public ListNode method1(ListNode head) {ListNode temp = head;while (temp != null){if (temp.next == null){break;}if (temp.next.val == temp.val){temp.next = temp.next.next;}else {temp = temp.next;}}return head;}

2.合并

/***给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。** 说明:*     初始化 nums1 和 nums2 的元素数量分别为 m 和 n。*     你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。** 示例:* 输入:* nums1 = [1,2,3,0,0,0], m = 3* nums2 = [2,5,6],       n = 3* 输出: [1,2,2,3,5,6]*/

第一种思路，先把第二个数组并到第一个数组中去，然后使用排序算法进行排序

冒泡排序，比较简单比较慢

public static void method1(int[] nums1, int m, int[] nums2, int n) {for (int i:nums2){nums1[m++]=i;}int c;for (int i=0;i<nums1.length-1;i++){for (int j=i+1;j<nums1.length;j++){if (nums1[i]>nums1[j]){c=nums1[i];nums1[i]=nums1[j];nums1[j]=c;}}}}

快速排序，比较麻烦比较快，数越多显得越快

public static void method2(int[] nums1, int m, int[] nums2, int n) {for (int i:nums2){nums1[m++]=i;}if(nums1.length<2)return;quickSort(nums1,0,nums1.length-1);}public static void quickSort(int[] arr,int low,int high){int i,j,temp,t;if(low>high){return;}i=low;j=high;//temp就是基准位temp = arr[low];while (i<j) {//先看右边，依次往左递减while (temp<=arr[j]&&i<j) {j--;}//再看左边，依次往右递增while (temp>=arr[i]&&i<j) {i++;}//如果满足条件则交换if (i<j) {t = arr[j];arr[j] = arr[i];arr[i] = t;}}//最后将基准为与i和j相等位置的数字交换arr[low] = arr[i];arr[i] = temp;//递归调用左半数组quickSort(arr, low, j-1);//递归调用右半数组quickSort(arr, j+1, high);}

但是无论快速排序怎么快，它的复杂度也掉不到N，因为给定的两个数组都是有序数组且第一个数组的长度可以包含第二个数组，要求排成从小到大的，那我们可以从大到小排列，从数组尾排到数组头。这样一遍循环便完事了。

public static void method3(int[] nums1, int m, int[] nums2, int n) {int i = m-1;int j = n-1;int k = m+n-1;while(i>=0&&j>=0){if(nums1[i]>nums2[j]){nums1[k--] = nums1[i--];}else{nums1[k--] = nums2[j--];}}while(j>=0){nums1[k--] = nums2[j--];}}

3.相同的树

/*** 给定两个二叉树，编写一个函数来检验它们是否相同。** 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。** 示例 1:** 输入:       1         1*           / \       / \*          2   3     2   3**         [1,2,3],   [1,2,3]** 输出: true** 示例 2:** 输入:      1          1*           /           \*          2             2**         [1,2],     [1,null,2]** 输出: false** 示例 3:** 输入:       1         1*           / \       / \*          2   1     1   2**         [1,2,1],   [1,1,2]** 输出: false*/

树的结构

public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }}

该题我的第一个想法是把两颗数分别存到两个数组中，然后比较两个数组是否相等，但我发现这种方法很难实现而且复杂无比，遍历树的时候还要添加null节点，然后想到了递归，可以使用递归解决此问题，不断比较想同位置上的值，相同继续比较左右子树，不同返回false。

public static boolean method1(TreeNode p,TreeNode q){if (p == null && q == null) {return true;} else if (p == null) {return false;} else if (q == null) {return false;} else if (p.val != q.val) {return false;}return method1(p.left, q.left) && method1(p.right, q.right);}

简化判断流程

public static boolean method2(TreeNode p,TreeNode q){if(p==null && q==null){return true;}if(p!=null && q!=null && p.val==q.val  ){return method2(p.left,q.left) && method2(p.right,q.right);}else {return false;}}

再次简化

public static boolean method3(TreeNode p,TreeNode q){if(p == null) return q == null;if(q == null||p.val!=q.val) return false;return method3(p.left,q.left)&&method3(p.right,q.right);}

4.对称的树

/*** 给定一个二叉树，检查它是否是镜像对称的。** 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。**     1*    / \*   2   2*  / \ / \* 3  4 4  3** 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:**     1*    / \*   2   2*    \   \*    3    3** 说明:* 如果你可以运用递归和迭代两种方法解决这个问题，会很加分。*/

树的结构

public class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }}

思想和上一题一样，前面做一些判断，后面递归比较对称位置

public boolean method1(TreeNode root) {if (root==null)return true;if (root.left==null) return root.right==null;if (root.right==null||root.left.val!=root.right.val)return false;return isSame(root.left,root.right);}public static boolean isSame(TreeNode p, TreeNode q){if(p == null) return q == null;if(q == null||p.val!=q.val) return false;return isSame(p.left,q.right)&&isSame(p.right,q.left);}

JAVA入门算法题（十）相关推荐

JAVA入门算法题（三）
把敬业变成习惯.短期来看是为了雇主,长期来看是为了自己. 1.题目:输入一行字符,分别统计出其中英文字母.空格.数字和其它字符的个数. 估计统计字符是所有人都做过的题这里给出两种思路,第一种思路是比 ...
【精选】JAVA入门算法题（五）
把敬业变成习惯.短期来看是为了雇主,长期来看是为了自己. 1.题目:重复的字符串 /*** 给定一个非空的字符串,判断它是否可以由它的一个子串重复多次构成.给定的字符串只含有小写英文字母,并且长度不超 ...
【精选】JAVA入门算法题（四）
把敬业变成习惯.短期来看是为了雇主,长期来看是为了自己. 1.题目:全排列问题这种问题在算法题中应用很多,主要思路是使用递归来求,求n个数的全排列就是把第一个数固定后求n-1个数的全排列,不断递归到 ...
JAVA入门算法题（十四）
一.最小的淘气值题目: /*** 老师要给学生安排座位,经统计教室有N个双人桌,M名学生,每个学生有一个淘气值,* 要合理安排座位,使得班内同桌之和的淘气值最大值尽可能的小,输出最小值.*/ 这是一 ...
JAVA入门算法题（十五）
一.满二叉搜索树 /*** 给定一个二叉树的层序遍历判断是不是一颗满二叉搜索树*/ 大致分为这么几步: 1.处理输入 2.根据满二叉树的节点数量进行排除 3.构建树 4.递归判断 public sta ...
JAVA入门算法题（十二）
一.最大利润题目: /***给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格.* 如果你最多只允许完成一笔交易(即买入和卖出一支股票),设计一个算法来计算你所能获取的最大利润.* 注意 ...
JAVA入门算法题（十三）
一.出现一次的数题目: /*** 给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次.找出那个只出现了一次的元素.* 说明:* 你的算法应该具有线性时间复杂度. 你可以不使用额 ...
JAVA入门算法题（九）
交会修理你的朋友.这种朋友正是你人生的导师. 1.加一 /***给定一个由整数组成的非空数组所表示的非负整数,在该数的基础上加一.* 最高位数字存放在数组的首位, 数组中每个元素只存储一个数字.* 你 ...
JAVA入门算法题（八）
有志者自有千计万计,无志者只感千难万难. 1.报数序列 /*** 报数序列是一个整数序列,按照其中的整数的顺序进行报数,得到下一个数.其前五项如下:* 1. 1* 2. 11* 3. 21* 4. 1 ...

JAVA入门算法题（十）

1.删除重复的数字

2.合并

3.相同的树

4.对称的树

JAVA入门算法题（十）相关推荐

最新文章

热门文章