精华内容
下载资源
问答
  • 的那个意义大致,当然数组本身传递就是地址传递的,是这样说的吗?我不知道该怎么描述,希望有问题可以有人指出来,不要误导大家才是。我对很多概念总是一知半解的,明知道不好,却很难改。 上代码 class Solution ...

    LeetCode刷题记12

    26. 删除排序数组中的重复项

    题目
    在这里插入图片描述
    这个题目有意思的地方在它的说明,这个和最早学c语言,参数加&的那个意义大致,当然数组本身传递就是地址传递的,是这样说的吗?我不知道该怎么描述,希望有问题可以有人指出来,不要误导大家才是。我对很多概念总是一知半解的,明知道不好,却很难改。
    在这里插入图片描述
    上代码

    class Solution {
        public int removeDuplicates(int[] nums) {
            if (nums.length <= 1) {
                return nums.length;
            }
            int cur = 0, i = 1;
            while (i < nums.length) {
                if (nums[cur] == nums[i]) {
                    i ++;
                } else {
                    nums[++ cur] = nums[i ++];
                }
            }
            return cur + 1;
        }
    }
    

    简单题使我快乐~我决定再来一题,嘻嘻嘻。

    展开全文
  • 指针加1

    2019-04-01 15:50:09
    首先我们先讨论指针加一是怎么加的 可以参考下列代码 int main() { int arr[10] = {0,1,2,3,4,5,6,7,8,9}; int *p = arr;//将数组arr[0]的地址赋给指针变量p printf("%d\n", p);//查看此时p的地址 ...

    日常生活中我们常用的计算是加减乘除,那么对于指针来说,它却只有加减运算
    首先我们先讨论指针加一是怎么加的
    可以参考下列代码

    int main()
    {
    	int arr[10] = {0,1,2,3,4,5,6,7,8,9};
    	int *p = arr;//将数组arr[0]的地址赋给指针变量p
    
    	printf("%d\n", p);//查看此时p的地址
    	printf("%d\n\n" ,*p);
    
    	p++;
    	printf("%d\n", p);//查看p++之后的地址
    	printf("%d\n", *p);
    
    }
    

    在这里插入图片描述
    从结果看,在没有进行加一之前 *p所指向的是数组的第一个元素啊arr[0],在p加一之后 *p指向的是数组第二个元素arr[1],而他们的地址相差4即4个字节,int型代表的是4个字节。再取char,float,double等类型的数组做实验,结果的是一样的,则我们判断p+1指向p指向的下一个元素。同理p-1也是如此。

    题外话:
    因为++和 * 的算数优先级一样高且结合方式是自右向左所以 *p++等同于 *(p++)即先取 *p值再p加一。
    而 *++p 是p+1再取 *p值。
    ++*p是将 *p的值加一

    展开全文
  • &a+1与a+1

    2015-03-18 20:13:30
    &a+1与a+1 int a[5] = {1, 2, 3, 4, 5}; int *ptr1 = (int*)(&a + 1); //这里偏移量是整个数组的大小,但我不知道怎么... //a地址再加一个字节,直接数值相加而不是指针 &a地址加1 int *ptr3 = (int*)(a + 1); //a相
        int a[5] = {1, 2, 3, 4, 5};
        int *ptr1 = (int*)(&a + 1); //这里偏移量是整个数组的大小,但我不知道怎么解释。
        int *ptr2 = (int*)((int)a + 1); //a地址再加一个字节,直接数值相加而不是指针 &a地址加1
        int *ptr3 = (int*)(a + 1); //a相当于int *指针,a+1相当于a+sizeof(int *),偏移量为int *
        printf("%x %x\n", ptr1[-1], *ptr3);

    输出5 ,2

    展开全文
  • 它里面的数据元素是以结点为单位,每个结点是由数据元素的数据和下一个结点的地址组成,在java集合框架里面LinkedList、HashMap(数组加链表)等等的底层都是用链表实现的。2、下面是单链表的几个特点:数据元素在...

    一、单链表

    1、在我们数据结构中,单链表非常重要。它里面的数据元素是以结点为单位,每个结点是由数据元素的数据和下一个结点的地址组成,在java集合框架里面
    LinkedList、HashMap(数组加链表)等等的底层都是用链表实现的。
    2、下面是单链表的几个特点:
    数据元素在内存中存放的地址是不连续的:单链表的结点里面还定义一个结点,它里面保存着下一个结点的内存地址,在实例化对象的时候,jvm会开辟不同内存空间,并且是不连续的。
    添加效率高:添加一个元素时,先找到插入位置的前一个,只需要将1,2个元素的连接断开,将插入结点的next指向第一个元素的next(1),然后将第一个元素的next指向插入结点(2),
    不用在挪动后面元素。

    e5b6a57d1b9e4686977c02db21ff48d4.png


    删除效率高:删除一个元素时,先找到删除位置,将前一个的next指向删除位置的next,不用在挪动后面元素。

    54d5bce17040bf8bfa016f62637c8420.png


    查询效率低:查询的时候必须从头开始,依次遍历,而数组因为它的内存是连续的,可以直接通过索引查找。
    3、下面通过代码来实现单链表结构:

    package com.tlinkedList;
    
    /**
    * User:zhang
    * Date:2020/10/26
    **/
    public class TLinkedList<T> {
      private Node head;//链表头部
      private int size;//链表元素的个数
      public TLinkedList(){
          head=null;
          size=0;
      }
    //    将结点作为内部类。也可以新建一个Node类,作为结点
      class Node{
          private Node next;//下一个结点
          private T t;//结点的数据
          public Node(T t){
              this.t=t;
          }
    
          public T getT() {
              return t;
          }
    
          public void setT(T t) {
              this.t = t;
          }
      }
    //    在链表头部添加一个结点
      public void addFirst(T t){
          Node node = new Node(t);
          node.next=head;
          head=node;
          size++;
      }
    //    在链表中间添加一个结点
      public void addMid(T t,int index){
          Node node = new Node(t);
          Node mid=head;
          for (int i = 0; i < index - 1; i++) {
              mid=mid.next;
          }
          node.next=mid.next;
          mid.next=node;
          size++;
      }
    //    在链表尾部添加一个结点
      public void addLast(T t){
          Node node = new Node(t);
          Node last=head;
          while (last.next!=null){
              last=last.next;
          }
          last.next=node;
          node.next=null;
          size++;
      }
    //    删除链表的头结点
      public void removeFirst(){
          head=head.next;
          size--;
      }
    //    删除链表的中间元素
      public void removeMid(int index){
          Node mid=head;
          if (index==0){
              removeFirst();
              return;
          }
          int j=0;
          Node qMid=head;
          while (j<index){
              qMid=mid;
              mid=mid.next;
              j++;
          }
          qMid.next=mid.next;
          size--;
      }
    //    删除链表的尾结点
      public void removeLast(){
          Node mid=head;
          Node qMid=head;
          while (mid.next!=null){
               qMid=mid;
               mid=mid.next;
          }
          qMid.next= null;
          size--;
      }
    //    获取链表指定下标的结点
      public Node get(int index){
          Node mid=head;
          if (index==0){
              return head;
          }
          int j=0;
          while (j<index){
              mid=mid.next;
              j++;
          }
          return mid;
      }
      public static void main(String[] args) {
          TLinkedList<String> linkedList = new TLinkedList<>();
          linkedList.addFirst("hello1");
          linkedList.addFirst("hello2");
          linkedList.addFirst("hello3");
          for (int i = 0; i < linkedList.size; i++) {
              System.out.println(linkedList.get(i).getT());
          }
    //        linkedList.removeLast();
    //        linkedList.removeFirst();
    //        linkedList.addLast("hello4");
          linkedList.addMid("hello",2);
          System.out.println("--------------");
          for (int i = 0; i < linkedList.size; i++) {
              System.out.println(linkedList.get(i).getT());
          }
      }
    }

    结果如下:

    14d748bafa95152f0e6a268d1a914a19.png

    二、栈(Stack)

    1、一提到栈我们脑海就会浮现四个字“先进后出”,没错,它就是栈的最大特点。

    35e06fa540c207ef460cdac351c2d061.png


    2、栈的应用场景也非常多,比如将字符串反转、jvm里面的栈区等等。
    3、栈里面的主要操作有:
    push(入栈):将一个数据元素从尾部插入
    pop(出栈):将一个数据元素从尾部删除
    peek(返回栈顶元素):将栈顶元素的数据返回
    相当于只有一个开口就是尾部,只能从尾进,从尾出。
    4、下面通过链表结构实现栈结构:

    package com.tStack;
    
    
    /**
    * User:zhang
    * Date:2020/10/26
    **/
    public class Test_Stack<T> {
      private Node head;//栈的头结点
      private int size;//栈的元素个数
      class Node{
          private Node next;//下一个结点
          private T t;//结点的数据
          public Node(T t){
              this.t=t;
          }
    
          public T getT() {
              return t;
          }
    
          public void setT(T t) {
              this.t = t;
          }
      }
    
      public Test_Stack() {
          head=null;
          size=0;
      }
    
      public static void main(String[] args) {
          Test_Stack<String> TStack = new Test_Stack<>();
          TStack.push("hello1");
          TStack.push("hello2");
          TStack.push("hello3");
          for (int i = 0; i < 3; i++) {
              System.out.println(TStack.pop());
          }
      }
    //    入栈
      public void push(T t){
          Node node = new Node(t);
          if (size==0){
              node.next=head;
              head=node;
              size++;
              return;
          }
          if (size==1){
              head.next=node;
              node.next=null;
              size++;
              return;
          }
          Node lastNode=head;
          while (lastNode.next!=null){
               lastNode=lastNode.next;
          }
          lastNode.next=node;
          node.next=null;
          size++;
      }
    //    出栈
      public T pop(){
          if (size==0){
              System.out.println("栈内无值");
              return null;
          }
          if (size==1){
              T t = head.getT();
              head=null;
              size--;
              return t;
          }
          Node lastNode=head;
          Node qNode=head;
          while (lastNode.next!=null){
              qNode=lastNode;
              lastNode=lastNode.next;
          }
          T t = lastNode.getT();
          qNode.next=null;
          size--;
          return t;
      }
    //    获取栈里面元素的个数
      public int getSize(){
          return size;
      }
    //    返回栈顶元素
      public T peek(){
          if (size==0){
              System.out.println("栈内无值");
              return null;
          }
          if (size==1){
              return head.getT();
          }
          Node lastNode=head;
          while (lastNode.next!=null){
              lastNode=lastNode.next;
          }
          return lastNode.getT();
      }
    }

    结果:

    53b84f23151ff9c92e91ebb657769b75.png

    三、队列(Queue)

    1、队列的特点也用“先进先出”四个字来概括。就是先进去的元素先输出出来。

    5e32fc52b33227f99e703d069f69ee68.png

    2、我们常见的消息队列就是队列结构实现的。
    3、队列的常见操作如下:
    put(入队):将一个结点插入到尾部。
    pop(出队): 将头结点的下一个结点作为头,然后将原来的头结点删除。
    4、通过链表结构实现队列:

    package com.tQueue;
    
    /**
     * User:zhang
     * Date:2020/10/26
     **/
    public class TQueue<T> {
        private Node front;//头结点
        private Node tail;//尾结点
        private int size;//队列中元素的个数
        class Node {
            private Node next;//下一个结点
            private T t;//结点的数据
    
            public Node(T t) {
                this.t = t;
            }
    
            public T getT() {
                return t;
            }
    
            public void setT(T t) {
                this.t = t;
            }
        }
        public int getSize() {
            return size;
        }
    
        public void setSize(int size) {
            this.size = size;
        }
    
        public TQueue() {
            front = tail = null;
        }
    
        //    入队
        public void put(T t) {
            Node node = new Node(t);
            if (size == 0) {
                front = tail = node;
                size++;
                return;
            }
            Node lastNode = front;
            while (lastNode.next != null) {
                lastNode = lastNode.next;
            }
            lastNode.next = node;
            tail = node;
            size++;
        }
    
        //    出队
        public T pop() {
            if (size == 0) {
                System.out.println("队列中无值");
                return null;
            }
            T t = front.getT();
            front=front.next;
            size--;
            return t;
        }
    
        public static void main(String[] args) {
            TQueue<String> tQueue = new TQueue<>();
            tQueue.put("Hello1");
            tQueue.put("Hello2");
            tQueue.put("Hello3");
            for (int i = 0; i < 3; i++) {
                System.out.println(tQueue.pop());
            }
        }
    }

    结果:

    a2b361bb86c508d64ab1030f1749419f.png

    文章有不足之处,欢迎大家留言指正,谢谢大家啦!


    原作者:远航
    原文链接:java实现单链表、栈、队列三种数据结构 - 学海无涯--远航 - 博客园
    原出处:博客园
    侵删

    c950f67dd686224a00a69aaca6e537b9.gif
    展开全文
  • :exclamation:怎么刷 LeetCode? 我是如何刷 LeetCode 的 算法小白如何高效、快速刷 leetcode? 刷题效率低?或许你就差这么一个插件 力扣刷题插件 《91 天学算法》限时活动 第一期讲义-二分法 第一期讲义-双...
  • 以前刚接触c语言没多久时,碰到涉及到一位数组、二维数组、一级指针、二级指针、指向一位数组的指针、...1. 一维数组的名字代表的是第一个元素的地址 1 就是下一个元素的地址,二维数组的名字代表的是第一行的地
  • //2 如何动态为学员姓名开辟空间 解决方案: 计算出字符串的长度, 然后加1 //3 如何存储为三个学员开辟空间之后的地址 解决方案: 使用指针数组来进行存储数组, 数组中有3个元素 char tempStr[20] = {0}; //临时...
  • 7.5.3 给汽车个重载的方法 169 7.5.4 测试一下 169 7.5.5 重载容易引发误解的两个地方——返回类型和形参名 170 7.5.6 重载中的最难点——参数匹配原则 171 7.6 使用类的实例作为方法参数 172 7.6.1 超车方法...
  • 在上面的地址看到了一个百度面试的题目:怎么找出{1,1,2,3,3,4,4,4,5,5,5,5} 找出出现次数为奇数的数字.     个人总结了一下,在上面博文评论里面共提到了2种方法. 1)使用一个数组来记录出现的次数,数组下标...
  • ES6 Map Set

    2018-10-21 23:48:51
    数组也是一种数据结构,(有序的地址存储) 对象的结构(key:value) 数组去重:arr =[1,'1',1,{}];(怎么实现去重,普通的去重方法不在适用) es6新的数据结构:Map 和 Set Map 是字典 加强的对象 ,若干键值...
  • 7.5.3 给汽车个重载的方法 169 7.5.4 测试一下 169 7.5.5 重载容易引发误解的两个地方——返回类型和形参名 170 7.5.6 重载中的最难点——参数匹配原则 171 7.6 使用类的实例作为方法参数 172 7.6.1 超车方法...
  • 7.5.3 给汽车个重载的方法 169 7.5.4 测试一下 169 7.5.5 重载容易引发误解的两个地方——返回类型和形参名 170 7.5.6 重载中的最难点——参数匹配原则 171 7.6 使用类的实例作为方法参数 172 7.6.1 超车方法...
  • 1 理解计算机是怎么运行程序的 2 运行一个已解释的程序 3 运行一个已编译的程序 4 C++在哪里 5 理解Visual c++中的程序文件 6 创建源代码文件 7 理解并创建头文件 第二章 结构和语法 8 理解计算机语言 9 理解计算机...
  • 第一种:定义一个数组,int a[2],输出a[1]和a[0]的地址,两个差就是Int占的字节数。 两个地址的差是4;第二种:定义一个数组,int a[4],然后用一个char型的指针指向其首地址,然后这个指针每次加一,然后再把这个...
  • 第二次博客作业

    2019-10-07 03:59:07
    1函数的递归调用 每次做一些机械循环的题目知道可以用函数的递归调用就是不会用,不知道怎么写,知道意思打不出来。 2字符串数组 感觉写的乱七八糟的 3指针与数组,指针与字符串 指针指向了地址,带上*符号 被引用...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 联合 2.20 结构和联合有什么区别? 2.21 有办法初始化联合吗? 2.22 有没有一...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 联合 2.20 结构和联合有什么区别? 2.21 有办法初始化联合吗? 2.22 有没有一...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 58 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 58 联合 59 2.20 结构和联合有什么区别? 59 2.21 有办法初始化联合...
  • 图说区块链 读书笔记

    2021-01-08 04:49:32
    1. 拜占庭将军 ...在比特币系统中,私钥本质上是由32个字节组成的数组,公钥和地址的生成都依赖私钥,有了私钥就能生成公钥和地址,就能够使用对应地址上的比特币。 哈希值,哈希算法将任意长度的二进制值
  • 刚开始有个数组,只有一个1,你可以进行两个操作: 1.把一个数复制到序列后面。 2.把一个数加上1。 你的任务是,通过上述操作,使所有数之和为一个给定值x,要求使操作次数尽可能小。 题目原地址...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样?  2.19 程序运行正确,但退出时却“coredump”(核心转储)了,怎么回事?  联合  2.20 结构和联合有什么区别?  2.21 有办法初始化联合吗?  ...
  •  2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“coredump”(核心转储)了,怎么回事? 联合 2.20 结构和联合有什么区别? 2.21 有办法初始化联合吗? 2.22...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“coredump”(核心转储)了,怎么回事? 联合 2.20 结构和联合有什么区别? 2.21 有办法初始化联合吗? 2.22 有...
  • 理解算法的时间与空间复杂度怎么计算(加强练习); 时间复杂度O(n),n表示运行代码行数所需的行数; 表示方法O(1),O(n),O(logn),O(n),O(nlongn); 数组:线性表、连续内存中存储相同类型的数据; 优点:查找快O(1);...
  • 答: 当数组名作为参数时,传递的实际上是地址。而其他类型如int作为参数时,由于函数参数值实质上是实参的一份拷贝,被调函数内部对形参的改变并不影响实参的值。 22、数据结构和算法: A:查找: (1)二分法查找; B...
  • 题目地址: https://www.lintcode.com/problem/k-edit-distance/description 给定一个字符串数组AAA,再给定一个字符串ttt和一个整数kkk,要求返回AAA中所有与ttt编辑距离小于等于kkk的字符串。编辑距离的定义是,一...
  • 2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 29 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 29 联合 30 2.20 结构和联合有什么区别? 30 2.21 有办法初始化...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    2.18 既然数组名可以用作数组的基地址,为什么对结构不能这样? 29 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 29 联合 30 2.20 结构和联合有什么区别? 30 2.21 有办法初始化...
  • 易学C++,C++入门

    2009-12-06 14:30:11
     5.3.2 怎么让输出的东西更好看   5.4 While循环   5.4.1 当型循环   5.4.2 导火索——do   5.5 方法指导   5.6 习题   第6章 好用的“工具”——函数   6.1 简单的“工具”——函数   ...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

数组怎么地址加1