精华内容
下载资源
问答
  • 最近有人聊到单向链表反转的相关问题,自己闲来无事研究一下。 先画图了解一下单向链表 看一下,一个链表有多个节点组成,每个节点指向下一个节点,最后一个的指向是null。 思路:从头节点开始设置头节的nextNode...

    最近有人聊到单向链表反转的相关问题,自己闲来无事研究一下。

    先画图了解一下单向链表

    在这里插入图片描述

    看一下,一个链表有多个节点组成,每个节点指向下一个节点,最后一个的指向是null。

    思路:从头节点开始设置头节的nextNode为null,当前节点的nextNode指向头节点,如此一来还需要定义一个nextNode来记录下一个节点,然后指针统一向右移动一位。三个重要角色:firstNode、currentNode、nextNode。

    在这里插入图片描述

    STEP 1

    设置first节的nextNode为null

    在这里插入图片描述

    STEP 2

    current节点的下一个节点指向first节点

    在这里插入图片描述

    STEP 3

    让current节点的下一个节点指向first节点,并让“指针”右移一位。
      
    current.setNextNode(firstNode);
    first  = current;
    current = next;
    next = next.getNextNode();
    

    在这里插入图片描述

    STEP 4

    以此类推,直到current的下一个节点为空(这里后面会看到)

    在这里插入图片描述

    如果while条件为 (current.getNextNode != null),此时会看到current和first是断开的,所以需要:

    current.setNextNode(firstNode);
    

    最后返回current。

    有了思路上代码

    准备一个链表节点

    public class Node {
        private int date;
    
        private Node nextNode;
    
        public int getDate() {
            return date;
        }
    
        public void setDate(int date) {
            this.date = date;
        }
    
        public Node getNextNode() {
            return nextNode;
        }
    
        public void setNextNode(Node nextNode) {
            this.nextNode = nextNode;
        }
    }
    

    构造一个链表

    Node head = new Node();
    Node node1 = new Node();
    Node node2 = new Node();
    Node node3 = new Node();
    Node node4 = new Node();
    Node tail = new Node();
    
    head.setDate(1);
    head.setNextNode(node1);
    
    node1.setDate(2);
    node1.setNextNode(node2);
    
    node2.setDate(3);
    node2.setNextNode(node3);
    
    node3.setDate(4);
    node3.setNextNode(node4);
    
    node4.setDate(5);
    node4.setNextNode(tail);
    
    tail.setDate(6);
    tail.setNextNode(null);
    

    遍历链表

    Node temp = head;
    while (temp != null){
        System.out.print(temp.getDate() + " -> ");
        temp = temp.getNextNode();
    }
    

    反转链表

    public static Node revert(Node head){
      	// 惯性的校验参数
        if (head == null || head.getNextNode() == null) {
            return head;
        }
      	// 定义三个重要角色
        Node firstNode = head;			  // 记录头节点的位置
        Node current = head.getNextNode();// 记录当前节点的位置
        Node next = current.getNextNode();// 记录下一个节点的位置
    		// 设置头节点指向null
        firstNode.setNextNode(null);
      	// 结束条件为当前节点的下一个节点不为null
        while (current.getNextNode() != null){
          	// 设置当前节点的下一个节点为firstNode
            current.setNextNode(firstNode);
          	// “指针”右移一位
            firstNode = current;
            current = next;
            next = next.getNextNode();
        }
      	// 现在当前节点的下一个节点还是指向null的,所以设置
        current.setNextNode(firstNode);
        return current;
    }
    

    完整代码

    public class ConvertNodeTest {
    
        public static void main(String[] args) {
            
            Node head = new Node();
            Node node1 = new Node();
            Node node2 = new Node();
            Node node3 = new Node();
            Node node4 = new Node();
            Node tail = new Node();
    
            head.setDate(90);
            head.setNextNode(node1);
            node1.setDate(63);
            node1.setNextNode(node2);
            node2.setDate(984);
            node2.setNextNode(node3);
            node3.setDate(35);
            node3.setNextNode(node4);
            node4.setDate(76);
            node4.setNextNode(tail);
            tail.setDate(53);
            tail.setNextNode(null);
            // 反转前遍历
            Node temp = head;
            while (temp != null){
                System.out.print(temp.getDate() + " -> ");
                temp = temp.getNextNode();
            }
            System.out.println();
            // 反转后遍历
            Node revert = revert(head);
            Node temp2 = revert;
            while (temp2 != null){
                System.out.print(temp2.getDate() + " -> ");
                temp2 = temp2.getNextNode();
            }
        }
    
        public static Node revert(Node head){
            // 惯性的校验参数
            if (head == null || head.getNextNode() == null) {
                return head;
            }
            // 定义三个重要角色
            Node firstNode = head;         // 记录头节点的位置
            Node current = head.getNextNode();// 记录当前节点的位置
            Node next = current.getNextNode();// 记录下一个节点的位置
            // 设置头节点指向null
            firstNode.setNextNode(null);
            // 结束条件为当前节点的下一个节点不为null
            while (current.getNextNode() != null){
                // 设置当前节点的下一个节点为firstNode
                current.setNextNode(firstNode);
                // “指针”右移一位
                firstNode = current;
                current = next;
                next = next.getNextNode();
            }
            // 现在当前节点的下一个节点还是指向null的,所以设置
            current.setNextNode(firstNode);
            return current;
        }
    }
    

    输出结果

    90 -> 63 -> 984 -> 35 -> 76 -> 53 -> 
    53 -> 76 -> 35 -> 984 -> 63 -> 90 -> 
    

    时间复杂度

    O(n)

    展开全文
  • 自己编的(作业),感觉比较适合那些找作业(大学生)的人用。txt格式的
  • } //循环输出 值 for (EnumTest e : EnumTest.values()) { System.out.println(e.toString()); } .ordinal()方法。 这个方法就是从枚举类型的第一个枚举开始,依次从零开始往上递增。 上面的例子中a,b,c,d,e,f,...

    本文转载自:http://blog.csdn.net/qq_27093465/article/details/51706076 作者:李学凯

    什么时候想用枚举类型:

    有时候,在设计一个java model对象的时候,你需要一些具体的常量字符串之类的东西,这个东西又没必要跟整个项目的全局常量放在一起,就放在model的java文件里面是最合适的,那么,你可以有两种选择:

    1,在java model文件里面,定义public final static XXXX = "" ;

    这种就是全局静态变量,通过类名就可以直接访问。

    2,还是在java model 文件里面,定义个枚举类型 public enum XXXX{a,b,c,d,e,f};

    什么时候,如何使用:

    当在和前台传过来的数据或者在逻辑操作的代码里面需要去用到这个常量值去做比较的时候,就是使用枚举类型的时候。

    一般形式是: 类名.枚举类型名.单个枚举类型

    用上面的例子(假设在一个叫A的model java文件里面),

    则为A.XXXX.a.toString();

    就可以这么使用了。

    为什么要这么设计常量:

    这里有个代码的书写原则,这东西一般是没人,而且书里面也是没人跟你说的,都是代码看多了,或者,在你犯错误的时候才知道的问题。

    就是在自己的代码里面,要是想使代码很规范,不被吊打,

    那么写出来的逻辑代码里面是不应该出现常量字符串和常量数字之类的东西。

    例如代码里面出现数字:100,8,

    或者其他的数字,

    字符串如:只要是在逻辑代码里面带引号的。

    这些代码,你写出来虽然在功能上是没有问题的,但是,这些都是隐藏的炸弹。

    好的代码,是不会出现这个问题的。这些东西都应该被定义成一个常量,然后再在其他地方使用。

    类似c语言里面的宏定义的感觉。

    不然在很久之后,忽然有些地方的值换了,只需要修改一处地方,整个项目都不用担心会出问题,

    但是,如果你没有这么干,那么,没人知道你在逻辑代码里面还有这样的常量存在。

    那么代码就会出现美妙的后果。

    然后就炸了。

    怎么循环一个枚举类型。

    枚举有一个方法,values(),

    使用形式如: int length = XXXX.values().length

    返回的是一个类型与枚举类型一致的数组。

    然后就可以循环这个数组。

    就是循环枚举类型了。

    public enum EnumTest {

    MON, TUE, WED, THU, FRI, SAT, SUN;

    }

    //循环输出 值

    for (EnumTest e : EnumTest.values()) {

    System.out.println(e.toString());

    }

    .ordinal()方法。

    这个方法就是从枚举类型的第一个枚举开始,依次从零开始往上递增。

    上面的例子中a,b,c,d,e,f,依次对应 为数字 ,0,1,2,3,4,5

    形式:A.XXXX.a.ordinal();

    这么个方式调用。

    创建枚举类型要使用 enum 关键字,隐含了所创建的类型都是 java.lang.Enum 类的子类(java.lang.Enum 是一个抽象类)其中的方法和属性如下图:

    enum 对象的常用方法介绍int compareTo(E o) 比较此枚举与指定对象的顺序。Class getDeclaringClass()返回与此枚举常量的枚举类型相对应的 Class 对象。String name() 返回此枚举常量的名称,在其枚举声明中对其进行声明。int ordinal() 返回枚举常量的序数(它在枚举声明中的位置,其中初始常量序数为零)。String toString()返回枚举常量的名称,它包含在声明中。static > T valueOf(Class enumType, String name)返回带指定名称的指定枚举类型的枚举常量。

    展开全文
  • 遍历法查找元素x的下标 用for循环将i从1~n依次遍历,当a[i]==x时,记录下标j=i,若当i>n时,j仍然未被赋值,则输出0 设计 for (i = 1; i <= n; i++) { if (x == a[i]) { j = i; //当a[i]==x时,...

    问题

    在一个排好序的数组T[1…n]中查找x,如果x在T中,输出x在T的下标j;如果x不在T中,输出j=0

    解析

    遍历法查找元素x的下标
    用for循环将i从1~n依次遍历,当a[i]==x时,记录下标j=i,若当i>n时,j仍然未被赋值,则输出0

    设计

    for (i = 1; i <= n; i++) {
    	if (x == a[i]) {
    		j = i;  //当a[i]==x时,记录下标j=i
    		break;
    	}
    }
    

    分析

    查找元素x的下标时复杂度为O(j),而0<=j<=n,所以复杂度为:
    在这里插入图片描述

    源码

    github源码地址
    https://github.com/loadin61/cuddly-memory

    展开全文
  • 遍历法 将所要查找的数与数组中从第一个元素开始进行比较,若遍历完数组所有元素都没有与要找的的元素相同,则数组中不存在这个数;若在遍历中,有相同的元素存在,则存在这个数。 因为进行比较是一个不断重复的...

    通过C语言来实现数组元素的查找

    查找数组元素,如果找到了,就输出它的下标,找不到的话就输出“找不到这个数”

    遍历法

    将所要查找的数与数组中从第一个元素开始进行比较,若遍历完数组所有元素都没有与要找的的元素相同,则数组中不存在这个数;若在遍历中,有相同的元素存在,则存在这个数。

    因为进行比较是一个不断重复的过程,所以这里用循环

    #include<stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int i;
    	int k = 6;       //所要查找的元素k
    	for (i = 0; i < 10; i++)
    	{
    		if (k==arr[i])
    		{
    			printf("这个数的下标是%d\n", i);
    			break;      //找到之后直接跳出循环
    		}
    	}
    	if (10 == i)    //如果遍历完整个数组都未找到时,跳出循环后i的值就已经是1了
    	{
    		printf("找不到这个数\n");
    	}
    }

    运行结果:

    但因为遍历法它的计算复杂度太高(复杂度最高为N),我们一般采用折半法/二分法来实现(复杂度最高为Log2  N)(N为数组元素个数)

    实现代码如下

    #include<stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int k = 3;
        int size = sizeof(arr) / sizeof(arr[0]);   //计算数组元素个数
    	int left = 0;
    	int right = size - 1;       //最右边元素下标
    	int mid;                    //中间元素下标
    	while (left <= right)
    	{
    	    mid = (left + right) / 2;
    		if (arr[mid] > k)
    		{
    			right = mid - 1;
    		}
    		else if (arr[mid] < k)
    		{
    			left = mid + 1;
    		}
    		else
    		{
    			printf("这个数的下标是%d\n", mid);
    			break;
    		}
    	}
    	if (left > right)         //在left与right发生交叉,即left>right时说明没有找到
    	{
    		printf("找不到这个数\n");
    	}
    	return 0;
    }

    运行结果:

    用二分法查找,每次都将查找范围缩小一半,效率较高

     

     

    展开全文
  • 求树的最大宽度(层次遍历法

    千次阅读 2017-07-21 08:57:37
    二叉树宽度:使用队列,层次遍历二叉树。在上一层遍历完成后,下一...用一个变量len来记录当前层的结点数,出一个结点就len–,len==0的时候就退出循环,然后又把队列中的节点数赋值给len int getWidth(BiNode head) {
  • 如果让一个人反复做一件相同或相似的事情,他会感到厌烦与疲倦...for 循环写一个求 1 至给定的整数 n 的和的例子来说明 for 循环的用法。sum = 0;n = input('Please enter the number n: ');for i = 1: nsum = sum ...
  • 文章目录一、最大子序列和?二、四种方法?1.暴力搜索2.分支法3.动态规划4....一、最大子序列和? 最大子序列和是指,给定一组序列,如 [-...def solu1(A):#暴力循环O(n^3) s=0 for i in range(len(A)): for j in rang
  • java经典面试题:单链表反转问题,有两种方法,一种为循环遍历法,一种递归法。 1、循环遍历法  首先设置三个节点,把当前节点的下一节点指向它前面的节点,此时你会发现指针链会断,所以要先把它后面一个节点用...
  • 一、 前言“JSON对象合并”是前端开发和 NodeJS 环境开发中非常常见的操作。开发者通常会通过循环遍历或一些库封装的方法或 ... 方法一:循环遍历法functionextend() {var length =arguments.length;if(length == ...
  • 拿到这道题的 第一个想法就是,双层循环遍历法,找出所有可能的组合,求出面积,然后比较,最终求出最大的面积。下面是具体的代码 class Solution{ public int maxArea(int[] height){ int max = 0; int area =...
  • 方法1:循环遍历法 这个方法耗时耗力 主要思想是运用两个循环逐一比较 不建议撰写 方法2:set大法 def unique(string): if string is None: return False return len(set(string)) == len(string) 两种情况:为...
  • 1:循环遍历法,分为遍历key-value键值对和遍历所有key两种形式 2:使用Linq查询法 1 private void GetDictKeyByValue() 2 { 3 Dictionary<int, string> dict = new Dictionary<int, string>()...
  • 对字符串的各种操作

    2018-09-19 21:04:24
    1.截取一个字符串中的一部分 String类的substring()方法,有两种,substring(int index)参数是开始截取的位置,截取之后的字符串, substring(int beginindex,int endindex)两个参数一个是开始处...//for循环遍历法...
  • Python 字符串与列表去重

    千次阅读 2019-06-26 22:42:00
    最近面试中出现频率比较高的字符串和列表的去重pstr = 'abcadcf'# 字符串去重# 1、使用集合 --没有保持原来的顺序 ...# 3、使用循环遍历法 -- 代码不够简洁,不高端 a = [] for i in range...
  • 去重 第一种方法 lists = [1,2,3,4,2,3,4] print(list(set(lists))) 第二种办法 #使用字典 -- 没有保持原来的顺序 ...#使用循环遍历法 -- 代码不够简洁,不高端 lists = [1,2,3,4,2,3,4] list1 = [] for i in li
  • 一、循环遍历法(传统思路) 最简单粗暴的算法,新建一个空数组,然后遍历原数组,将不在新数组中的项添加到新数组,最后返回新数组 function compare(arr){ var newarr=[];//新建空数组 for(var i...
  • 定义差集: A,B是两个集合,所有属于A且不属于B的元素构成的集合, 就是差集。交集: A,B是两个集合,既属于A又属于B的元素构成的集合, 就是交集。并集: A,B是两个集合,把他们所有的... 循环遍历法ret=[]fori...
  • 定义差集: A,B是两个集合,所有属于A且不属于B的元素构成的集合, 就是差集。交集: A,B是两个集合,既属于A又属于B的元素构成的集合, 就是交集。并集: A,B是两个集合,把他们所有的... 循环遍历法ret=[]fori...
  • 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转...方法一:循环遍历法(暴力求解) 根据旋转数组的特性,数组中突然变小的数字必为最小。若无则返回第一个数字 class Solution { public int minAr
  • shell编程:for 循环

    2017-05-09 13:59:00
    hell 编程——for in 循环 -------for in 格式------- for无$变量in字符串 ...一简单的字符串 枚举遍历法,利用for in格式对字符串按空格切份的功能 SERVICES="80222511080002320213306...

空空如也

空空如也

1 2 3 4 5
收藏数 97
精华内容 38
关键字:

循环遍历法