精华内容
下载资源
问答
  • 采用C语言实现:完整删除链表指定位置元素的代码。 原链表:3->4->5。现在要删除位置为2处的元素删除后的链表:3->5。 #include <stdio.h> #include <stdlib.h> #include <MacTypes...

    采用C语言实现:完整删除链表中指定位置的元素的代码。

    原链表:3->4->5。现在要删除位置为2处的元素。
    删除后的链表:3->5。

    #include <stdio.h>
    #include <stdlib.h>
    #include <MacTypes.h>
    
    /*定义节点*/
    typedef struct Node {
        int data;
        struct Node *next;
    } LinkedList;
    
    /*使用头插法来构建一个链表*/
    void push(struct Node **head_ref, int new_data);
    
    /*给一个指针的指针作为引用,作为这个链表的头指针,进行删除指定位置的节点*/
    void deleteNode(struct Node **head_ref, int position);
    
    /*打印链表*/
    void printList(LinkedList *node);
    
    int main() {
        LinkedList *head_ref = NULL;
        //注意这里要传取地址符
        push(&head_ref, 3);
        push(&head_ref, 4);
        push(&head_ref, 5);
        deleteNode(&head_ref,2);
        printList(head_ref);
        return 0;
    }
    
    /*
     * 头插法的几步
     * 1.定义一个新的指针,给指针申请空间,使其变成一个新的节点。
     * 2.给这个新的节点data数据域赋值。
     * 3.将这个新的节点的next指针指向原来的开始节点(原头指针指向的节点)
     * 4.将原头指针左移移动到新的节点
     */
    void push(struct Node **head_ref, int new_data) {
    
        LinkedList *new_node = (LinkedList *) malloc(sizeof(LinkedList));
        new_node->data = new_data;
        new_node->next = (*head_ref);
        (*head_ref) = new_node;
    }
    
    /*从给定节点往后打印链表*/
    void printList(LinkedList *node) {
        //节点不为空,循环
        while (node != NULL) {
            //打印节点值
            printf(" %d \n", node->data);
            //指针后移
            node = node->next;
        }
    }
    
    /*删除指定位置的的节点*/
    void deleteNode(struct Node **head_ref, int position) {
    
        //1.首先判断这个链表是否为空
        if (*head_ref == NULL) {
            return;
        }
    
        //2.创建一个指针存储头节点
        struct Node *temp = *head_ref;
    
        //3.如果这个position是0,那么直接移除掉头节点
        if (position == 0) {
            *head_ref = temp->next;
            free(temp);
            return;
        }
    
        //4.从头节点遍历,找到删除位置position的前驱节点,temp指向前驱
        for (int i = 0; temp != NULL && i < position - 1; ++i) {
            temp = temp->next;
        }
    
        //5.如果这个位置比链表还长
        if (temp == NULL || temp ->next == NULL){
            return;
        }
    
        //6.创建一个新的指针指向将要删除的节点的下一个节点
        //temp是删除节点的前驱
        //temp->next 这个节点是即将被删除的节点
        struct Node *next = temp->next->next;
        //7.删除节点
        free(temp->next);
    
        //8.将next节点连接在前驱节点temp后面
        temp->next=next;
    
    }
    

    输出:

     5 
     4 
    
    展开全文
  • public Item delete(int k){ if(isEmpty()) throw new RuntimeException("List is empty"); int i = 1; Node prev = null, curr = first; if(size() &gt;= k){ ... ...
    public Item delete(int k){
    		if(isEmpty())
    			throw new RuntimeException("List is empty");
    		int i = 1;
    		Node prev = null, curr = first;
    		if(size() >= k){
    			while(i < k){
    				prev = curr;
    				curr = curr.next;
    				i++;
    			}
    			if(curr.next == null){
    				prev.next = null;
    				last = prev;
    			}else{
    				prev.next = curr.next;
    				curr.next = null;
    			}
    			
    		}else{
    			throw new RuntimeException("k > N");
    		}
    		N--;
    		return curr.item;
    	}

    展开全文
  • 删除链表指定位置元素

    千次阅读 2016-04-16 15:30:03
    #include #include using namespace std; typedef int Elemtype; typedef struct node {  Elemtype data;  struct node* next; }; node* Greatlist(int n) //创建链表 {  node

    #include<stdio.h>
    #include<iostream>
    using namespace std;
    typedef int Elemtype;
    typedef struct node {
        Elemtype data;
        struct node* next;
    };
    node* Greatlist(int n)                       //创建链表
    {
        node*p, *r, *head = NULL;
        r = (node*)malloc(sizeof(node));
        int i;
        Elemtype c;
        for (i = 1; i <= n; i++)
        {
            cin >> c;
            p = (node*)malloc(sizeof(node));
            p->data = c;
            p->next = NULL;
            if (head == NULL)
            {
                r=head= p;
            }
            else
            {
                
                r->next = p;
                r = p;
            }
        }
        return head;
    }

    int Linklen(node*head)                        //返回链表长度,本题中用不到这个函数
    {
        int count = 0;
        node* p = head;
        while (p!=NULL)
        {
            count++;
            p=p->next;
        }
        return count;
    }

    node* getPtr(node* head, int pos)              //得到指定位置的链表元素的指针
    {
        node* p = head;
        int i;
        for (i = 1; i < pos; i++)
        {
            p = p->next;
        }
        return p;
    }

    int main()
    {
        node*l;
        cout << "input 10 interger:" << endl;
        l = Greatlist(10);
        cout << "the length is:" << Linklen(l) << endl;
        node*p, *q;
        p = getPtr(l, 4);
        q = p->next;
        p->next = q->next;
        free(q);
        cout << "the linklist after deleting the fifth node :" << endl;
        p = l;
        while (p)
        {
            cout << p->data << " ";
            p = p->next;
        }
        return 0;
    }



    展开全文
  • 参考:链表的12种基本操作(C++实现) 链表的几个基本操作代码只要弄懂指针、链表的数据结构就不难实现,代码如下,不懂得话可以留言询问,有错误的话请指正 #include<iostream> using namespace std; //定义...

    参考:链表的12种基本操作(C++实现)

    链表的几个基本操作代码只要弄懂指针、链表的数据结构就不难实现,代码如下,不懂得话可以留言询问,有错误的话请指正

    运行环境 vs2019

    #include<iostream>
    using namespace std;
    
    //定义表结点的数据结构:数据+指针
    struct ListNode
    {
        int value;
        ListNode* next;
    };
    
    void creatList(ListNode * linkList,int n)
    {
        //链表动态增加元素 
        //定义创建新的元素的辅助指针 *p
       ListNode* p = linkList;
        for (int i = 0; i < n; i++)
        {
            //动态创建新的链表节点并初始化
            ListNode* newNode = new ListNode;   //开辟了链表的存储空间  不能用delete释放
            newNode->value = i;
            newNode->next = NULL;
            //辅助指针把新创建的节点接到链表的结尾
            p->next = newNode;
            //辅助指针后移指向最新的节点
            p = newNode;
            //delete newNode;  这里不能释放newNode,因为此时 p = newNode  ,是链表的最后一个节点
        }
        //linkList = linkList->next;  //执行这个语句就把头指针指向第一个元素 
    
    }
    
    void outputList(ListNode* linkList)
    {
        if (linkList == NULL|| linkList->next == NULL)
    	{
            cout << endl << "链表为空"<<endl;
    		return;
    	}
    	else
    	{
            cout << "链表的元素:";
    		ListNode* p = linkList;
    		while (p->next != NULL)
    		{
    			p = p->next;
    			cout << p->value << " ";
    		}
            cout << endl;
    	}
    }
    int lengthOfList(ListNode* linkList)
    {
        if (linkList == NULL || linkList->next == NULL)
        {
            return 0;
        }
        else
        {
            ListNode* p = linkList;
            if (p != NULL)     //如果没有判断p是否赋值成功vs2019会警告越界
            {
    			int count = 0;
    			while (p->next != NULL)
    			{
    				p = p->next;
    				count++;
    			}
    			return count;
            }
            
        }
        
    
    }
    int getValue(ListNode* linkList, int index)
    {
    	//判断是否越界
    	if (index <= lengthOfList(linkList))
    	{
    		ListNode* p = linkList;
    		for (int i = 0; i < index; i++)
    		{
                p = p->next;
    		}
            return p->value;
    	}
    
    }
    void insert(ListNode* linkList, int site, int e)
    {
        //判断是否越界
        if (site <= lengthOfList(linkList))
        {
            ListNode* p = linkList;
            for (int i = 0; i < site; i++)
            {
                p = p->next;
            }
            ListNode* pTemp = new ListNode;
            pTemp->value = e;
            pTemp->next = p->next;
            p->next = pTemp;
            cout << "插入元素成功"<<endl;
        }
    }
    void deleteE(ListNode* linkList, int site)
    {
        if (site <= lengthOfList(linkList))
        {
            ListNode* p = linkList;
            for (int i = 0; i < site; i++)
            {
                p = p->next;
            }
            ListNode* pTemp = new ListNode;
            pTemp = p->next;
            p->next = pTemp->next;
            delete pTemp;
            cout << "删除元素成功" << endl;
        }
    }
    void deleteList(ListNode* linkList)
    {
        ListNode* p = linkList->next;  //定义p为首节点
        while (p != NULL)
        {
            ListNode* pTemp=p;
            p = p->next;
            delete pTemp;
        }
        linkList->next = NULL;
        cout << endl << "删除链表成功" << endl;
    }
    
    int main()
    {
        //创建头指针
        ListNode* list = new ListNode;
       
        //头指针初始化
        list->next = NULL;
        int n;
        
        cout << "输入链表长度:";
        cin >> n;
        
        // 创建链表
        creatList(list, n);
        
        //输出链表的所有元素
        outputList(list);
    
        //获取链表的长度:
        int len = lengthOfList(list);
        cout << "链表的长度:" << len << endl;
    
        //获取指定节点的值
        cout << endl << "输入要获取链表的第几个元素:";
        int index;
        cin >> index;
        int E = getValue(list, index);
        cout<<"第"<<index<<"个元素的值为:" << E<<endl;
    
        //在指定位置插入元素:
        cout << endl << "输入插入链表元素的位置:";
        int site;
        cin >> site;
        cout << endl << "输入插入链表的元素:";
        int e;
        cin >> e;
        insert(list, site, e);
        outputList(list);
    
        //在指定位置删除元素:
        cout << endl << "输入插入要删除的链表元素的位置:";
        cin >> site;
        deleteE(list, site);
        outputList(list);
    
        //清空链表
        cout << "是否清除链表的所有节点? 输入1或0:";
        int ifDelete;
        cin >> ifDelete;
        while (ifDelete != 0 && ifDelete != 1)
        {
            cout << endl << "输入错误,请重新输入:" << endl;
            cin >> ifDelete;
        }
        if (ifDelete == 0)
        {
            cout << endl << "结束" << endl;
        }
        else
        {
            deleteList(list);
            outputList(list);
        }
    
        //别忘了delete
        delete list;
        return 0;
    }
    
    展开全文
  • 学习心得:C语言中,要掌握链表,除了基本的知识外,还要有对指针的理解在这里特别是指向结构体的指针,由于知识比较抽象,必要时可通过画图方便理解。 运行结果 源代码(每个函数都有说明参数和功能) #include ...
  • public interface Link { //定义行为标准 void add(Object obj);...//删除指定位置数据 boolean set(int index,Object obj);//改变指定位置数据 Object get(int index);//查找指定位置数据 int ...
  • 删除指定节点 //删除某个结点 int list_delete(linklist H,int pos){ if(H==NULL){ printf("删除结点失败,链表为空!\n"); return -1; } //获取要删除结点的上一个结点(前驱) listnode *lastnode = list_...
  • 链表删除指定值的元素

    千次阅读 2013-11-19 20:37:32
    在网上看到很多删除链表中的元素都是指定位置的,如何删除所有值为x的节点呢,下面以int节点的单链表为例说明: 这是C++类中的实现 void List::removeData(int data) { for(Node** cur = &m_head;*cur;) { ...
  • 1.删除无头单链表的非尾节点 函数原型:void DelNotTail(pNode pos); 分析:无头单链表与有头单链表的区别在于找其中的节点不能使用遍历的方法,我们这里定义一个指针cur,让它指向pos的next,然后将cur->data给pos-...
  • 题目题目:在长度为n的整数序列中删除指定为序的m个元素,按照原顺序输出剩余的元素。.../*删除指定位置元素,注意位序从0开始*/ int DelList(sqlist *L,int i) { int k; if(i<0 || i>L->length
  • // 链表基本操作.cpp : 定义控制台应用程序的入口点。 // // 链表基本操作.cpp : 定义控制台应用程序的入口点。 // #include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef ...
  • void LinkList::DeleteElemAtPoint(DataType data) { ElemType * ptemp = Find(data); //查找到指定数据的节点位置 ... //删除指定位置的节点 delete ptemp; ptemp = NULL; } ``` ```
  • 删除单链表指定位置元素

    千次阅读 2018-08-13 10:57:47
    #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;time.h&gt; typedef struct Node { ...void print(Node L) //输出全部链表元素 { Node* p=L.next; while (p!=N...
  • 解题思路:这题与找到链表第n个元素差不多,就多了一步删除,设置两个指针,一个指针先走到指定位置,另一个与现在这个指针一起走,找到结点后,一个覆盖另一个即可 解题思路:class Solution { public:  L
  • 数据结构——单链表基本操作(初始化,销毁,统计元素个数,指定位置元素,查找元素位置,求前驱后继,插入,删除,清空,遍历输出) 1.实验目的 通过该实验,深入理解链表的逻辑结构、物理结构等概念,掌握链表基本...
  • 一般来说,我们用数组这种数据结构最多的情况,是用来做查询,时间复杂度为O(1)...数组的插入和删除元素,一般时间复杂度都是O(N),比较麻烦,所以对于插入和删除操作中,不建议选用数组这种数据结构,可以考虑链表...
  • 文章目录双向链表构建双向链表判断链表是否为空(与单链表同)链表长度遍历添加元素:头插法添加元素:尾插法添加元素指定位置删除节点查找节点是否存在单向循环链表构建单向循环链表判断链表是否为空链表长度遍历...
  • 链表:&emsp &nbsp 链表是一种物理存储单元上非连续...nbsp下面直接通过代码进行展示:包括初始化一个可以指向任何数据类型的链表链表中指定位置插入节点元素链表删除指定位置的节点元素、获取链表的长度
  • 203. 移除链表元素

    2021-02-17 18:55:22
    题目要求: 删除链表中等于给定值 val 的所有节点。...2.所要去除的元素链表内的某个位置或者链尾,则定义一个结构体指针prev指向cur指向的前一个位置,就是记录所要去除元素前一个元素位置,方便进行
  • 文章目录问题描述问题分析步骤罗列解题代码复杂度分析GitHub代码 问题描述 ...删除指定值节点; 链表没有保证排序 原地操作,不能打乱链表其余节点相对位置 问题分析 这个题目难度为“简答”,所...
  • 双向链表1.1 双向链表创建1.2 双向链表插入结点1.3 双向链表删除指定结点1.4 双向链表删除指定元素1.5 双向链表查找元素位置1.6 双向链表更新结点数据1.7 双向链表遍历2. 双向循环链表2.1 双向循环链表创建2.2 双向...
  • 一:java的链表是一个非常有用的数据结构,在频繁的对数据结构进行删除,插入等操作时,可以比数组等数据结构更加节省资源。最近在一个小项目中需要通过对具有多属性的数据进行边读取边排序,通常情况下,我们会使用...
  • 双向链表

    2016-12-11 16:47:06
    删除双向列表指定位置的的结点 1.定义循环链表和双向链表是对单链表的改进,仍属于链存储结构 双向链表的结点包括一个数据域和两个指针域,后继指针和前继指针域 双向链表的后继链和前继首尾相连,为空双向链表,又...
  • Java 数据结构:单向链表链表: 末尾添加元素, 插入元素, 获得指定位置的元素, 删除指定位置元素数组和链表的优劣链表实现代码实现测试 链表: 末尾添加元素, 插入元素, 获得指定位置的元素, 删除指定位置元素 数组和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 568
精华内容 227
关键字:

链表删除指定位置元素