精华内容
下载资源
问答
  • 在Python中初始化链表

    2021-01-05 23:05:00
    建立链表函数,并且赋值,链接到下一个位置的示例代码 class Node(object): “”“单链表的结点”"" def __init__(self, item): # item存放数据元素 self.val = item # next是下一个节点的标识 self.next = None...

    如果帮助到您,还请点个关注吧,hahaha

    建立链表函数,并且赋值,链接到下一个位置的示例代码

    class Node(object):
    “”“单链表的结点”""

    def __init__(self, item):
        # item存放数据元素
        self.val = item
        # next是下一个节点的标识
        self.next = None
    

    node1 = Node(9)
    node2 = Node(9)
    node3 = Node(9)
    node4 = Node(9)
    node5 = Node(9)
    node6 = Node(9)
    node7 = Node(9)

    将结点添加到链表
    l1 = node1

    将第一个结点的next指针指向下一结点
    node1.next = node2
    node2.next = node3
    node3.next = node4
    node4.next = node5
    node5.next = node6
    node6.next = node7

    展开全文
  • 局部变量的未初始化数值一般都被系统初始化为随机值, 主函数在栈区分配空间,无论是全局指针,全局数组,字符数组,整型数组,double数组,全局结构体变量未初始化,都在.bss区域初始化。 数据区:字符串常量区...

    1.全局变量的未初始化的数值一般都被系统初始化为0
    局部变量的未初始化数值一般都被系统初始化为随机值, 主函数在栈区分配空间,无论是全局指针,全局数组,字符数组,整型数组,double数组,全局结构体变量未初始化,都在.bss区域初始化。
    数据区:字符串常量区(只读数据区),未初始化区域(.bss区域),已初始化区域。
    在这里插入图片描述
    2.购买链表节点函数

    ListNode* Buynode()
    {
    	ListNode* s = (ListNode*)malloc(sizeof(ListNode));
    	if (nullptr == s) exit(1);
    	memset(s, 0, sizeof(ListNode));
    	return s;
    }
    

    3.链表初始化函数

    void Init_List(LinkList* plist)
    {
    	assert(plist != nullptr);
    	plist->head = Buynode();
    	plist->cursize = 0;
    }
    

    4.查找链表中某个数值,返回此下标

    ListNode* FindValue(LinkList* plist, ElemType val)
    {
    	assert(plist != nullptr);
    	ListNode* p = plist->head->next;
    	while (p != nullptr && p->data != val)
    	{
    		p = p->next;
    	}
    	return p;
    }
    

    5.打印出链表中数值

    void Print_List(LinkList* plist)
    {
    	assert(plist != nullptr);
    	ListNode* p = plist->head->next;
    	while (p != nullptr);
    	{
    		printf("%5d", p->data);
    		p = p->next;
    	}
    	printf("\n");
    }
    

    6.删除链表中某一个数值

    bool Erase_Item(LinkList* plist, int pos)
    {
    	assert(plist != nullptr);
    	ListNode* pre = FindPos_Pre(plist, pos);
    	if (pre == nullptr || pre->next == nullptr)return false;
    	ListNode* q = pre->next;
    	pre->next = q->next;
    	free(q);
    	q = nullptr;
    	plist->cursize -= 1;
    	return true;
    }
    

    7.查找链表中某一个数值的节点

    ListNode* Findpos(LinkList* plist, int pos)
    {
    	assert(plist != nullptr);
    	if (pos<1 || pos>plist->cursize) return nullptr;
    	ListNode* p = plist->head->next;
    	int i = 1;
    	while (i < pos)
    	{
    		p = p->next;
    		++i;
    	}
    	return p;
    }
    

    8.查找链表中某一个数值,返回它的上一个结点的位置

    ListNode* FindPos_Pre(LinkList* plist, int pos)
    {
    	assert(plist != nullptr);
    	if (pos<1 || pos>plist->cursize+1) return nullptr;
    	ListNode* p = plist->head;
    	int i = 1;
    	while (i < pos)
    	{
    		p = p->next;
    		++i;
    	}
    	return p;
    }
    

    9.在链表中某个位置插入元素

    bool Insert_Item(LinkList* plist, int pos, ElemType val)
    {
    	assert(plist != nullptr);
    	ListNode* p = FindPos_Pre(plist, pos);
    	if (p == nullptr) return false;
    	ListNode* s = Buynode();
    	s->data = val;
    	s->next = p->next;
    	p->next = s;
    	plist->cursize += 1;
    	return true;
    }
    

    10.在链表最前边插入元素,在链表最后边插入元素,在链表中某个位置插入数组

    void push_back(LinkList* plist, ElemType val)
    {
    	Insert_Item(plist, plist->cursize + 1, val);
    }
    void push_front(LinkList* plist, ElemType val)
    {
    	Insert_Item(plist, 1, val);
    }
    void Insert_Ar(LinkList* plist, int pos, ElemType* ar, int n)
    {
    	for (int i = 0; i < n; ++i)
    	{
    		Insert_Item(plist, pos, ar[i]);
    	}
    }
    

    11.主函数实现调用函数实现功能

    int main()
    {
    	LinkList mylist;
    	Init_List(&mylist);
    	for (int i = 0; i < 10; ++i)
    	{
    		push_front(&mylist, i + 10);
    	}
    	Print_List(&mylist);
    	return 0;
    }
    
    展开全文
  • 链表初始化C++

    2021-05-13 16:10:07
    #include <iostream> using namespace std;... Node(int _data) { //显式构造函数,每次对新声明的节点类的对象进行初始化 data = _data; next = NULL; } }; //链表类 class LinkList { publi

    初始化

    #include <iostream>
    #include<malloc.h>
    #include<stdlib.h>
    
    using namespace std;
    
    typedef struct ListNode
    {
    	int data;
    	ListNode* next;
    }ListNode;
    
    ListNode* List()//返回 创建链表的返回值
    {
    	int i = 0;
    	ListNode *head = nullptr;
    	ListNode *pNew = nullptr;
    	ListNode* pEnd = nullptr;
    
    	int x = 0;
    	head = (ListNode*)malloc( sizeof(ListNode) );
    
    	while (1)
    	{
    		cout << "input the data: " << endl;
    		cin >> x;//逐个输入,每输入一个就enter,直到输入零
    
    		if (x == 0) break;
    
    		pNew = (ListNode*)malloc(sizeof(ListNode));
    		pNew->data = x;
    
    		if (++i == 1) 
    		{ 
    			head->next = pNew; 
    		}
    		else 
    		{ 
    			pEnd->next = pNew;
    		}
    
    		pEnd = pNew;
    	}
    
    	pEnd->next = NULL;
    	return head;
    }//不需要括号
    
    
    void WriteList(ListNode* head)
    {
    	
    }
    
    int main()
    {
    	ListNode* head;
    
    	head = List();
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 由于java中没有结构体,所以用一个类来定义链表,代码如下主要包括一个data,还有一个指向后面一个节点的next重写了toString函数,返回你想要的数据定义链表的类:package LinkNode;public class LinkNode {public ...

    由于java中没有结构体,所以用一个类来定义链表,代码如下

    主要包括一个data,还有一个指向后面一个节点的next

    重写了toString函数,返回你想要的数据

    定义链表的类:

    package LinkNode;

    public class LinkNode {

    public String data;

    public LinkNode next;

    public String getData(){

    return data;

    }

    public void setData(String data){

    this.data=data;

    }

    public LinkNode getNext(){

    return next;

    }

    public void setNext(LinkNode next){

    this.next=next;

    }

    public LinkNode(String data,LinkNode next){

    super();

    this.data=data;

    this.next=next;

    }

    public LinkNode(){

    super();

    }

    @Override

    public String toString(){

    return "data:"+data+" next->"+next;

    }

    }

    1.初始化链表:

    public static void initLinkNode(LinkNode L){

    L.setData("#");

    L.setNext(null);

    }

    2.遍历链表,返回链表的长度

    public static int traverse(LinkNode L){

    LinkNode p = L;

    int count = 1;

    while(p.next!=null){

    p = p.next;

    count++;

    }

    return count;

    }

    3.把链表L的data转化为StringBuffer输出,输出结果为字符串

    public static StringBuffer outputLinkNode(LinkNode L){

    StringBuffer str = new StringBuffer("");

    LinkNode p = L;

    for(@SuppressWarnings("unused")

    int i=0;;){

    str.append(p.data);

    if(p.next!=null){

    p = p.next;

    }

    else{

    break;

    }

    }

    return str;

    }

    4.在链表L的尾部插入一个节点,值为data

    public static void insertLinkNode(LinkNode L,String data){

    LinkNode p = L;

    LinkNode q = new LinkNode();

    for(@SuppressWarnings("unused")

    int i=0;;){

    if(p.next==null){

    q.setData(data);

    q.setNext(null);

    p.setNext(q);

    System.out.println("Insert "+data+" success.");

    break;

    }

    else{

    p = p.next;

    }

    }

    }

    5.删除第n个节点(从0开始)

    public static void deleteLinkNode(LinkNode L,int n){

    int count = 1;

    LinkNode p = L;

    for(@SuppressWarnings("unused")

    int i;;){

    if(count == n){

    p.setNext(p.next.next);

    break;

    }

    else{

    count++;

    p = p.next;

    }

    }

    }

    6.从index=n开始遍历,如果后面出现str,则返回true否则返回false

    public static int lastIndex(LinkNode L,String str){

    LinkNode p = L;

    int flag = 0;

    for(int i=0;i

    if(p.data==str){

    //System.out.println(i);

    flag = i;

    }

    p = p.next;

    }

    return flag;

    }

    测试程序:

    package LinkNode;

    public class Quarrel extends Method{

    public static void main(String[] args){

    LinkNode L = new LinkNode();

    System.out.println("初始化:");

    initLinkNode(L);

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

    System.out.println("插入节点:");

    insertLinkNode(L,"R");

    insertLinkNode(L,"R");

    insertLinkNode(L,"L");

    insertLinkNode(L,"L");

    insertLinkNode(L,"R");

    insertLinkNode(L,"L");

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

    int count = traverse(L);

    System.out.println("节点个数:"+count);

    StringBuffer str = outputLinkNode(L);

    System.out.println(str);

    //最后一个L的位置

    int lastindex = lastIndex(L,"L");

    System.out.println("最后一个L的位置:"+lastindex);

    System.out.println("删除一个节点");

    deleteLinkNode(L,2);

    count = traverse(L);

    System.out.println("节点个数:"+count);

    str = outputLinkNode(L);

    System.out.println(str);

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

    }

    }

    结果如下:

    0f8059c97452e363cb27341aefed360d.png

    原文:https://www.cnblogs.com/fanghuiplus/p/9446376.html

    展开全文
  • 单链表的初始化 void createlist(linklist *L) { L = new node; if(L==NULL) { cout 申请内存失败" ; } L->next = NULL; /*如果有具体操作就继续实现*/ } 三.单链表的取值 void getlist(linklist *L,int i,int &e) {...
  • 我们对链表进行初始化时:主要有两种方法 (1)采用一级指针对链表进行初始化 (2)采用二级指针对链表进行初始化 我们一般采用第一种方法的比较多,特别是对于刚刚接触链表的萌新,或者对于指针的理解不是很熟悉的...
  • 链表初始化赋值以及插入 下面展示一些 代码。 #include<iostream> #include<stdlib.h> //创建一个结构体来表示链表的结点类型 struct ListNode{ int val; struct ListNode *next; ListNode(int x):...
  • # 首先定义结点类,链表结点包括值域 val,和 next 指针 class ListNode: def __init__(self, x): self.val = x self.next = None class LinkList: def __init__(self): ... # 用 list 初始化一个 linklis
  • 废话少说,先上代码: #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node* pNext;... //初始化链表 void traverse_list(PNODE pHead); //为链表添加元素 bool
  • 刚接触linux不久,今天想要用linux写个小程序,结果在初始化函数这一步怎么也过不去,请教程序哪里有问题typedefstructLink_node{intdata;structLink_node*next;}node,*Link_list;voidinit_Linklist(Link_list*L){...
  • 链表是一个数据结构,结构体,链表定义的链表对象,本身占用内存空间,有自己的地址 链表的成员,可以是指针,指针的类型,可以是链表结构体类型 链表就像自行车的链条一样连接起来,内存地址可以连续,也可以不...
  • memset()calloc()函数realloc()函数线性表顺序存储结构链式存储结构单链表单链表的状态图单链表结点数据结构定义单链表初始化循环单链表的状态图双向链表的状态图双向循环链表的状态图总结静态存储和动态存储变量从...
  • Java链表基本操作和Java.util.ArrayList今天做了一道《剑指offer》上的一道编程题“从尾到头打印...然后定义一个ArrayList 变量,由于ArrayList是动态数组,不能在未初始化的情况下对任意位置进行插入指定的值。所...
  • 相信有很多数据结构的初学者在学习链表的时候对于malloc感觉很困惑 我们习惯了用int x来定义一个整形变量,而不是利用malloc来堆里面分配内存定义变量 那为什么要这么写? 可不可以不用mallloc创建? 带着问题我们来...
  • 第五百页17.3.4 实现接口的程序清单17.5中的初始化链表函数有误 #源代码 void InitializeList(List * plist) { plist = NULL; } #更正 void InitializeList(List * plist) { *plist = NULL; } 应该把指向头节点...
  • ————————————————————————————————————————————双向循环链表 //遍历等执行方法与普通双向链表相同,不单独列举- - - - - - - - - - - - - - - - - - - - - - - - - - -...
  • 1.双链表定义 //双链表定义 ...2.初始化链表 //初始化链表 bool InitDLinkList(DLinkList &L){ L = (DNode *)malloc(sizeof(DNode)); //创建头结点 if(L==NULL) return false; //内存
  • #include #include/*** 含头节点循环单链表定义,初始化 及创建*/#define OK 1;#define ERROR 0;//函数返回类型,表示函数运行结果的状态typedef intStatus;//定义数据元素类型typedef charElemType;//循环单链表...
  • ————————————————————————————————————————————双向链表- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ...
  • 用 DEV C++ 写C语言实现单链表时,编译没有报错,但是就是走到初始化(InitList)这里就不走了,很明显代码出现了问题。 于是开始断点调试,但是调试也不行,报如下错误: 几番折腾后解决方法如下↓↓↓↓ 2. 解决...
  • 双向链表常见操作如下:建立链表,初始化链表,遍历链表,清空链表,销毁链表,插入节点,删除节点,查找某节点等。 ////2021年3月10日17点35分 #include <string.h> #include <stdlib.h> #include...
  • //创建数组结构体 初始化array和size void array_free( Array *a ) ;//释放数组内存 int array_size( const Array *a ) ;//设置结构体中的size int *array_at( Array *a, int index );//先判断是否越界 若越界 则...
  • 有头链表
  • 初始化双向循环链表3.使用尾插法插入结点4.插入第i个结点(在第i个结点之前插入)4.删除第i个结点5.遍历双向循环链表6.主函数二、全部代码三、运行结果 一、部分实现 1.双向循环链式存储结构 代码如下: /*链式...
  • 链表操作在c语言里我们通过结构体和数组这两种数据结构构造线性表创建顺表表-数组静态分配内存。typedef struct {char data[10];int length;}SqList;bool ListInsert(SqList &L,int i,char e){for (int j = L....
  • 代码#include #include #include /** 使用头节点*/typedef struct node {int data;struct node *prev;...// 初始化void init(PNODE *);// 是否为空bool is_empty(PNODE);// 遍历void traverse(PNODE);/...
  • #include using namespace std;...//初始化带头结点的双链表 bool InitDLinkList(DLinkList& L) { DNode L = new DNode; if (L == NULL) //内存分配失败 return false; L->next = NULL; L->pe
  • 就例如在链表的构建中,链表初始化和销毁为何需要使用一个二级指针,而不是只需要传递一个指针就可以了,其问题的关键就在于c语言的参数传递的方式是值传递那么,这篇文章就来聊一聊在链表初始化中一级指针的传递和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 290,355
精华内容 116,142
关键字:

未初始化链表