精华内容
下载资源
问答
  • 在页面中添加三个按钮,当点击按钮时,按钮的值循环发生改变。 例如三个按钮的默认值都为A,当任意点击一个按钮时,其默认值变成B,再次点击变成C,再点一次又变为A. 2.源代码:  pageEncoding="utf-8"%>...

    1.练习内容:

    在页面中添加三个按钮,当点击按钮时,按钮的值循环发生改变。
    例如三个按钮的默认值都为A,当任意点击一个按钮时,其默认值变成B,再次点击变成C,再点一次又变为A.

    2.源代码:

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <%@ page language="java" contentType="text/html; charset=utf-8"
        pageEncoding="utf-8"%>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>???????</title>
    <style type="text/css">
    input{
    height:30px;
    width:50px;
    }


    </style>
    <script type="text/javascript">
    window.οnlοad=function()
    {
    var i;
    var a=document.getElementsByTagName("input");//获取input,返回一个集合 
    var b=['a','b','c'];


    for(i=0;i<a.length;i++)
    {
    a[i].num=0;//利用for循环对每个元素自定义属性
    a[i].οnclick=function()
    {


    this.value=b[this.num]//对元素的value赋值
    this.num++;
    if(this.num==3)//进行条件判断,使元素value循环
    {
    this.num=0;
    }
    };


    }


    };




    </script>
    </head>
    <body>


    <input type="button" value="">
    <input type="button" value="">
    <input type="button" value="">
    </body>
    </html>

    展开全文
  • 先看空指针异常: List<MovieInfo> movieInfos= null; 这样创建时,list指向为空,修改方法: List<MovieInfo> movieInfos= new ArrayList<MovieInfo>(); 再看list循环赋值的问题: 问题...

    先看空指针异常:

    List<MovieInfo> movieInfos= null;

    这样创建时,list指向为空,修改方法:

    List<MovieInfo> movieInfos= new ArrayList<MovieInfo>();

    再看list循环赋值的问题:

    问题描述:

    for (i=0;i<10;i++){
                movieInfoSum.movieId = (int)recommendation.get(i).getItemID();
                movieInfoSum.movieName = movieInfos.get(i).getMovieName();
                movieInfoSum.movieType = movieInfos.get(i).getMovieType();
                movieInfoSum.value = recommendation.get(i).getValue();
                movieInfoSums.add(movieInfoSum);
            }

    这段代码在每一次循环时,都会将新的数值赋值到已保存的list中,比如,

    第一个循环结束后:

    数据正常加入,进行第二个循环过程中:

    List movieInfoSums中已存入的下标0的值改变了,经过蒙逼半天后查找资料(https://blog.csdn.net/single_cong/article/details/80560616),发现是因为值类型和引用类型没区分好的问题

    修改方法:

    for (i=0;i<10;i++){
                MovieInfoSum movieInfoSum = new MovieInfoSum();//将对象创建语句放在循环内
                movieInfoSum.movieId = (int)recommendation.get(i).getItemID();
                movieInfoSum.movieName = movieInfos.get(i).getMovieName();
                movieInfoSum.movieType = movieInfos.get(i).getMovieType();
                movieInfoSum.value = recommendation.get(i).getValue();
                movieInfoSums.add(movieInfoSum);
            }

    总结:1,List创建时不置空,2,将对象传入List时要new新的对象。

    展开全文
  • 循环链表尾指针

    千次阅读 2016-10-28 11:10:39
    循环链表-尾指针

    1 对于两个链表之间的操作非常合适

    #include "string.h"
    #include "ctype.h"
    
    #include "stdio.h"
    #include "stdlib.h"
    #include "io.h"
    #include "math.h"
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 1000 /* 存储空间初始分配量 */
    typedef int ElemType ;
    typedef int status  ;
    
    typedef struct Node{
        ElemType data;
        struct Node * next;
    }Node;
    
    typedef struct Node* LinkList;
    
    status ListEmety(LinkList L){
        if(L->next!=L){
            return OK;
        }else{
            return ERROR;
        }
    }
    
    
    status GetElem(LinkList L ,int i , ElemType *e){  //L指向头结点 L叫头指针
    
    
        int j;
        LinkList p;
        p = L->next->next;                               //p指向元素的第一个节点
        j = 1;
        while(j<i){                           // p向后移动
              p = p ->next;                          //p指向第二个节点,第三个节点。。。。
                                                     //因为i+1个节点不存在到第i+1个节点退出
              ++j;
              if(p == (L)->next);                //这里是为了防止i越界,当条件成立时说明已经到链表头了
              return ERROR;
        }
    
       // printf("%p",p);
    
        if( j>i){
            printf("p为空\n");
            return ERROR;
        }
    
        *e = p->data;
    
    }
    
    
    status ListInsert(LinkList *L , int i, ElemType e){  //这里可以改成LinkList L
                                                         //因为这里不涉及改变L指向的变量
    
    
        int j;
        LinkList p,s;
        p = (*L)->next;//p为头指针,p指向头元素节点 从头结点开始
        j = 1;
    
              if(p == *L&&i==1){ //如果链表为空并且插入的是第一个位置
                    s = (LinkList)malloc(sizeof(Node));
                    s->data = e ;
                    s->next = *L;
                    (*L)->next = s;
                    *L = s;
                    return 1;
                }
    
    
        while(j<i){//j<i是控制到i-1个位置
            p = p->next;
            ++j;
            if(p == (*L)->next)//这里是为了防止i越界,当条件成立时说明已经到链表头了
            return ERROR;
        }
    
    
    
    
        if(j>i){   // j>i是防止出现i=0的情况
           printf("%d\n",p->data);
           return ERROR;
        }
    
    
    
        s = (LinkList)malloc(sizeof(Node));
        s->data = e ;
    
        s->next = p->next;
        p->next = s;
        if(p==*L) //判断假如有两个位置12,插入到第三个位置的情况
        {
            *L = s;
        }
         return OK ;
    
    }
    
    
    status InitList(LinkList *L) //注意这里使用了二级指针 不用一级指针是因为L是在栈中新开辟的元素,
                                 //和原p指向同一内存地址,而这里修改了L的指向的内存空间,但指针p还是没有变化,
                                //还造成了内存泄漏,在堆中申请的内存空间无法访问
    {
        *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
        if(!(*L)) /* 存储分配失败 */
        return ERROR;
        (*L)->next=*L; /* 指针域为自己*/
        return OK;
    }
    
    
    status ListDelete(LinkList *L , int i , ElemType *e){
        ListEmety(*L);//判断链表是否为空
    
        LinkList p = (*L)->next;//头结点
        LinkList q;
        int j;
        j=1;
        while(j<i){//遍历寻找i-1个节点
            p = p->next;
            ++j;
            if(p==(*L)->next) //i越界
            return ERROR;
        }
    
        if(j>i){ //i等于0的情况
            return ERROR;
        }
    
    
    
        q = p->next;
        p->next = q->next;
    
        *e = q->data;
    
        if(q == *L) //q是最后一个节点,而L是尾指针会和q相等
         *L = p;
        free(q);
    
        return OK;
    
    
    }
    
    
    void CreateListHead(LinkList*L ,int n ){ //头插法
        LinkList p ;
        int i;
        srand(time(0));
        *L = (LinkList)malloc(sizeof(Node));
        (*L)->next =*L;
        LinkList head = (*L)->next->next;
        int count=0;
        for(i=0;i<n;i++){
            p=(LinkList)malloc(sizeof(Node));
            p->data=rand()%100+1;
            p->next = head->next;
            head->next = p;
            if(!count)
            {
                (*L) = p;//开始的第一次让L指向p,因为L是尾指针,其余清空都是插在他前面
                count = 1;
            }
        }
    
    
    }
    
    void CreateListTail(LinkList * L ,int n){
        srand(time(0));
        *L= (LinkList)malloc(sizeof(Node));
        LinkList p = *(L); //p为指向头结点(由于没有元素,尾指针也指在头节点)
    
        LinkList r;
        int i;
        for(i=0;i<n;i++){
            r = (Node *)malloc(sizeof(Node));
            r->data=rand()%100+1;
            (*L)->next = r;
            (*L) = r;
        }
        r->next = p;//(最后一个节点指向头)
    }
    
    
    status ClearList(LinkList *L){
        LinkList p,q;
        p=(*L)->next->next;
        while(p!=(*L)->next){
             q=p->next;
             free(p);
             p=q;
        }
    
        (*L) = q ;  //头节点的指针域为空
        return OK;
    }
    
    
    
    
    
    int ListLength(LinkList L){
        int i=0;
        LinkList L1;
        L1=L->next->next;
        while(L1!=L->next){ //计算长度应该循环到头节点,因为尾节点也是元素
           i++;
           L1=L1->next;
        }
        return i;
    }
    
    /* 初始条件:顺序线性表L已存在 */
    /* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */
    /* 若这样的数据元素不存在,则返回值为0 */
    int LocateElem(LinkList L,ElemType e)
    {  int i=1;
       LinkList L1;
       L1=L->next->next;
       while(L1!=L->next){
            if(L1->data == e)
            return i;
    
            L1=L1->next;
            i++;
       }
       return 0;
    }
    
    
    void unionrear(LinkList  rear1 , LinkList rear2 ){
    
    
        if(ListEmety(rear1)&&ListEmety(rear2)){
    
            LinkList p = rear1->next;
            rear1->next = rear2->next->next;
            LinkList q =rear2->next;
            rear2->next = p;
            free(q);
        }
    
    
    }
    
    int main(){
    
    //手动插入
       int e,value;
       LinkList rear;
       InitList(&rear);
       //printf("%p",p);
    
       LinkList firstNode = (LinkList)malloc(sizeof(Node));
       rear->next= firstNode;
       firstNode->next =rear;
       rear = firstNode;
       firstNode->data=12345;
       printf("%d\n",ListInsert(&rear,27,5));
       printf("%d\n",ListInsert(&rear,2,4));
    
       LinkList p;
       p=rear->next->next;
       while(p!=rear->next){
           printf("rear=%d\n",p->data);
           p=p->next;
       }
    
    printf("\n");
    //手动删除
    printf("%d\n",ListDelete(&rear,2,&value));
    p=rear->next->next;
       while(p!=rear->next){
           printf("rear=%d\n",p->data);
           p=p->next;
       }
    printf("\n");
    //得到第i个位置上的值
    
    int value2;
    printf("%d\n",GetElem(rear,1,&value2));
    printf("%d\n",value2);
    
     printf("\n");
     //计算长度
       LinkList rear1;
       InitList(&rear1);
       printf("%d\n",ListInsert(&rear1,1,5));
       printf("%d\n",ListInsert(&rear1,1,5));
       printf("%d\n",ListInsert(&rear1,3,7));
       printf("%d\n",ListInsert(&rear1,22,4));
    
       printf("%d\n",ListLength(rear1));
       printf("\n");
    //计算与输入元素相等的位置
     printf("%d\n",LocateElem(rear1,7));
     //清空链表
     printf("\n");
    
     printf("%p\n",rear1);
     ClearList(&rear1);
     printf("%p\n",rear1);
    printf("\n");
     //头插法
     LinkList headInsert;
     CreateListHead(&headInsert,10);
     LinkList headInsertHead;
       headInsertHead=headInsert->next->next;
       while(headInsertHead!=headInsert->next){
           printf("rear=%d\n",headInsertHead->data);
           headInsertHead=headInsertHead->next;
       }
    //尾插法
    printf("\n");
     LinkList tailInsert;
     CreateListHead(&tailInsert,12);
     LinkList headInsertTail;
       headInsertTail=tailInsert->next->next;
       while(headInsertTail!=tailInsert->next){
           printf("rear=%d\n",headInsertTail->data);
           headInsertTail=headInsertTail->next;
       }
    printf("\n");
    //union
    
      unionrear(headInsert,tailInsert);
      LinkList u = tailInsert->next->next;
      while(u != tailInsert->next){
        printf("rear=%d\n", u->data);
        u = u->next;
      }
    
     return 0;
    }
    
    
    
    展开全文
  • 在python中,for循环相当于一个迭代器(Iterator),在循环体中改变循环变量的循环次数是没有影响的。 迭代器在一个独立的线程中工作,并且拥有一个mutex锁。迭代器被创建的时候,建立了一个内存索引表(单链表...

    在之前的编程语言里,学到for循环里面是可以重置变量i的值的,然后让整个for循环从头开始,但是在python里面却行不通

    这是为什么呢???

    在python中,for循环相当于一个迭代器(Iterator),在循环体中改变循环变量的值对循环次数是没有影响的。 

    迭代器在一个独立的线程中工作,并且拥有一个mutex锁。迭代器被创建的时候,建立了一个内存索引表(单链表),这个索引表指向原来的对象,当原来的对象数量改变的时候,这个索引表的内容没有同步改变,所以当索引指针往下移动的时候,便找不到要迭代的对象,于是产生错误。就是说迭代器在工作的时候,是不允许被迭代的对象被改变的。 

    转载自:

    点击打开链接

    展开全文
  • 循环链表合并(只带尾指针) 对循环链表,有时不给出头指针,而给出尾指针可以更方便的找到第一个和最后一个结点。 如何查找开始结点和终端结点? 开始结点:rear->next->next 终端结点:rear 循环...
  • C语言通过指针修改变量的

    万次阅读 2016-08-06 14:01:30
    C语言学习笔记之通过指针修改变量的 1.C语言的基本结构介绍 2.C语言的数据类型 3.通过指针改变变量的 总结:
  • 目录 一.变量的内存实质到 1.1变量的实质 ...3.2.1.改变一级指针指向 3.2.2改变 N-1 级指针的指向 3.2.3二级指针的步长 四. 指针与数组 4.1 指针与数组名 4.1.1 通过数组名访问数组元素 4....
  • 循环双链表实现下述功能: void meau(); //菜单函数 void Initlist(List *list); //初始化 void show(List *list); //打印链表内容 bool Push_back(List *list,ElemType x); //尾插法 b
  • 指针

    万次阅读 多人点赞 2019-07-28 22:08:42
    一、指针变量的定义和使用 1.定义指针变量 2.通过指针变量取得数据 3.关于*和& 二、指针变量运算(加法、减法、比较运算) 三、数组指针(指向数组的指针) 假设 p 是指向数组 arr 中第 n 个元素的指针,...
  • JAVA8stream嵌套循环并设置

    千次阅读 2020-03-19 11:49:27
    JAVA8stream嵌套循环并设置 简介: Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理数据。 Stream 不存储数据、不改变源数据 详情请阅读stream官网 一.测试代码 public static void ...
  • char *t="www",我想让s内容变成"hellowww" 可以通过直接使用指针指向来做么,不要string.h函数 不要循环赋值。就是想通过修改指针指向来做 ``` 这个可以实现么 不要函数不要循环复制 为什么不能让s+5=t,就是让它...
  • 写了一年多的C ++了,今天写二叉搜索树ADT中的deletemin()的时候出现了一个非常奇怪,从未见过的问题---指针在赋值给其他指针变量一次之后,自己自动的改变了,简直是吓死我了 排查这个问题用了一个多小时,通过...
  • jquery 里面有一个很常用的函数 each,可以把循环的对象元素绑定到this,方便操作。  这里只是简单的做个演示:  代码  复制代码 代码如下: function each(tagName, callback)  {  ...
  • 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,...
  • C语言指针就应该这么学 - 指针的进阶篇

    万次阅读 多人点赞 2021-05-27 16:12:19
    文章目录前言一、字符指针实例1:二、数组指针三、指针数组四、数组传参和指针传参六、函数指针数组七、指向函数指针数组的指针九、回调函数十、指针和数组笔试题解析十一、指针的初识篇 前言 在C语言初识篇我们大概...
  • php中用foreach改变数组的的问题

    千次阅读 2017-11-23 23:13:28
    今天在用 php 中的 foreach 循环改变原数组元素时,发现一直出不来结果,还以为代码逻辑写错了!后来发现是数组没被改变!!百度之后有以下处理方法,以下是转载的内容: 翻到PHP文档的foreach那页这样写道: ...
  • 【C/C++】C语言的指针总结

    万次阅读 多人点赞 2019-08-28 15:46:13
    文章目录基础部分关于内存物理存储器和存储地址空间关于内存地址指针和...指针和函数函数形参改变实参的数组名做函数参数指针做为函数的返回值指针和字符串字符指针字符指针做函数参数const修饰的指针变量指针数组...
  • C语言指针——指针与数组

    千次阅读 2021-03-20 18:32:52
    种一棵树最好的时间是十年前,其次是现在。 指针与数组 一、指针的运算 指针可以进行三种运算: 1.指针加上整数: ...当两个指针相减时,结果是指针在内存上的距离,可以用数组元素的个数来度量,所以如果指
  • 指针入门

    千次阅读 2017-03-11 17:02:29
    现在的Java、C#等语言已经取消了指针,但作为一个C++程序员,指针的直接操作内存,在数据操作方面有着速度快,节约内存等优点,仍是很多C++程序员的最爱。指针就像是一把良剑,就看你怎么去应用它!什么是指针? ...
  • //由于仅带尾指针的单循环链表尾指针不断变化, 所以只能传递地址,通过地址改变实参的; PLinkQueue CreateLinkQueue(void); void DestroyLinkQueue(PLinkQueue * pR); bool EmptyLinkQueue(PLinkQueue * pR); ...
  • 智能指针(三):weak_ptr浅析

    万次阅读 多人点赞 2018-09-01 14:36:26
    weak_ptr这个指针天生一副“小弟”的模样,也是在C++11的时候引入的标准库,它的出现完全是为了弥补它老大shared_ptr天生有缺陷的问题,其实相比于上一代的智能指针auto_ptr来说,新进老大shared_ptr可以说近乎完美...
  • 字符指针

    万次阅读 多人点赞 2019-08-10 16:37:09
    2019-8-9字符指针 ①字符指针:指向字符型数据的指针变量。每个字符串在内存中都占用一段连续的存储空间,并有唯一确定的首地址。即将字符串的首地址赋值给字符指针,可让字符指针指向一个字符串。 ② char *ptr = ...
  • 关于C语言中的数组指针指针数组以及二级指针

    万次阅读 多人点赞 2017-02-05 19:14:18
    概念解释数组指针:首先它是一个指针,它指向一个数组,即指向数组的指针;在32 位系统下永远是占4 个字节,至于它指向的数组占多少字节,不知道。数组指针指向的是数组中的一个具体元素,而不是整个数组,所以数组...
  • 让你不再害怕指针——C指针详解(经典,非常详细)

    万次阅读 多人点赞 2016-04-12 10:53:34
     要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,...
  • Linux C程序访问NULL指针

    千次阅读 2019-10-31 09:44:20
    本文将介绍如何对NULL指针地址建立合法映射,从而合法访问NULL指针。本文表达的宗旨: 任何虚拟地址,只要有合法的页表映射,就能访问! 提到C语言编程,我想几乎所有人都遭遇过NULL指针。我们的代码中总是...
  • C++ STL 四种智能指针

    万次阅读 多人点赞 2018-08-07 11:25:13
    STL一共给我们提供了四种智能指针:auto_ptr、unique_ptr、shared_ptr和weak_ptr,auto_ptr是C++98提供的解决方案,C+11已将将其摒弃,并提出了unique_ptr作为auto_ptr替代方案。虽然auto_ptr已被摒弃,但在实际项目...
  • 编写一个函数,作用是把一个 char 组成的字符串循环 右移 n 个。 比如原来是“abcdefghi” 如果 n=2,移位后应该是“hiabcdefgh” 左移n个 比如原来是“abcdefghi” 如果 n=2,移位后应该是“cdefghiab” ...
  • volatile(注意它是用来修饰变量而不是上面介绍的__volatile__)表明某个变量的可能在外部被改变,因此对这些变量的存取不能缓存到寄存器,每次使用时需要重新存取。该关键字在多线程环境下经常使用,因为在编写多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 180,148
精华内容 72,059
关键字:

循环改变指针的值怎么改变