精华内容
下载资源
问答
  • 单链表按值序号查找

    千次阅读 2010-06-01 22:27:16
    #include<malloc.h>;#include<stdio.h>;typedef struct node{ int data;...NODE *locate(NODE *head,int value){ /*按值查找*/  NODE *p; p=head->next; ...

    #include<malloc.h>;
    #include<stdio.h>;
    typedef struct node{
         int data;
         struct node *next;
    }NODE;

    NODE *locate(NODE *head,int value){   /*按值查找*/

          NODE *p;
          p=head->next;
          while((p!=NULL)&&(p->data!=value)){
                 p=p->next;
          }
          return p;
        }
    NODE *find(NODE *head,int index){
         NODE *p;
         int skip=1;
         p=head->next;
         while((p!=NULL)&&(index<skip)){

             p=p->next;
             skip++;
         }
         return p;
    }


    NODE *create(){    /*创建连接表*/
      NODE *head,*p,*q;
      char ch;
      int a;
      head=(NODE*)malloc(sizeof(NODE)); /*开辟一个空间*/
      q=head;
      scanf("%d",&a);
      ch=getchar();
      while(ch!='?'){
        p=(NODE*)malloc(sizeof(NODE));
        p->data=a;
        q->next=p;
        q=p;
        scanf("%d",&a);
        ch=getchar();
      }
      q->next=NULL;
      return head;
    }

    展开全文
  • 数据结构-单链表查找按值查找

    千次阅读 2017-09-13 16:02:18
    cout输入查找值:"; cin>>num; int find_data=FindData(p,num); if(find_data!=ERROR) { cout查找结果为:"; } else { cout无法查询结果"; } } } return 0; }
    #include<iostream>
    #include<stdlib.h>
    #define ERROR -40000
    using namespace std;
    
    typedef struct LNODE
    {
    	int data;
    	struct LNODE *next;
    }Lnode;
    
    Lnode *Input(int n)
    {
    	Lnode *head,*p,*q;
    	head=p=(Lnode*)malloc(sizeof(Lnode));
    	p->next=NULL;
    	for(int i=0;i<n;i++)
    	{
    		int data;
    		cin>>data;
    		q=(Lnode*)malloc(sizeof(Lnode));
    		q->data=data;
    		q->next=p->next;
    		p->next=q;
    		p=q;
    	}
    	return head;
    }
    
    int FindData(Lnode *L,int num)
    {
    	Lnode *p;
    	p=L->next;
    	int id=1;
    	while(p!=NULL)
    	{
    		if(p->data==num) return id;
    		id++;
    		p=p->next;
    	}
    	if(p==NULL) return ERROR;
    }
    
    int main()
    {
    	int n;
    	while(cin>>n)
    	{
    		Lnode *p=Input(n);
    		cout<<"数据查询:"<<endl;
    		while(1)
    		{
    			int num;
    			cout<<"输入查找值:"<<endl;
    			cin>>num;
    			int find_data=FindData(p,num);
    			if(find_data!=ERROR)
    			{
    				cout<<"查找结果为:"<<find_data<<endl;
    			} 
    			else
    			{
    				cout<<"无法查询结果"<<endl; 
    			}
    		}
    	}
    	return 0;
    }

    展开全文
  • 单链表按元素查找并插入,若不存在需要查找的元素,则在单链表最后插入 代码实现 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define FLAG -1 //停止输入的标志 typedef struct...

    单链表按元素查找并插入,若不存在需要查找的元素,则在单链表最后插入

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #define FLAG -1    //停止输入的标志
    typedef struct Node
    {
        int data;
        struct Node * next;
    }LNode,*LinkList;
    
    void show_List(LinkList L);
    void CreateLinkList(LinkList L);
    LNode *LocationLinkList(LinkList L,int x);
    void InsertLinkList(LinkList L,int eme,int x);
    
    void main()
    {
        int eme,x;
        LinkList L = (LNode *)malloc(sizeof(LNode));
        printf("创建一个单链表:\n");
        CreateLinkList(L);
        printf("遍历单链表:\n");
        show_List(L);
        printf("输入需要在哪一个元素前插入元素,并且输入要插入的元素:\n");
        scanf("%d%d",&eme,&x);
        printf("按值查找,并插入\n");
        InsertLinkList(L,eme,x);
        show_List(L);
    }
    
    void show_List(LinkList L)
    {
        LinkList p = L->next;
        printf("%d",p->data);
        p = p ->next;
        while(p != NULL)
        {
            printf("->%d",p->data);
            p = p->next;
        }
        printf("\n");
    }
    
    void CreateLinkList(LinkList L)  //尾插法  输出是输入的正序
    {
        LinkList s,r;
        int x;
        scanf("%d",&x);
        r = L;    //没写闪退
        while(x != FLAG)
        {
            s = (LNode *)malloc(sizeof(LNode));
            s->data = x;
            //r->next = s;
            //s->next = r->next;   出错误的原因是r->next中已经是新节点的地址了,
            //再把新节点地址赋值给它的指针域,会导致自己不断的指自己 不断 33333
    
            //不妨先把r->next也就是NULL赋给新节点指针域,再将上一个指向新节点,这样就没问题了!
            //s->next = r->next;   //第一种写法
            r->next = s;
    
            r = s;
            scanf("%d",&x);
        }
        r->next = NULL;//第二种写法  先不管最后一个节点,最后再置为NULL
    }
    
    LNode *LocationLinkList(LinkList L,int eme) //按元素查找
    {
        LinkList p,q;
        q = L;
        p = L->next;
        while(p != NULL && p->data != eme)
        {
            q = p;
            p = p->next;
        }
        return q;
    }
    
    void InsertLinkList(LinkList L,int eme,int x)
    {
        LinkList q,s,r;
        int flag=0;
        r=L;
        while(r)
        {
            q = LocationLinkList(r,eme);
            r=q->next;
    
            //找到了元素ele  在其前面插入
            if(r!=NULL)
            {
                s = (LNode*)malloc(sizeof(LNode));
                s->data = x;
                s->next = q->next;
                q->next = s;
                flag=1;
            }
        }
        if(flag == 0)//说明没有找到相应的元素 应该在尾部插入
        {
    
            s = (LNode*)malloc(sizeof(LNode));
            s->data = x;
            q->next = s;
            s->next = NULL;
        }
    }
    
    
    展开全文
  • 按值查找 位查找 /** * 位查找,返回第i个节点 * 带头结点 * @param L * @param i * @return */ LNode * GetElem(LinkList L, int i){ if (i<0){ return NULL; } LNode *p; int j = 0; p=L; ...

    单链表的查找–带头结点

    • 按位查找
    • 按值查找

    按位查找

    /**
     * 按位查找,返回第i个节点
     * 带头结点
     * @param L 
     * @param i 
     * @return 
     */
    LNode * GetElem(LinkList L, int i){
        if (i<0){
            return NULL;
        }
        LNode *p;
        int j = 0;
        p=L;
        while (p!= NULL && j<i){
            p = p->next;
            j++;
        }
        return p;
    }
    

    封装(基本操作)的好处 — 避免重复操作、简洁、易于维护

    按值查找

    /**
     * 按值查找
     * 找到数据域 ==e的节点
     * @param L 
     * @param e 
     * @return 
     */
    LNode * LocateElem(LinkList L, int e){
        LNode *p = L->next;
        while (p != NULL && p->data != e){
            p = p->next;
        }
        return p;
    }
    

    求单链表的表的长度

    /**
     * 求单链表的长度
     * @param L 
     * @return 
     */
    int Length(LinkList L){
        int len = 0;
        LNode *p = L;
        while (p->next != NULL){
            p = p->next;
            len++;
        }
        return len;
    }
    
    

    单链表头插法建立单链表

    /**
     * 头插法建立单链表
     * @param L 
     * @return 
     */
    LinkList List_HeadInsert(LinkList &L){
        LNode *s;
        int x;
        L = (LinkList) malloc(sizeof (LNode));
        L->next = NULL;
        scanf("%d", x);
        while (x!= 9999){
            s=(LNode *) malloc(sizeof (LNode));
            s->data = x;
            s->next = L->next;
            L->next = s;
            scanf("%d", x);
        }
        return L;
    }
    

    尾插法建立单链表

    /**
     * 尾插法建立单链表
     * @param L 
     * @return 
     */
    LinkList List_TailInsert(LinkList &L){
        int x;
        L = (LinkList ) malloc(sizeof (LNode));
        LNode *s,*r=L;
        scanf("%d", &x);
        while (x!=9999){
            s=(LNode *) malloc(sizeof (LNode));
            s->data=x;
            r->next=s;
            r = s;
            scanf("%d", &x);
        }
        r->next =NULL;
        return L;
    }
    

    上单链表的所有代码

    #include <iostream>
    
    /**
     * 传统定义方法
     */
    //struct LNode{
    //    int data;
    //    struct LNode *next;
    //};
    //typedef struct LNode LNode;
    //typedef struct LNode *LinkList;
    /**
     * 课本上的定义方法
     */
    typedef struct LNode {
        int data;
        struct LNode *next;
    } LNode, *LinkList;
    
    int main() {
        printf("hello");
        return 0;
    }
    
    /**
     * 获取单链表的节点的方式
     * @param L
     * @param i
     * @return
     */
    LNode *getElem(LinkList L, int i) {
        int j = i;
        LNode *p = L->next;
        if (i == 0) {
            return L;
        }
        if (i < 1) {
            return NULL;
        }
        while (p != NULL && j < i) {
            p = p->next;
            j++;
        }
        return p;
    }
    
    /**
     * 初始化一个空的单链表
     */
    bool InitList(LinkList &L) {
        L = NULL;              //空表,暂时没有任何节点-->防止脏数据
        return true;
    }
    
    void test() {
        LinkList L;
        InitList(L);
    }
    
    /**
     * 初始化一个带头节点的单链表
     * @param L
     * @return
     */
    bool InitList1(LinkList &L) {
        L = (LNode *) malloc(sizeof(LNode));
        if (L == NULL) {
            return false;
        }
        L->next = NULL;
        return true;
    }
    
    /**
     * 判断单链表是否为空
     * @param L
     * @return
     */
    bool isEmpty1(LinkList L) {
        if (L == NULL) {
            return true;
        } else {
            return false;
        }
    }
    
    void test1() {
        LinkList L;
        InitList1(L);
    }
    
    /**
     * 在带头结点的单链表中插入元素
     * 在第i个位置插入元素e
     * @param L
     * @param i
     * @param e
     * @return
     */
    bool ListInsertDaiTouJieDian(LinkList &L, int i, int e) {
        if (i < 1) {
            return false;
        }
        LNode *p;
        int j = 0;
        p = L;
        while (p != NULL && j < i - 1) {
            p = p->next;
            j++;
        }
        if (p == NULL) {
            return false;
        }
        LNode *s = (LNode *) malloc(sizeof(LNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
    
    /**
     * 笔袋头节点的单链表,按位序插入
     * ps:如果不带头结点,删除第一个元素时,需要改变头指针L;
     * @param L
     * @param i
     * @param e
     * @return
     */
    bool ListInsertBuDaiTouJieDian(LinkList &L, int i, int e) {
        if (i < 1) {
            return false;
        }
        if (i == 1) {
            LNode *s = (LNode *) malloc(sizeof(LNode));
            s->data = e;
            s->next = L;
            L = s;
            return true;
        }
    
        LNode *p;
        int j = 1;
        p = L;
        while (p != NULL && j < i - 1) {
            p = p->next;
            j++;
        }
        if (p == NULL) {
            return false;
        }
        LNode *s = (LNode *) malloc(sizeof(LNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
    
    /**
     * 后插操作
     * 在第i个位置后进行插入操作
     * @param L
     * @param i
     * @param e
     * @return
     */
    bool ListInsertAnWeiZhi(LinkList &L, int i, int e) {
        if (i < 1) {
            return false;
        }
        LNode *p;
        int j = 0;
        p = L;
        while (p != NULL && j < i - 1) {
            p = p->next;
            j++;
        }
        if (p == NULL) {
            return false;
        }
        LNode *s = (LNode *) malloc(sizeof(LNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
    
    /**
     * 后插操作
     * 在指定节点后进行操作
     * @param p
     * @param e
     * @return
     */
    bool ListInsertNextNode(LNode *p, int e) {
        if (p == NULL) {
            return false;
        }
        LNode *s = (LNode *) malloc(sizeof(LNode));
        if (s == NULL) {         //内存分配失败
            return false;
        }
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
    
    /**
     * 前插操作
     * 偷天换日
     * 由于不知道指定节点的前方节点,只能在后方节点后插入,然后更换数据
     * @param p
     * @param e
     * @return
     */
    bool ListInsertPriorNode(LNode *p, LNode *s) {
        if (p == NULL) {
            return false;
        }
    //    LNode *s = (LNode *) malloc(sizeof (LNode));
    //    if (s== NULL){
    //        return false;
    //    }
        s->next = p->next;
        p->next = s;
        int temp = p->data;
        p->data = s->data;
        p->data = temp;
        return true;
    }
    
    /**
     * 删除带头节点的单链表中的节点
     * @param L
     * @param i
     * @param e
     * @return
     */
    bool ListDeleteDaiTouJieDian(LinkList &L, int i, int &e) {
        if (i < i) {
            return false;
        }
        LNode *p;
        int j = 0;
        p = L;
        while (p != NULL && j < i - 1) {
            p = p->next;
            j++;
        }
        if (p == NULL) {
            return false;
        }
        if (p->next == NULL) {
            return false;
        }
        LNode *q = p->next;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
    
    /**
     *删除指定节点
     * 需要注意的是不知道前驱节点,可以知道后继节点
     * 采用更改数据域的内容删除该节点
     * @param p
     * @return
     */
    bool DeleteNode(LNode *p) {
        if (p == NULL) {
            return false;
        }
        LNode *q = p->next;
        p->data = p->next->data;
        p->next = q->next;
        free(q);
        return true;
    }
    
    /**
     * 按位查找,返回第i个节点
     * 带头结点
     * 可以把头节点认为是第0个节点
     * @param L
     * @param i
     * @return
     */
    LNode *GetElem(LinkList L, int i) {
        if (i < 0) {
            return NULL;
        }
        LNode *p;
        int j = 0;
        p = L;
        while (p != NULL && j < i) {
            p = p->next;
            j++;
        }
        return p;
    }
    
    /**
     * 按值查找
     * 找到数据域 ==e的节点
     * @param L
     * @param e
     * @return
     */
    LNode *LocateElem(LinkList L, int e) {
        LNode *p = L->next;
        while (p != NULL && p->data != e) {
            p = p->next;
        }
        return p;
    }
    
    /**
     * 求单链表的长度
     * @param L 
     * @return 
     */
    int Length(LinkList L){
        int len = 0;
        LNode *p = L;
        while (p->next != NULL){
            p = p->next;
            len++;
        }
        return len;
    }
    /**
     * 尾插法建立单链表
     * @param L
     * @return
     */
    LinkList List_TailInsert(LinkList &L){
        int x;
        L = (LinkList ) malloc(sizeof (LNode));
        LNode *s,*r=L;
        scanf("%d", &x);
        while (x!=9999){
            s=(LNode *) malloc(sizeof (LNode));
            s->data=x;
            r->next=s;
            r = s;
            scanf("%d", &x);
        }
        r->next =NULL;
        return L;
    }
    
    /**
     * 头插法建立单链表
     * @param L
     * @return
     */
    LinkList List_HeadInsert(LinkList &L){
        LNode *s;
        int x;
        L = (LinkList) malloc(sizeof (LNode));
        L->next = NULL;
        scanf("%d", x);
        while (x!= 9999){
            s=(LNode *) malloc(sizeof (LNode));
            s->data = x;
            s->next = L->next;
            L->next = s;
            scanf("%d", x);
        }
        return L;
    }
    
    展开全文
  • 带头结点的单链表的建立,按值查找,计算表长,及其输出单链表中的数据
  • 序号查找 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } *LinkList,LNode; // 尾插建立单链表 LinkList List_ToolInsert (LinkList &L){ int...
  • 9007:单链表按值操作

    2018-10-24 21:10:23
    递增有序的单链表进行以下操作:若表中存在为x的结点,则将它从表中删除;否则,就往表中插入一个为x的结点,并保持表递增有序的性质不变(假设表中没有相同的元素)。处理后若为空表则不输出。  ...
  • 单链表按值操作

    2013-08-19 11:20:27
    #include using namespace std; typedef struct Node { int val; Node *next; }node; node* mycreat(int n) { node *head=NULL,*p=NULL,*sec=NULL; head=(node*)malloc(sizeof(node)); p=head;...
  • //查找,返回第i个元素(带头结点) bool ListInsert(LinkList &L, int i, int e){ if(i<0) return NULL; LNode *p; //指针p指向当前扫描到的结点 int j=0; //当前p指向的是第几个结点 p = L; //L...
  • 6-1 按值查找单链表 (10分) 本题要求实现一个函数,Locate_LinkList(LinkList L, datatype x)函数是在带头结点单链表中查找值为x的结点。函数须返回找到结点的指针,没有找到返回空。 函数接口定义: LNode *Locate_...
  • C语言实现单链表查找中间

    千次阅读 2019-11-05 16:19:23
    C语言实现单链表查找中间主要功能实现代码 主要功能 创建单链表 查看链表 查看链表长度 查找单链表中间节点的 实现代码 #include <stdio.h> #include <stdlib.h> #include <time.h> #...
  • 单链表是数据结构中较为“简单”的一部分,但是它却是很重要的一部分。二叉树,线索二叉树,哈希函数等等的相关操作都离不开链表,因此搞懂单链表显得尤为重要。下面是我对链表简单操作的一些理解。(本文中所有链表...
  • 查找单链表中间

    2014-12-17 20:59:57
    输出未知长度的单链表的中间; 方法一:扫描单链表。得到单链表的长度 方法二:设置快慢指针,快指针的扫描速度是慢指针的扫描速度的两倍 */ #include #include"Search.h" using namespace std; int...
  • 序号查找 #include<iostream> using namespace std; typedef struct LNode { int data; struct LNode *next; } *LinkList,LNode; // 尾插建立单链表 LinkList List_ToolInsert (LinkList &
  • 单链表查找最大并删除 任务描述: 试编写在带头结点的单链表中删除一个最大结点的高效算法。 代码实现: // 在带头节点的单链表中删除一个最大结点 #include <stdio.h> #include <stdlib.h> ...
  • 编译环境:VS2019 利用单链表实现对12345的创建等操作 //建立一个单链表,将12345存放到链表中去 #define _CRT_SECURE_NO_WARNINGS ...//头插法创建单链表 当输入为0时,停止输入 node* creat1() { node*
  • 单链表操作之查找中间结点

    千次阅读 2016-06-08 22:50:12
    ***单链表操作之查找中间结点*** //查找链表的中间结点; //自定义的结点结构体和头指针结构体: #include #include #include #include typedef int DataType; typedef struct LinkNode...
  • 一、单链表查找(带头结点)(一)查找GetElem(L,i):查找操作。获取表L中第i个位置的元素的。//查找,返回第i个元素(带头结点)LNode * GetElem(LinkList L, int i){if(i<0)return NULL;LNode *p;//...
  • 数据结构-单链表查找按序号查找

    千次阅读 2017-09-13 15:55:09
    cout输入查找序号:"; cin>>num; int find_data=FindData(p,num); if(find_data!=ERROR) { cout查找结果为:"; } else { cout无法查询结果"; } } } return 0; }
  • C语言之单链表操作之查找

    千次阅读 2015-09-10 20:00:18
    二、单链表的基本运算 建立了一个单链表之后,如果要进行一些如插入、删除等操作该...对单链表进行查找的思路为:对单链表的结点依次扫描,检测其数据域是否是我们所要查好的,若是返回该结点的指针,否则返回NULL
  • 查找成功,算法输出该结点的data域的,并返回1;否则,只返回0。 关键字:带头结点单链表+倒数查找 思路 关注:递归算法的设计重点在于找到“递归”的部分,即重复调用函数,改变部分相关变量 设f(...
  • 单链表查找

    2021-02-02 13:42:17
    单链表的查找一、位查找,返回第i个元素(带头结点)二、按值查找三、求表的长度 一、位查找,返回第i个元素(带头结点) LNode * GetElem(Linklist L,int i){ if(i<0) return NULL; LNode *p; int j=0;...
  • 这里有封装好的单链表,里面包含了各种单链表的实现过程

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,020
精华内容 15,208
关键字:

单链表按值查找