精华内容
下载资源
问答
  • C++链表的快速创建方法定义链表结构体定义链表创建的类书写头文件 定义链表结构体 struct ListNode { int val; ListNode *next; ListNode(int val1, ListNode *next1 = nullptr) { val = val1; next = next1...

    关于C++如何将数组转化成链表结构并进行链表相关操作的方法

    定义链表结构体

    struct ListNode
    {
    	int val;
    	ListNode *next;
    	ListNode(int val1, ListNode *next1 = nullptr)
    	{
    		val = val1;
    		next = next1;
    	}
    };
    

    定义创建链表类

    class List
    {
    public:
    	ListNode *numberList;
    	List()
    	{
    		numberList = nullptr;
    	}
    	~List()
    	{
    		ListNode *n;
    		while (numberList != nullptr)
    		{
    			n = numberList;
    			numberList = numberList->next;
    			delete n;
    		}
    		cout << "congradgulations!" << endl;
    	}
    
    	ListNode *creat(int array[], int len)
    	{
    
    		for (int i = 0;i < len;i++)
    		{
    			numberList = new ListNode(array[i], numberList);
    		}
    		return numberList;
    	}
    	void print()
    	{
    		ListNode *nm = numberList;
    		while (nm != nullptr)
    		{
    			cout << nm->val << endl;
    			nm = nm->next;
    		}
    		cout << "hello" << endl;
    	}
    };
    

    在主函数中建立数组,并通过指针函数*creat给数组成员创建链表,这样就实现了链表的快捷创建。

    其中需要注意打印函数print()中需要创建一个新指针来遍历链表节点,防止头指针指向空,调用的时候出现空指针的错误。

    书写头文件

    头文件一般书写函数的声明、类定义,为了防止重定义错误,头文件开头需要写#pragma once或者#ifndef LISTNODE_H
    #define LISTNODE_H

    #endif
    在头文件中类的成员函数需要写在类里面,这时,编译器将成员函数当作内联函数处理,避免了重定义的错误。

    #pragma once
    #ifndef LISTNODE_H
    #define LISTNODE_H
    using namespace std;
    struct ListNode
    {
    	int val;
    	ListNode *next;
    	ListNode(int val1, ListNode *next1 = nullptr)
    	{
    		val = val1;
    		next = next1;
    	}
    };
    class List
    {
    public:
    	ListNode *numberList;
    	List()//构造函数
    	{
    		numberList = nullptr;
    	}
    	~List()//析构函数
    	{
    		ListNode *n;
    		while (numberList != nullptr)
    		{
    			n = numberList;
    			numberList = numberList->next;
    			delete n;
    		}
    		cout << "congradgulations!" << endl;
    	}
    
    	ListNode *creat(int array[], int len)
    	{
    
    		for (int i = 0;i < len;i++)
    		{
    			numberList = new ListNode(array[i], numberList);//链表节点的地址和数组中的地址有关系吗
    		}
    		return numberList;
    	}
    	void print()
    	{
    		ListNode *nm = numberList;
    		while (nm != nullptr)
    		{
    			cout << nm->val << endl;
    			nm = nm->next;
    		}
    		cout << "hello" << endl;
    	}
    };
    class Solution {
    public:
    	ListNode* removeElements(ListNode* head, int val)
    	{
    		ListNode* dummyHead = new ListNode(0);
    		dummyHead->next = head;
    		ListNode* cur = dummyHead;
    		while (cur->next != NULL) {
    			if (cur->next->val == val) {
    				ListNode* tmp = cur->next;
    				cur->next = cur->next->next;
    				delete tmp;
    			}
    			else {
    				cur = cur->next;
    			}
    		}
    		head = dummyHead->next;
    		delete dummyHead;
    		return head;
    	}
    };
    void creat(int array[], int len);
    void print();
    struct ListNode;
    class List;
    ListNode* removeElements(ListNode* head, int val);
    
    
    #endif
    
    
    

    其中Solution类实现链表指定节点删除,其中用到了链表的虚表头指针,更方便对链表头进行操作。

    源文件与main函数

    #include<iostream>
    #include"ListNode.h"
    using namespace std;
    //ListNode* removeElements(ListNode* head, int val);
    
    int main()
    {
    	List *l=new List();
    	Solution s;
    	int a[] = { 1,2,3,4,5,6 };
    	int len = sizeof(a) / sizeof(int);
    	ListNode *number = l->creat(a, len);
    	s.removeElements(number, 3);
    	l->print();
    	delete l;
    	system("pause");
    	return 0;
    }
    

    在源文件中包含头文件,并调用函数,实现链表操作。

    其中sizeof运算符返回一条表达式或一个类型名字所占的字节数,这里通过int len = sizeof(a) /sizeof(int);返回数组a的长度。

    输出结果

    将数组a[]={1,2,3,4,5,6}转化为链表结构,并删除值为3的节点,其中hello表示调用了print()函数,congradgulations!表示调用了析构函数。

    注意:此处的链表插入方式是从头插入,因此链表头的值是数组的尾部成员。

    new与delete

    *creat()函数中使用了new命令在堆区创建了空间,由于堆区的空间需要手动创建和手动释放,因此我们需要使用delete来调用析构函数,否则会造成内存泄漏错误。

    同时需要注意,delete的使用一般放在程序的末端,因为delete l,也相当于删除了l这个对象。

    初学C++的感想

    由于之前学过JAVA,现在学起C++感觉C++的语言比较繁琐,但是很灵活、基础,对编程的原理能够很清楚。其中指针是C++的灵魂,指针的灵活应用与管理是我后期需要学习的。

    由于C++使用指针,涉及到内存空间,因此C++比JAVA更加灵活也更加危险。

    通过这个想法的实现,让我对指针有了更深刻的认识。

    展开全文
  • String转化为char[] String 转化为数组类型这里用到 String s; s="everything has two sides,flea,storage"; char[] chrCharArrays;...还有就是java链表的理解,通过一系列函数调用 ` #...

    String转化为char[]

    String 转化为数组类型这里用到
    		String s;
    		s="everything has two sides,flea,storage";
    		char[] chrCharArrays;
    		chrCharArrays=s.toCharArray();
    		转化为'chrCharArrays'
    
    

    还有就是java中链表的理解,通过一系列函数调用
    `

    代码

    
     class node{
    	private char st;
    	private node next;
    	void setchar(char x)
    	{
    		st=x;
    	}
    	char getChar()
    	{
    		return st;
    	}
    	node getNext()
    	{
    		return next;
    	}
    	void setNext(node x)
    	{
    		next=x;
    	}
    }
    public class demo6 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		node x[]=new node[100];
    		int i;
    		String s;
    		s="everything has two sides,flea,storage";
    		char[] chrCharArrays;
    		chrCharArrays=s.toCharArray();
    		//for(i=0;i<chrCharArrays.length;i++)
    			//System.out.println(chrCharArrays[i]);
    		for(i=0;i<x.length;i++)
    		x[i]=new node();
    		for(i=0;i<chrCharArrays.length;i++)
    		{
    			x[i].setchar(chrCharArrays[i]);//把字符数组中的字符存入x[i]类中
    			if(i<chrCharArrays.length-1)x[i].setNext(x[i+1]);//指向下一个地址,相当于指针
    		}
    		node start;//起始指针
    		start=x[0];
    		System.out.print(start.getChar());
    		while(start.getNext()!=null)
    		{
    			start=start.getNext();
    			System.out.print(start.getChar());
    		}
    	}
    
    
    
    
    展开全文
  • } } } 输出结果如下: 或者 看这里: 数组实现的栈输出如下 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 链表实现的栈输出如下 29 28 27 26 25 24 23 22 21 20 19 18 17 16 ...

    一、栈

    栈的定义

    栈(Stack)是限制仅在表的一端进行插入和删除运算的线性表。

    (1)通常称插入、删除的这一端为栈顶 (Top),另一端称为栈底 (Bottom)。

    (2)当表中没有元素时称为空栈。

    (3)栈为后进先出(Last In First Out)的线性表,简称为 LIFO 表。

    栈的修改是按后进先出的原则进行。每次删除(退栈)的总是当前栈中"

    最新"的元素,即最后插入(进栈)的元素,而最先插入的是被放在栈的底部,

    要到最后才能删除。

    2、栈的基本运算

    (1) 判断栈是否为空

    boolean isEmpty();

    (2)清空栈

    void clear();

    (3)栈的长度

    int length();

    (4)数据入栈

    boolean push(T data);

    (5)数据出栈 ,栈中删除

    T pop();

    (6)数据出栈 ,栈中不删除

    T peek();

    二、代码编写

    1、接口类

    package com.lin.stack;

    /**

    * 功能概要:栈的接口类

    *

    * @author linbingwen

    * @since  2015年8月29日

    */

    public interface MyStack {

    /**

    * 判断栈是否为空

    * @author linbingwen

    * @since  2015年8月29日

    * @return

    */

    boolean isEmpty();

    /**

    * 清空栈

    * @author linbingwen

    * @since  2015年8月29日

    */

    void clear();

    /**

    * 栈的长度

    * @author linbingwen

    * @since  2015年8月29日

    * @return

    */

    int length();

    /**

    * 数据入栈

    * @author linbingwen

    * @since  2015年8月29日

    * @param data

    * @return

    */

    boolean push(T data);

    /**

    * 数据出栈 ,栈中删除

    * @author linbingwen

    * @since  2015年8月29日

    * @return

    */

    T pop();

    /**

    * 数据出栈 ,栈中不删除

    * @author linbingwen

    * @since  2015年8月29日

    * @return

    */

    T peek();

    }

    2、数组实现栈

    package com.lin.stack;

    /**

    * 功能概要:数组实现栈

    *

    * @author linbingwen

    * @since  2015年8月29日

    */

    public class MyArrayStack implements MyStack {

    private Object[] objs = new Object[16];

    private int size;

    @Override

    public boolean isEmpty() {

    return size == 0;

    }

    @Override

    public void clear() {

    for (int i = 0; i 

    objs[i] = null;

    size--;

    }

    }

    @Override

    public int length() {

    return size;

    }

    @Override

    public boolean push(T data) {

    if(size == (objs.length-1)){

    Object[] temp = new Object[objs.length*2];

    for (int i = 0; i 

    temp[i]=objs[i];

    }

    objs= temp;

    }

    objs[size++]=data;

    return true;

    }

    @Override

    @SuppressWarnings("unchecked")

    public T pop() {

    return size == 0?null:(T) objs[(size--)-1];

    }

    @Override

    @SuppressWarnings("unchecked")

    public T peek() {

    return size == 0?null:(T) objs[size];

    }

    }

    3、链表实现栈

    package com.lin.stack;

    /**

    * 功能概要:

    *

    * @author linbingwen

    * @since  2015年8月29日

    */

    public class MyListStack implements MyStack{

    private int size;

    private Node top;

    class Node{

    T data;

    Node pre;

    }

    @Override

    public boolean isEmpty() {

    return size == 0;

    }

    @Override

    public void clear() {

    top = null;

    }

    @Override

    public int length() {

    return size;

    }

    @Override

    public boolean push(T data) {

    Node node = new Node();

    node.data=data;

    if( null == top){

    top = node;

    }else {

    node.pre = top;

    top =node;

    }

    size++;

    return true;

    }

    @Override

    public T pop() {

    if(size == 0){

    return null;

    }

    T data = top.data;

    top = top.pre;

    size--;

    return data;

    }

    @Override

    public T peek() {

    if(size == 0){

    return null;

    }

    T data = top.data;

    return data;

    }

    }

    4、测试

    package com.lin.stack;

    /**

    * 功能概要:

    *

    * @author linbingwen

    * @since  2015年8月29日

    */

    public class StackTest {

    /**

    * @author linbingwen

    * @since  2015年8月29日

    * @param args

    */

    public static void main(String[] args) {

    MyStack myStack1 = new MyArrayStack();

    MyStack myStack2 = new MyListStack();

    for(int i =0;i<30;i++){

    myStack1.push(i);

    myStack2.push(i);

    }

    System.out.println("数组实现的栈输出如下 ");

    for(int j =0;j<30;j++){

    System.out.print(myStack1.pop()+"  ");

    }

    System.out.println();

    System.out.println("链表实现的栈输出如下 ");

    for(int k =0;k<30;k++){

    System.out.print(myStack2.pop()+"  ");

    }

    }

    }

    输出结果如下:

    6ac829c7789566c246f1811149a2b304.png

    或者 看这里:

    数组实现的栈输出如下

    29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10  9  8  7  6  5  4  3  2  1  0

    链表实现的栈输出如下

    29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10  9  8  7  6  5  4  3  2  1  0

    http://blog.csdn.net/evankaka/article/details/48088983

    展开全文
  • Java数组链表的互换

    千次阅读 2019-09-21 09:48:55
    package 链表; import java.util.ArrayList; class Node{ int val; Node next; Node(int val){ this.val = val; } } public class Main1 { public static Node arrayToNode(int[] arr...
    package 链表;
    
    import java.util.ArrayList;
    
    class Node{
        int val;
        Node next;
        Node(int val){
            this.val = val;
        }
    }
    public class Main1 {
        public static  Node arrayToNode(int[] arr){
            Node head = new Node(arr[0]); // 把数组的第一个位置定义为头结点
            Node other = head; // 一个指针,此时指向头结点
            for(int i=1;i<arr.length;i++){ //头结点已经定义,从1开始
                Node temp = new Node(arr[i]);
                other.next = temp;
                other = other.next;
    
            }//在此处打印结点容易导致head的变化
            return head;
        }
        public static void printNode(Node node){
            while(node!=null){
                System.out.print(node.val+" ");
                node = node.next;
            }
        }
        public static void nodeTolist(Node node){
            ArrayList<Integer> list = new ArrayList<>();
            while(node != null){
                list.add(node.val);
                node = node.next;
            }
            System.out.println();
            System.out.println(list);
        }
        public static void main(String[] args){
            int[] arr = new int[]{1,2,3,4,5,6};
            Node node = arrayToNode(arr);
            printNode(node);
            nodeTolist(node);
    
        }
    }
    

     

    展开全文
  • 自定义链表ListNode类public class ListNode {int val;ListNode next;ListNode(int x) {val = x;}}将链表转换成数组//将链表转换成数组public class Test1 {public static void main(String[] args) {Test1 test1 = ...
  • java 动态的数组链表

    2010-06-21 15:28:30
    java 动态的数组链表 java 动态的数组链表 java 动态的数组链表
  • //构造函数中定义了将一个数组传入,将数组转化链表。 //根据构造函数 只需要知道头结点就可以查询链表中所有的信息。 ListNode head = new ListNode ( nums ) ; System . out . println ( head ) ; ...
  • 最近被问到链表,是一个朋友和我讨论Java的时候说的。说实话,我学习编程的近一年时间里,学到的东西还是挺少的。语言是学了Java和C#,关 于Web的学了一点Html+css+javascript。因为比较偏好,学习WinForm时比较认真...
  • 数组简单来说就是将所有的数据排一排存放在系统分配的一个内存块上,通过使用特定元素的索引作为数组的下标,可以在常数时间内访问数组元素的这么一个结构;为什么能在常数时间内访问数组元素?为了访问一个数组...
  • hashMap是我们常用的一种java集合类,在jdk1.8中以数组+链表+红黑树实现。使用put(key, value)存储对象到HashMap中,使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时,我们先对键调用hashCode()...
  • 数组链表

    2021-11-21 11:39:47
    数组第一个元素作为链表头节点 声明临时节点以便缓存上次节点引用 实例化并赋值当前节点给上次节点的 next 属性 移动临时节点指向, 以便下次获取临时节点 最终返回头节点, 而不是临时节点 代码 /** * 数组链表 ...
  • 数组链表都是我们在编码过程中最经常使用的数据结构,数组是一种连续的数据结构,而链表是一种离散的数据结构,我们在编码的过程中经常需要在这两种数据结构之间进行来回的转换,从而来解决我们遇到的一些问题,...
  • 这位老哥的这篇文章写的非常好,结合小破站”硬核空间java“up猪的视频一起观看“https://www.bilibili.com/video/av71408100”效果更佳。 概述 文章的内容基于JDK1.7进行分析,之所以选用这个版本,是因为1.8的...
  • HashMap(数组+链表+红黑树)

    千次阅读 2020-08-24 12:08:19
    HashMap(数组+链表+红黑树) HashMap 根据键的 hashCode 值存储数据,大多数情况下可以直接定位到它的值,因而具有很快 的访问速度,但遍历顺序却是不确定的。 HashMap 最多只允许一条记录的键为 null,允许多条记 录...
  • 学习java的同学平常最经常会使用到List、HashMap,这两个类库就是使用到了数组链表和hash表 数组 数据在内存中的结果如图所示,当数组长度为8时在内存中分配了连续的8个内存地址,注意是连续的。 比如说我们new ...
  • public class SingListNode { //链表类 int val; SingListNode next; public SingListNode(int val) { this.val = val; } ...public class SingListNodeInser { ... 将数组转化链表 */ publ
  • Java中HashMap底层为什么是数组链表

    千次阅读 2019-11-17 20:25:02
    之后被问到HashMap底层为什么是数组链表呢?这样的话,链表一长,在链表中查询的效率不是很低吗? 我:(哑了) 最近看到一个比较有依据的答案,在此做一下答复。 HashMap底层为什么是数组链表呢?在链表中查询的效...
  • 利用二维数组实现一个矩阵类:Matrix。要求提供以下操作:(1)set(introw,intcol,doublevalue):将第row行第col列的元素赋值为value;(2)get(introw,intcol):取第row行第col列的元素;(3)width():返回矩阵的列数;...
  • Java数组到HashMap之算法解释

    千次阅读 2017-08-01 15:30:00
    一、数组是什么?...Java示例代码: int[] array = new int[5] 忽略对象头信息和数组长度信息,JVM执行时会在堆中分配20个字节的内存空间,看起来就是这样的: 这样的数据结构可以很方便地通过数组下...
  • java数组和集合

    2021-03-08 09:50:52
    java中,集合类是用来存放对象的。对于集合的使用是通过实例化集合类得到集合对 象。而集合对象则代表以某种方式组合到一起的一组对象,对于这组对象的使用是通过引用集合对象来进行的。通过班级的例子来给集合...
  • 0、定义一个Java数组String[] aArray = new String[5];String[] bArray = {"a","b","c", "d", "e"};String[] cArray = new String[]{"a","b","c","d","e"};第一种是定义了一个数组,并且指定了数组的长度,我们这里...
  • java数组遍历的方法

    千次阅读 2020-05-04 23:14:19
    java中遍历数组的三种方法 方法一:for循环进行下标遍历 int[] array = {1,2,3,4,5,6,7,8,9,0}; for(int i = 0;i < array.length;i++){ System.out.print(array[i] + " "); } //输出结果 //1 2 3 4 5 6 7 8 9 0 ...
  • Java数组操作十大方法

    2021-03-05 15:45:54
    定义一个Java数组String[] aArray = new String[5];String[] bArray = {"a","b","c", "d", "e"};String[] cArray = new String[]{"a","b","c","d","e"};第一种是定义了一个数组,并且指定了数组的长度,我们这里称它...
  • 数组链表是数据结构中最基础的两种结构,其他的都是由这两者转化而来; 因此,掌握这两种结构至关重要!下面,时光就带大家来学习一下数组链表; 思维导图: 1,什么是线性表? 线性表是具有相同类型的n(>=...
  • 一、Java中字符串与数组之间的转化 1、字符串->数组 (1)转换字符数组java String 类中的toCharArray()方法将字符串转换为字符数组 String str = "123abc"; char[] arr = str.toCharArray(); // char数组 ...
  • 第一部分是首先说下数组链表的区别~数组是大家常用的而熟知的,利用链表对比数组这样可以加深对链表的记忆。第二部分就是链表的代码实现,加深理解。关于单链表:1、概念在单链表中由于数据元素的存储空间一般不是...
  • Java链表基本操作和Java.util.ArrayList今天做了一道《剑指offer》上的一道编程题“从尾到头打印链表”,具体要求如下:输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。一开始我想的是通过两次遍历链表,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,653
精华内容 10,661
关键字:

java数组转化成链表

java 订阅