单链表的的查找与删除(C)-CSDN论坛

单链表的的查找与删除(C) [问题点数：20分，结帖人uloborid]

⋅SQL-Server2005出现“对于造型说明无效的字符”错误，求解！！！ ⋅用ODBC创建SQL-Server数据源的问题 ⋅麻烦各位帮我看看这个错误！！！谢谢！！ 更多帖子 关注私聊空间博客 uloborid 本版专家分：0 结帖率 93.33%: 感觉就是主函数有问题,请大家帮我看看应该怎么写??
题目是:
建立并输出单链表A,D,E,F,H,I,F;查找到F,并删除.输出结果为A D E H I
#include "string.h"
#include "stdio.h"
#define null 0
typedef char datatype;
typedef struct node
{
datatype data;
struct node *next;
}listnode;
typedef listnode *linklist;
listnode *p;
linklist head;

linklist createlistr(void)
{
char ch;
linklist head;
listnode *s,*r;
head=null;r=null;
while ((ch=getchar())!='\n')
{
s=(listnode *)malloc(sizeof(listnode));
s->data=ch;
if (head==null)
head=s;
else
r->next=s;
r=s;
}
if (r!=null)
r->next=null;
return head;
}

listnode* getnode(linklist head,int i)
{
int j;
listnode *p;
p=head;j=0;
while(p->next&&j<i)
{
p=p->next;
j++;
}
if(i==j)
return p;
else
return null;
}

void deletelist(linklist head ,int i)
{
listnode *p,*r;
p=getnode(head,i-1);
if(p==null||p->next==null)
error("position error");
r=p->next;
p->next=r->next;
free(r);
}

main()
{
linklist head;
listnode *p;
printf("please input which character are you search\n");
head=linklist createlistr();
p=deletelist(head,);
while(p=='')
{
 printf("%c",p->datatype);
 p=p->next;
}
}

0 2007-12-30 15:57:09

回复数 4 只看楼主引用举报楼主

⋅百度之星复赛被蹂躏了 ⋅问一到概率论的题目 ⋅问一道具体数学上的题目，期待高手进来解决 更多帖子 关注私聊空间博客 lyg_wangyushi 本版专家分：0

#include "string.h"
#include "stdlib.h"
#include "stdio.h"
#define null 0
typedef char datatype;
typedef struct node
{
datatype data;
struct node *next;
}listnode;
typedef listnode *linklist;
listnode *p;
linklist head;

linklist createlistr(void)
{
char ch;
linklist head;
listnode *s,*r;
head=null;r=null;
while ((ch=getchar())!='\n')
{
s=(listnode *)malloc(sizeof(listnode));
s-> data=ch;
if (head==null)
head=s;
else
r-> next=s;
r=s;
}
if (r!=null)
r-> next=null;
return head;
}

listnode* getnode(linklist head,int i)
{
int j;
listnode *p;
p=head;j=0;
while(p&&j<i)
{
p=p-> next;
j++;
}
if(i==j)
return p;
else
return NULL;
}

linklist deletelist(linklist head ,int i)
{
listnode *p,*r;
p=getnode(head,i-1);
if(p==NULL)
printf("position error");

r=p-> next;
p-> next=r-> next;
free(r);
return p;
}

main()
{
int counter=1;
linklist head;
listnode *p;
printf("please input which character are you search\n");
head=createlistr();
p=head;
while(p!=NULL)
{
if(p->data!='F')
{
printf("%c",p->data);
counter++;
}
else
{
p=deletelist(head,counter);
counter--;
}
p=p->next;
}
return 0;
}

0 2007-12-30 17:58:56

只看TA 引用举报 #1 得分 0

代码比较乱整理一下

0 2007-12-30 18:01:54

只看TA 引用举报 #2 得分 20

单链表的查找和删除单链表的删除操作需要注意的地方: 删除之前必须先找到要删结点的前驱结点,所以在查找判断条件要用p-&gt;next!=NULL 任何要改变链表本身的操作(如增加,删除,),都不能乱动头结点的位置,而是需要额外定义一个指针指向头结点,然后用这个指针操作 #include &lt;iostream&gt; #include&lt;stdlib.h&gt; typedef struct LNod...

lyg_wangyushi 本版专家分：0: 对不起，上面的代码只给出了删除的部分

0 2007-12-31 09:18:51

只看TA 引用举报 #3 得分 0

单链表的定义，查找与删除自己写的，不怎么好，还请大家见谅！一下是单链表的定义： typedef struct LNode { ElemType data; struct LNode *next; }LinkList; LinkList *L,*head;

uloborid 本版专家分：0: 啊哈...中间很久一段没上这个论坛了
今天来看下果然还是有大大给出答案了
非常感谢！

0 2008-04-28 08:46:57

只看TA 引用举报 #4 得分 0

单链表的查找，插入和删除用c++实现了单链表的查找，插入和删除，简单直观。

收藏帖子

单链表的插入删除查找: #include"seqlist.h"pLinkList CrtatNode(){ pLinkList node = (pLinkList) malloc(sizeof(pLinkList)); node-&gt;next = NULL; return node;} void DestroyNode(pLinkList node){ free(node);} void InitNode(pLink...

C++: 运行结果： Rolls 10 Jam 3 Tea 2 Enter you want to insert after the item: Tea Enter the insert item: Lisa Enter the insert count: 33 Rolls 10 Jam 3 Tea 2 Lisa 33 Do you want to continue <y/n

单链表的建立、查找、删除、插入: 单链表的头插入、尾插入、以及查找、删除、逆置等操作

单链表的创建查找插入删除: 这里有封装好的单链表，里面包含了各种单链表的实现过程

单链表的插入，删除，查找，转置: 单链表的定义线性表的链式存储又称为单链表，它是指通过任意一组的存储单元来存储线性表中的数据元素。在单链表中，每个节点包含一个指向链表下一节点的指针。链表最后一个节点的指针字段的值为NULL，提示链表后面不再有其它节点。它是非随机存取的存储结构，操作时只能从表头开始遍历。通常用 “头指针” 标识一个单链表，头指针为“NULL“ 表示空表，为了操作上的方便，在单链表的第一个节点前附加一个...

单链表的创建、插入、删除、查找: include #include typedef int DataType; typedef struct node{ DataType data; struct node *next; }LinkList,*PLinkList; PLinkList Init_LinkList(void) { PLinkList H; H=(PLinkList)malloc(sizeof(LinkList)); if(H) H->next=NULL; return H; }

单链表的初始化、插入、删除、查找: 单链表的存储结构描述 typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; LNode为结点的类型，LinkList为指向LNode节点类型的指针类型。定义一个LinkList类型的变量 L，作为单链表的头指针，若L==NULL，表长为0，即为空表单链表的初始化 LNode *LinkListI

c语言实现单链表建立，插入，删除，查找，循环链表，静态链表: 单链表结点结构 typedef struct LNode{ ElemType data; struct LNode * next; }LNode, *LinkList; 元素插入头插法，逆向建立单向链表，每次在头结点之后插入元素 LinkList CreateList1 (LinkList L){ LinkList s;//链表元素指针 int x; L

C/C++学习（七）单链表的头插法，尾插法，元素插入、删除和查找 .: 链表也是线性表的一种，与顺序表不同的是，它在内存中不是连续存放的。在C语言中，链表是通过指针相关实现的。而单链表是链表的其中一种，关于单链表就是其节点中有数据域和只有一个指向下个节点的指针域。创建单链表的方法有两种，分别是头插法和尾插法。所谓头插法，就是按节点的逆序方法逐渐将结点插入到链表的头部。反之尾插法就是按节点的顺序逐渐将节点插入到链表的尾部。相对来说，头插法要比尾插法算法简单，但是最后产生

C语言实现单链表创建、删除、查找、插入: 本文将详细的介绍C语言单链表的创建、删除、查找、插入以及输出功能一、创建#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int ElemType; /*结构体部分*/ typedef struct Node { ElemType data; //数值域 struct Node *next; //指针域 }Li...

C语言单链表插入/删除/查找/遍历/递归/合并/排序: 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 1 链表结构 2 链表操作链表操作难度不大，只要我们熟悉其数据结构，说白了就是操作指针。下面附上我对单链表的相关...

单链表查找: //单链表,定义 typedef struct LNode{ datatype data; struct LNode *next; }LNode,*linklist; p=L-&gt;next; //访问元素 p=p-&gt;next; while(p!=NULL) { visit (p-&gt;data); p=p-&gt;next; } //打印元素 vo...

c实现单链表插入和删除: int delete(sqlist *L,int i,elemtype *y) { int j; if(i(*L).len) { printf("删除位置不正确!\n"); return 0; } else { *y=(*L).v[i-1]; for(j=i;j<(*L).len;j++) (*L).v[j-1]=(*L).v[j]; (*L).len=(*L).len-1; return 1; } }

单链表的创建，查找，排序，插入，删除: 1、创建一个带头结点的单链表（头指针为head），且遍历此链表（输出链表中各结点的值）； 2、查找单链表中的第i个结点，并输出结点元素的值； 3、在单链表中的第i个结点前插入一个结点值为e的正整数(从外部输入); 4、删除单链表中的第j个结点； 5、将单链表中的各结点就地逆序（不允许另建一个链表）； 6 查找线性表中的最大元素并输出 7 将线性表中的元素按升序排列；

单链表基本操作：初始化，建立，插入，查找，删除: //////////////////////////////////////////// //单链表的初始化，建立，插入，查找，删除。// //////////////////////////////////////////// #include #include typedef int ElemType; //////////////////////////////////////////

单链表的顺序插入、删除、查找/code/c&c++: #include #include #define MAXLEN 20 typedef struct node { int data; node * next; }node; void Createnode(node * & l)//顺序插入节点 { static int len = 0; if(len >= MAXLEN) { printf("L

单链表的创建，输出，插入，删除，查找。: #include&lt;malloc.h&gt; #include &lt;stdio.h&gt; typedef int datatype; typedef struct LNode{ datatype data; struct LNode *next; } *node; void scan(node&amp;head,int n)//输入 { head=(node)malloc...

单链表的创建、查找、删除、添加、合并: 单链表的创建、查找、删除、添加、合并

数据结构之单链表（尾插法）查找、插入和删除: 这一次的难度主要体现在长，常常的代码让人望而生畏，不过，只要理解清楚了查找、插入和删除就好办了代码#include #include typedef struct node { int data; struct node*next; }node; node*creat() { node*head,*q,*p; char ch;

对单链表进行插入、删除、查找操作: 根据键盘输入数据建立一个单链表，并输出该单链表；根据屏幕菜单的选择，进行数据的插入、删除、查找操作，并在插入或删除后，再输出单链表； #include&lt;stdio.h&gt; typedef struct LNode { int data;//节点的数据域 struct LNode *next;//节点的指针域 }LNode, *LinkList;//LinkList为指向结构体...

可视化实现单链表插入，删除，查找: 可视化实现单链表插入，删除，查找 。可以使用JAVA/C++

单链表的一些基本操作排序查找删除等等: #include&lt;stdafx.h&gt; #include&lt;stdlib.h&gt; #define length sizeof(struct node) typedef struct node { int data; struct node *next; } Test; Test *head, *p, *q, *r;//定义遍历指针 //带有头结点的链...

【链表】单链表创建，删除，插入，查找: 链表链表是线性表的链式存储结构，是用一组任意的存储单元存储线性表的数据元素（存储单元在内存中是不连续的）。每个数据单元有两部分组成，一个是数据域，存储数据值；另一个是指针域，指向下一个数据单元。这样的数据单元叫做结点。优点相比于顺序表，在插入和删除元素时，效率很高；缺点：链表的元素是不支持随机访问的，想要知道某个元素，只能从头结点开始遍历整个链表，因此链表访问随机元素的平均时间复杂度是O（n）；

单链表的创建，插入，删除，查找，求长度: 实现了单链表的创建，插入，删除，查找，求长度等基本操作

查找（删除）单链表的倒数第k个结点: 1.查找单链表的倒数第k个结点（只能遍历一次链表） 2.删除单链表的倒数第k个结点对于第一个问题，如果可以两次遍历链表，我们就可以先计算出链表的长度，然后再减去k-1就能求得倒数第k个结点但只能遍历一次链表，我们就可以用使用两个指针front，back，让front先走，走k-1个结点，然后再让front和back同时走当front走到最后结点的时候，back就走到了倒数第k个结点 ...

java实现单链表的增加，删除，查找，打印: 原文地址：http://liuyanzhao.com/2230.html 刚才传了一个java实现顺序表的基本功能的代码，下面是单链表的。同为笔记，以为回顾文件名App.java /*编写类，实现如下功能： *1、创建有序单链表 *2、包含如下基本操作：初始化、增加、删除、查找、打印元素 * 注意：初始化不同于用new 创建元素。 * *目的： * 1、理解成员变量、成员方法的

单链表基本操作的实现--创建、插入、查找、删除: 单链表基本操作的实现--创建、插入、查找、删除 其中，查找和删除分为按值查找删除和按序号查找删除；附上代码（具体的代码实现见注释解析） linkedlist.h(链表的头文件) #pragma once #include class Node { public: int data; Node* next; }; class LinkedList { privat

单链表的插入、删除、遍历（查找||改写数据）: 数组的四个基本操作是增、删、改、查。链表也是这样，学链表的第一步除了会用两种方法（头插和尾插）创建链表之外，剩下的就是学会增、删、改、查这四个基础操作。不论进行哪种操作，链表的遍历是最最基础的，大框架如下： node *p=head-&gt;next;（带头节点） while( p ) { 操作； p=p-&gt;next; } 上篇博文对链表的遍历----查找做了一个简单总结 https:/...

单链表汇总（建立，查找，处理，删除，……）: 单链表汇总 #include &lt;iostream&gt; #include &lt;cstdlib&gt; using namespace std; //-------------------------------- struct node { int data; node *next; }*head,*p,*r; //---------------------...

数据结构课后练习——初识单链表（单链表的创建，查找并删除）: 就保平布置的那个必做题。。。题目：在一个按值递增的链表中删除值等于x的节点，成功返回1，失败返回0. 源代码如下： #include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; class node { node* next; int data; public: node() {} ~node() {...

单链表的删除: 已知单链表L含有头节点，且节点中的元素值以递增的方式排列。下面的函数DeleteList在L中查找所有值大于mink且小于maxK的元素，若找到，则逐个删除，同时释放被删节点的空间。若链表中不存在满足条件的元素，则返回-1，否则返回0。例如，某单链表如下图(a)所示。若令minK为20、maxK为50，则删除后的链表如图(b)所示。链表节点类型定义如下： typedef struct...

C语言：单链表查找其中节点的数据: #include #include #define MAX 10 struct List { int number; int total; struct List *next; }; typedef struct List Node; typedef Node *Link; int data[2][MAX] = {3, 9, 25, 5, 7, 26, 56, 80, 2, 6

C 带头节点的单链表查找中间节点: //自定义的结点结构体和头指针结构体： [cpp] view plain copy #include #include #include #include typedef int DataType; typedef struct LinkNode { DataType

C语言实现单链表增删查找等功能: struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; List MakeEmpty(List L); //将链表置空 int IsEmpty(List L); //判断链表为空 int Is

问题 C: 字符串的查找删除: 题目描述给定一个短字符串（不含空格），再给定若干字符串，在这些字符串中删除所含有的短字符串。输入输入只有1组数据。输入一个短字符串（不含空格），再输入若干字符串直到文件结束为止。输出 删除输入的短字符串(不区分大小写)并去掉空格,输出。样例输入 in #include int main() { printf(&quot; Hi &quot;); } 样例输出 #clude tma() { prtf(“Hi...

单链表查找函数: 基础的单链表查找函数 c语言实现新手学习c语言链表的基础函数

单链表（增、删、查找）: 用结构体构建单链表，实现单链表的基本功能。 //头文件 #pragma once #include #include #include typedef int DataType; typedef struct ListNode { DataType _data; struct ListNode *_next; }ListNode; //初始化 void InitList(List

单链表实现查找中间结点: 题目：用户输入x；随机生成X个元素，输出中间元素。若为奇数则输出中间，若为偶数输出中间两个数的平均值链表实现具体实现算法：（1）定义两个指针，首先将他们指向第一个元素（2）快慢指针，快指针p1是慢指针p2的2倍速度。相当于p1+2，p2++；（3）考虑可能是偶数个元素，快指针p1->next为空时，直接输出慢速度p2所指的元素，并跳出循环。

查找单链表的中间节点: 这是今天面试测开面试官提到的一个问题，当时有点紧张，代码写的不整洁，回来整理了一下。个人有点强迫症，纸上的代码一定想用机器跑起来。特整理如下：问题描述：查找单链表的中间节点。我的思路：快慢指针。 “` class Node { int val ; Node next; public Node(int val) { // TODO Auto...

数据结构--单链表查找条件: 在数据结构与算法中，对于单链表的查找算法有两种。rn[img=https://img-bbs.csdn.net/upload/201608/14/1471184939_570493.png][/img]rn[img=https://img-bbs.csdn.net/upload/201608/14/1471184948_906666.png][/img]rn这两个算法的循环判断条件对于前半部分p表达的应该是一样意思。rnP&&jnext ! e;当P不是空的时候判断后边的。rn但是为什么用不同的写法呢？rn

单链表查找中间元素: int ListLinkSearch(Node *head) { if(head == NULL) { return FAILURE; } Node *current = head-&gt;next; Node *middle = head-&gt;next; int i = j = 0; while(current !...

递归实现单链表的查找: #include using namespace std;struct Node { Node(int data) :_data(data) ,_next(NULL) {} Node* _next; int _data;};

C语言：【单链表】删除一个无头单链表的非尾节点: #include #include #include typedef int DataType; typedef struct SListNode { DataType data; struct SListNode* next; }SListNode; SListNode* BuyNode( DataType x) { SListNode* next = (SLis

单链表查找人名: 题目要求输入n个姓名建立链，并查找一个人名,如查到则输出其表中位置，查不到则输出-1. 输入描述先输入n,然后输入n个姓名。再输入一个待查的姓名。输出描述输出查询结果，查到则输出链表中序号，否则输出-1 输入样例 3 Tom John Mike John 输出样例 2 代码` #include <stdio.h> #include <malloc.h> #inclu...

单链表--------------链表查找: #include #include typedef struct person { int age; struct person *next; }per; per *tail_list(per *one, int num) { per *temp = (per *)malloc(sizeof(per)); temp->age = num; per

单链表——头插法、尾插法和查找: #include&lt;stdio.h&gt;#include&lt;malloc.h&gt;#define OK 1#define ERROR 0 typedef struct Node{ int date; struct Node * next;}Node, *LinkList; void InitList(LinkList *L)//初始化单链表{ *L=(LinkList)malloc(s...

单链表值查找出错。。: void ShowCity(pCity c) //遍历所有链表所有内容rnrn pCity cc=c;rn while (cc->next!=NULL)rn rn cc=cc->next;rn printf("City name is:%c\n",cc->CityName);rn printf("City Position is X:%d Y:%d\n",cc->x,cc->y);rn rnrn这段显示代码可以正常显示结果。rnrnvoid SearchCity(pCity c,char name) //查找City链表，显示城市坐标rnrn pCity cNow=c; //当前指针指向的节点的指针rn while (cNow->next!=NULL)rn rn if (cNow->CityName==name)rn rn printf("the city you searched %c x is:%d y is:%d",c->CityName,c->x,c->y);rn break;rn rn cNow=c->next;rn rn// printf("can't find the city in the link\n");rnrn这段查找代码就有问题了。。rntypedef struct City // 城市结构体rnrn char CityName; //城市名字rn int x; //城市x坐标rn int y; //城市y坐标rn struct City *next; //城市头指针rnCity,*pCity; rn数据类型定义

数据结构查找之-单链表的基本操作: 先给出结构体的定义：#include #include #includetypedef int DataType; typedef struct Node { struct Node* next; DataType data; }Node, *PNode;//这里定义一个结构体类型和一个结构体指针类型单链表的基本操作实现：//

单链表操作之查找中间结点: ***单链表操作之查找中间结点*** //查找链表的中间结点; //自定义的结点结构体和头指针结构体： #include #include #include #include typedef int DataType; typedef struct LinkNode { DataType data; struct LinkNode* n

单链表的查找方法: //单链表查找操作,,,按序号查找和按值查找 //先尾插法建立一个空链表 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int elem; typedef struct Lnode { elem *data; struct Lnode *next; }Lnode, *list; list creat(list &amp;...

编程实现一个单链表的查找: 【单链表节点的查找】： //查找单链表pos位置的节点，返回节点指针 //pos从0开始，0返回head节点 node *search_node(node *head, int pos) { node *p = head->next; if(pos < 0) //pos位置不正确 { cout << "in

数据结构之单链表——带有节点的单链表的创建、插入和删除（C/C++）: // 带有头节点的单链表的创建、插入和删除#include #include #include typedef int DataType; typedef struct LNode{ DataType data; struct LNode *next; }LNode,*LinkList; // 这里的函数参数必须是链表的指针的地址，否则为局部变量无法将链表指针带回主程序 // 创

C语言单链表删除（无备注）: 数据结构典型范例，单链表删除操作（注：因实验需要，没有直接汉语注释和输入提醒）

C语言实现单链表的创建、插入、删除: 节点数据结构: /* *定义链式存储线性表的结构 */ typedef struct LNode { int data; //数据域 struct LNode * next; //指向下一个节点的指针 } LNode,*LinkList;从尾部添加节点： /* *fun:CreateList_L() *desc:逆位序输入n个元素的值,建立带表头结点的单链线

单链表的初始化、插入、删除——C语言: 单链表的初始化、插入、删除 #include #include typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; //单链表中的数据域 struct Node *next; //单链表的指针域 }Node,*LinkedList;

c语言单链表的创建、插入、删除: 由于之前的下位机开发要求比较低，很少使用链表，后来换了份工作，跟另外一个同事共同开发一个主控程序，链表成为了最基本的数据结构，所以花了一段时间对链表进行了比较认真的学习，以下内容为个人对链表的一些理解。 1：链表的结构链标的单位为节点，节点包含数据及指向下一个节点的地址。 2：链表的创建将各个节点按上图的结构串联在一起 3：链表的插入 4、删除一个节点 5

C语言数据结构单链表的删除算法: 1、利用尾插法创建一个类型为字符型的带头结点的单链表。 2、删除上述单链表中指定位置的元素。 3、要求：屏幕上分别显示删除前、后的单链表中元素列表；从键盘输入指定的删除位置。

单链表的构建、遍历、删除、插入c源码: description 头结点是为了操作的统一与方便而设立的，放在第一个元素结点之前，其数据域一般无意义（当然有些情况下也可存放链表的长度、用做监视哨等等）。有了头结点后，对在第一个元素结点前插入结点和删除第一个结点，其操作与对其它结点的操作统一了。首元结点也就是第一个元素的结点，它是头结点后边的第一个结点。头结点不是链表所必需的。头指针是指向头结点的一个指针。 code #inclu...

单链表结点删除 C语言实现: 实现代码：#include #include#define N 15typedef struct linklist { int data; struct linklist *next; }list, *plist;void create_list(plist* head) { int i; if (NULL == *head)/*

【C】单链表: 头文件 #define _CRT_SECURE_NO_WARNINGS #pragma once #include #include #include typedef int DataType; typedef struct SListNode { DataType data; //链表中存放的数据 struct SListNode *pNex

C 单链表: #pragma once//定义一个结构体(.h文件) typedef struct _NODE{ int count; char name[8]; struct _NODE* next; }NODE; int _insert(const char* name, int count); int _insert2(const char* name, int count, int

单链表的应用.c 单链表的应用.c: 单链表的应用.c 单链表的应用.c 单链表的应用.c

C单链表: c的纯新手，看了两天书，对于指针链表还是搞不清楚，觉得再怎么想也无济于事，于是动手开始写，花了一下午把下面的单链表操作写完了，希望各位给些帮助，支出不妥和优化的地方，在此谢谢各位帮助了rn[code=c]#include rn#include rnrntypedef struct nodern int data;rn struct node *next;rnNODE ;rn//创建链表rnNODE *CreateLink(int len);rn//查看链表rnvoid DisplayLink( NODE *head );rn//查看链表长度rnint GetLinkLen( NODE *head );rn//根据位置查找rnvoid FindItemByPosition( NODE *head, int position );rn//根据内容查找rnvoid FindItem( NODE *head ,int value );rn//插入节点rnNODE *InsertItem( NODE *head, int position, int value );rn//删除节点rnNODE *DelItem( NODE *head, int value );rn//根据位置删除节点rnNODE *DelItemByPosition( NODE *head, int position );rn//删除链表rnvoid DelLink( NODE *head );rnrn/**创建链表**/rnNODE *CreateLink( int len )rn NODE *head,*current,*temp;//头节点指针，当前指针,创建指针rn if( len == 0 ) return NULL;//长度为零，返回空指针rn head = (NODE *)malloc( sizeof (NODE));rn head->data = 0;rn head->next = NULL;rn if( len == 1 ) return head;//长度为1，返回头节点rn current = head;//当前指针指向头节点rn for( int i =1; i < len; i++ ) rn temp = (NODE *)malloc( sizeof (NODE));//分配内存,并将当前指针的next指向内存rn temp->data = i;rn temp->next = NULL;rn current->next = temp;//表示将current所指向的节点的next指向temprn current = temp;//表示将current指针移向新生成的节点temprn rn return head;rnrnrn/**查看指针长度**/rnint GetLinkLen( NODE *head )rn NODE *current;//当前指针rn current = head;//将当前指针指向头结点rn int len = 0;rn while( current != NULL )rn len++;rn current = current->next;//指针后移rn rn return len;rnrnrn/**查看链表**/rnvoid DisplayLink( NODE *head )rn NODE *current;//当前指针rn current = head;//将当前指针指向头结点rn while( current!= NULL )rn printf("data = %d\n", current->data);rn current = current->next;//指针后移rn rnrnrn/**根据位置查找**/rnvoid FindItemByPosition( NODE *head, int position )rn int len = GetLinkLen( head );//查看链表长度rn if( len < position+1 ) rn printf("position error link len is %d\n", len);rn return;rn rn NODE *current;//当前指针rn current = head;//将当前指针指向头结点rn //int size = sizeof(NODE);//计算结构体大小rn //current = head+position*size;//指针指向所查位置rn for( int i =0 ; i< position ; i++ )rn current = current->next;rn rn printf("position %d data is %d\n", position,current->data);rnrnrn/**根据内容查找**/rnvoid FindItem( NODE *head ,int value )rn NODE *current;//当前指针rn current = head;//将当前指针指向头结点rn int position = 0;rn while( current )rn if( current->data == value )rn printf("The %d position is %d\n", value,position);rn return ;rn rn position++;rn current = current->next;//指针后移rn rn printf("Don't find %d position\n", value);rn return;rnrnrn/**插入节点**/rnNODE *InsertItem( NODE *head, int position, int value ) rn int len = GetLinkLen( head );//链表长度rn NODE *insert;//需要插入的rn insert = (NODE *)malloc( sizeof (NODE) );//内存分配rn insert->data = value;rn //1.查找要插入的位置rn //插入头rn if( position == 0 )rn insert->next = head;rn return insert;rn rn //插入尾部rn if( len < position + 1 )rn position = len;rn rn NODE *current,*prev;//当前指针，前驱指针rn current = head;//当前指针指向头结点rn for( int i=0; inext;//指针后移rn rn prev->next = insert;rn insert->next = current;rn return head;rnrnrn/**删除节点**/rnNODE *DelItem( NODE *head, int value )rn NODE *current,*prev;//当前指针,前驱指针rn current = head;rn int position = 0;rn while (current)rn if( current->data == value )rn if( position == 0 )//头结点被删除rn NODE *newhead = head->next;rn free( head );rn return newhead;rn rn prev->next = current->next;//将前驱指针定位到删除节点的下一个节点rn free( current );rn return head;rn elsern prev = current;//定位前驱指针rn current = current->next; //指针后移rn rnrn rn printf("%d not exist in link\n", value);rn return head;rnrnrn/**根据位置删除节点**/rnNODE *DelItemByPosition( NODE *head, int position )rn NODE *current,*prev;//当前指针,前驱指针rn current = head;rn if( position == 0 )//删除头节点rn NODE *newhead = head->next;rn free( head );rn return newhead;rn rn int len = GetLinkLen( head );//获取列表长度rn if( len < position + 1 )rn position = len;rn rn for( int i = 0 ; i < position ; i++ )rn prev = current;//定位前驱指针rn current = current->next;//指针后移rn rn prev->next = current->next;rn free( current );rn return head;rnrnrn/**删除整个链表**/rnvoid DelLink( NODE *head )rn NODE *current,*prev;//当前指针，前驱指针rn current = head;rn while( current != NULL )rn prev = current;//将当前指针指向头结点rn current = current->next;//指针后移rn free( prev );//删除前驱节点rn rn printf("Del Link Done\n");rn[/code]

【单链表】 c语言的单链表: 单链表：是一种线性表，每个节点里面存储着下一个节点的指针，把存储的数据元素连起来。本文中应用了C++的引用来传参数。存储结构：typedefintDataType; typedefstructSListNode { DataType_data; structSListNode*_next;//指向下一个节点 }SListNode;链表中节...

单链表的插入删除等功能: 1.初始化链表L 2.销毁链表L 3.清空链表L 4.求链表L的长度 5.判链表L空否。 6.通过e返回链表L中第i个数据元素的内容 7.在链表L中检索值为e的数据元素 ......

单链表插入和删除: 用单链表的实现的插入和删除，可以上机执行的！适合初学者！

单链表的创建和删除: 单链表的整表创建 step1:确定函数原型：函数返回值：void 函数参数：头指针的地址ListNode **、创建链表节点的个数n step2:先判断要不要头结点，如果要头结点先创建一个头节点并让头指针指向头节点 step3:利用传进来链表节点的个数n做循环控制的条件，循环创建链表并插入链表节点的结构...

【数据结构】NOJ005 单链表的删除: 从A表中删除那些又在B表又在C表的元素这跟【顺序表的删除】几乎一个道理，但是链表的删除更简单（不用移动元素），所以正常从前往后遍历就行了应该专门写一个函数来初始化并输入链表的……然而懒，宁愿复制三遍orz #include <iostream> #include <stdlib.h> using namespace std; typedef struct node ...

单链表某一元素的删除: 为啥总是犯十分智障的错误！！！错误代码：#include #include //删除元素 typedef struct LNode{ int data; LNode *next; }*List,LNode;void Creat(List &L,int n){//创建链表 List p;//用于循环创建的节点 L=(List)ma

【数据结构】单链表的插入与删除: 1.链接存储结构的定义在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的). 它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点. 链式存储结构又分为单链表、双链表、循环链表。 2.链式存储结构的特点比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的

删除单链表指定元素: class ListNode { int val; ListNode next; ListNode(int x) { val = x; } ListNode(int x, ListNode next) { val = x; this.next = next; }}public class Solution {

单链表的插入和删除: #include <iostream> using namespace std; **//**链表不是随机存取结构，不能直接按序号访问结点。头结点可以看做第0个结点，所以计数器j加到i时为第i个结点。** typedef struct node { int data; struct node *next; }ListNode; **//创建带头结点的单链表** Li...

单链表删除特定值: void remove( const int&amp; data) { node* cur=head-&gt;next; node* pre=head; while(cur) { if(cur-&gt;data==data) { node* q=cur; pre-&gt;next...

删除单链表的头结点？: 书上写着rnstruct LNode *q=*p,*t;rnif(i==1)rnt=q;rn *p=q->next;rn rn 请问*p=q->next;这一步的具体含义是什么？

单链表删除头结点问题: rn下边的代码定义了一个名字为node的类，和一个函数。函数的功能为去掉链表的头结点。rn class nodern rn public:rn typedef double value_type;rnrn node(const value_type& initial_data_value, node* initial_link=nullptr)rn data_field = initial_data_value; link_field = initial_link;rnrn ~node()rn rn link_field=nullptr;rn rnrn void set_link(node* new_link)link_field = new_link;rn private:rn value_type data_field;rn node *link_field;rn ;rnrn void list_head_remove(node*& head_ptr)rn rnrn node* remove_ptr;rn remove_ptr=head_ptr;rn head_ptr=head_ptr->link();rn delete remove_ptr;rn rn在主程序中，首先构造一个长度为3的链表，然后将链表头结点去除。rnnode N1(100);rnnode N2(200);rnnode N3(300);rnN1.set_link(&N2);rnN2.set_link(&N3);rnhead_ptr = &N1;rnlist_head_remove(head_ptr);rnrn程序运行时，最后一句话会出问题。弹出的黑色窗口什么文字都没有。请大家帮忙帮助我看看错误在哪里。谢谢。rnrnrn

单链表的创建、添加、删除: 创建头插法： ①什么是头插法？ #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node * next; }Node; //create函数如下: Node * create(int n) { int i; Node * head= (N...

单链表中元素的删除: 下面代码是要删除A表中B，C表都有的的元素，即a∈A∩B∩C，不过写挫了，搞了一上午没搞出来，求高手不吝赐教！rn说明：表中元素递增存储。rnrn[code=C/C++]rnbool est(NODE *a,NODE *&b)rn bool i=false;rn while(b&&(a->dat>=b->dat))rn if(a->dat==b->dat)i=true;rn b=b->next;rn rn return i;rnrnrnbool del_com(NODE *pa,NODE *pb,NODE *pc)//删除成功返回1，否则返回0rn int c=pa->dat,t;//c is used to count the number of elements in the listrn NODE *p=NULL,*ha=pa,*pre=pa;//pre用于记下A表当前元素位置,以维护链表rn pa=pa->next;rn pb=pb->next;rn pc=pc->next;//skip the head nodern while(pa)rn if(est(pa,pb)&&est(pa,pc))//deletern t=pa->dat;rn while(pa&&(pa->dat==t))rn p=pa;rn pa=pa->next;rn free(p);rn rn pre->next=pa;//重连、结束表rn rn else pa=pa->next;//判断下一个rn pre=pa;//更新A表当前元素位置rn rn ha->dat=c;rn if(p)return true;//即未删除元素rn return false;rnrn[/code]

单链表节点的删除和小结: 1.算法是程序的灵魂，优秀的程序在对海量数据处理时，依然保持高速计算，就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少，但存在两个问题：1)授课方式单一，大多是照着代码念一遍，数据结构和算法本身就比较难理解，对基础好的学员来说，还好一点，对基础不好的学生来说，基本上就是听天书了2)说是讲数据结构和算法，但大多是挂羊头卖狗肉，算法讲的很少。本课程针对上述问题，有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式，让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外，还包括程序员常用10大算法：二分查找算法（非递归）、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题，让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人，就需要花时间来研究下数据结构和算法。教程内容：本教程是使用Java来讲解数据结构和算法，考虑到数据结构和算法较难，授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二分查找算法(非递归)、分治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标：通过学习，学员能掌握主流数据结构和算法的实现机制，开阔编程思路，提高优化程序的能力。

单链表的初步实现---（转置，删除，替换，查找，添加）: package Test; class Link{ //定义链表 private class Node{ //定义保持的节点 private Object data; //要保持的数据，可以用泛型替代 p

单链表的操作（创建、查找、插入、删除、遍历、就地逆转等）: 先贴原代码，后面再一一做解释。 /* 单链表的各创建等等操作日期：2017年11月3日 21：46 */ #include &amp;amp;amp;quot;stdafx.h&amp;amp;amp;quot; #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; #include &amp;amp;amp;quot;stdlib.h&amp;amp;amp;quot;

求教一道单链表的显示，单个插入，查找和删除的代码题目: 谢谢大家，··rnrn#include rn#include rn#include rn#include rn#include rn#include rn#include rn#include rnrn//定义结点类型rnstruct Nodernint data;rnNode *next;rn;rnrnNode Head; //头结点rnNode *DLList; //头指针rnrnvoid init(Node *DLList);rnvoid display(Node *DLList);rnvoid insert(Node *DLList);rnvoid search(Node *DLList);rnvoid del(Node *DLList);rnrnvoid main()rnrnchar choice;rnrnDLList=&Head; //使头指针指向头结点rnHead.next=NULL; rnrnwhile (1)rnrnsystem("cls");rncout << "\n\n\n\n";rncout << "\t\t 单链表操作 \n";rncout << "\t\t======================================";rncout << "\n\n";rncout << "\t\t 1：初始化 \n";rncout << "\t\t 2：显示 \n";rncout << "\t\t 3：单个插入 \n";rncout << "\t\t 4：查找 \n";rncout << "\t\t 5：删除 \n";rncout << "\t\t 0：退出 \n";rncout << "\n";rncout << "\t\t请选择：" << flush;rnrnchoice = getch();rnsystem("cls");rnrnswitch(choice)rnrncase '1':rninit(DLList);rnbreak;rncase '2':rndisplay(DLList);rnbreak;rncase '3':rninsert(DLList);rnbreak;rncase '4':rnsearch(DLList);rnbreak;rncase '5':rndel(DLList);rnbreak;rncase '0':rnexit(0);rnrnrnrnrn//公用的等待函数rnvoid wait()rnrncout << "\n\n请按任意键继续" << flush;rngetch();rnrnrn//屏幕提示后，从键盘输入线性表长度和随机数种子，生成以DLList为头指针的指定长度的线性表rnvoid init(Node *DLList)rnrnint length;rnNode *p,*q;rnwhile (1)rnrncout << "输入元素个数（0－" << 10000 << "）：" << flush;rncin >> length;rnif (length >= 0 && length << endl;rnrnrn int i;rnwhile (1)rnrncout << "输入随机数种子（0－32767）：" << flush;rncin >> i;rnif (i >= 0 && i << endl;rnrnrn //从线性表中删除并释放原有的结点，使其成为空表rnp=DLList;rnwhile (p->next!=NULL)rnrnq=p->next;rnp->next=q->next;rnfree(q);rnrnrnsrand(i); //指定随机数种子，相同的种子将产生相同的数据序列rnrand(); rnrn//向线性表插入length个新结点rn for (int j=1;jnext=DLList->next;rnDLList->next=p;rnp->data=rand() % 10000;rn rnrnrn//在屏幕上依次显示以DLList为头指针的线性表中的全部元素和元素个数rn//格式应便于观察rn//如果需要指定输出的宽度，可以使用 cout << setw(W) << X ，其中 X 是输出的数值，W 是占据的列数rnvoid display(Node *DLList)rnrnrnrn//屏幕提示后，从键盘输入一个元素值，然后把这个新元素插到以DLList为头指针的线性表的末尾rnvoid insert(Node *DLList)rnrnrnrn//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中搜索这个元素rnvoid search(Node *DLList)rnrnrnrn//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中删除这个元素rn//屏幕显示删除成功与否的信息rnvoid del(Node *DLList)rnrn rn rn rn

用单链表对学生成绩插入删除查找: 头文件 #ifndef LinkList_H #define LinkList_H //if not defined,防止头文件的重复包含和编译 template //定义单链表的结点 struct Node { student data; Node *next; }; //以下是类Lin

单链表的创建、插入、删除: 看网上资料，然后写的关于单链表的、插入、删除等方面的代码练练手，代码存在一些bug,仅供参考。#include #include //1.定义链表数据结构 struct node { int num; struct node *next; };//函数声明 struct node *creat(struct node *head); vo

单链表删除重复节点: 学后一年重看数据结构，确实难啊，搞了半天才搞明白这个小问题。#include #include #include typedef char ElemType; typedef struct Node /*结点类型定义*/ { ElemType data; struct Node * next; } Node, *LinkList; /* LinkList为结构指针类

尾差法和删除单链表: #include #include typedef struct Node { int data; struct Node *Next; }Node,*LinkedList; /* 下面的程序为尾差法建立单链表 */ void tailCreat(LinkedList &L,int i) { int j; LinkedList p1,p2; L = (LinkedLi

链表之单链表重复元素的删除: #include #include struct node { int data; struct node *next; }; int main() { int n, i; scanf("%d", &n); struct node *head, *tail, *p, *q, *t; head = (struct node

单链表插入删除: 在链表的插入删除操作上理解起来比顺序表更为容易，其不需要变动在i位置前的所有的元素，只需要修改节点指针即可。插入：设在链表的i位置插入新元素，设i-1节点的指针域为p，设插入的节点指针域为s，所以插入操作应该为： s->next=p->next;将s的后缀改为p的后缀，p的后缀是原来的第i个点的指针域，将其给s的后缀说明此时的s是第i个节点的前一个节点。 p->next=s;;将p的后

利用单链表删除重复元素: ****前面一篇介绍了用顺序表删除重复元素，那用单链表是不是也能奏效呢？下面用单链表删除重复元素。**** #include <iostream> using namespace std; typedef int ElemType; struct Node { ElemType data; struct Node *next; }; Node* Create() { Node

搭建自己的MDS断网服务器下载: Linux下的用来搭建黑莓MDS服务器的源代码相关下载链接：[url=//download.csdn.net/download/libwan/3305583?utm_source=bbsseo]//download.csdn.net/download/libwan/3305583?utm_source=bbsseo[/url]

Android权限列表下载: Android权限列表 Android开发所有权限相关下载链接：[url=//download.csdn.net/download/q403666704/4424741?utm_source=bbsseo]//download.csdn.net/download/q403666704/4424741?utm_source=bbsseo[/url]

C#常用代码下载: C#基础代码,为初学者更好认识,编程的魅力相关下载链接：[url=//download.csdn.net/download/qq_17860635/7943743?utm_source=bbsseo]//download.csdn.net/download/qq_17860635/7943743?utm_source=bbsseo[/url]

相关热词 c# 去空格去转义符 c#用户登录窗体代码 c# 流 c# linux 可视化 c# mvc 返回图片 c# 像素空间 c# 日期最后一天 c#字典序排序 c# 截屏取色 c#中的哪些属于托管机制

我们是很有底线的