数据结构单链表

最新推荐文章于 2022-10-22 22:07:30 发布
最新推荐文章于 2022-10-22 22:07:30 发布
阅读量637 收藏 4
点赞数
分类专栏： 考研数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45889436/article/details/119833658
版权

线性表的链式表示

特点：不需要使用地址连续的存储单元，插入删除直接修改指针，不需要移动元素

            缺点：失去随机存储的优点

1.单链表的节点定义：

//节点的定义
typedef struct LNode {
    int data;
    struct LNode* next;
} LNode, *LinkList;

一、头结点和头指针的区别：

头指针：永远指向链表的第一个节点

头结点：带有头结点的链表的第一个结点，结点通常不存储信息

二、引入头结点的优点：

1.由于第一个数据节点的位置被存储在头结点的指针域中，因此链表的第一个位置上操作和其他节点一致，不存在区别。

2.无论链表空还是非空，头指针都指向头结点的非空指针。空表非空表得到统一。

三、链表的判空条件

单链表：带头结点：L->next=NULL;  不带头结点：L=NULL;

双链表：带头结点：L->next=NULL;不带头结点：L=NULL；  

循环链表：带头结点：L->next=L;  不带头结点 L=NULL；

循环双链表：带头结点：L->next=L;L->prior=L;(L的前驱和后继都为自己) ；不带头结点L=NULL;

二、带有头结点的单链表基本操作

       1.头插法：直接定义新指针进行建立

                特点：顺序逆序

                时间复杂度 o（1） 若表长为n 时间复杂度 o（n）

LinkList headinsert(LinkList& L) {
    LNode* s;
    int X;
    L = (LNode*)malloc(sizeof(LNode));
    L->next = NULL;
    printf("请输入第1个数");
    scanf("%d", &X);
    int i = 1;
    while (X != 999999) {

        s = (LNode*)malloc(sizeof(LNode));
        s->data = X;
        s->next = L->next;
        L->next = s;
        i++;
        printf("输出第%d个数", i);
        scanf("%d", &X);

    }
    return L;

}

        2.尾插法建立链表：利用尾指针来建立链表

                特点：输入顺序于存储顺序一致

                时间复杂度 o（1） 插入n个：o（n）

LinkList tail(LinkList& L) {
    LNode* s;
    LNode* tail = L;
    int X;
    L = (LNode*)malloc(sizeof(LNode));
    int i = 0;
    printf("请输入%d个数", i);
    scanf("%d", &X);
    while (X != 999999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = X;
        tail->next = s;
        tail = s;
    }
    tail->next = NULL;
    return L;
}

3.按序号查找节点（第i个数字结点）值：用变量j来遍历链表至空

   时间复杂度：O（n）

LNode* GetElem(LinkList& L, int i) {
    LNode* e = L->next;
    int j = 1;
    if (i == 0)
        return L;
    if (i < 1)
        return NULL;
    while (e != NULL && j < i) {
        e = e->next;
        j++;

    }
    return e;
}

4.按值查找结点 判断条件 p！=NULL&&p->data=NULL

   时间复杂度：O（n）

LNode* locatElem(LinkList& L, int X) {
    LNode* e = L->next;
    while (e != NULL && e->data != X)
        e = e->next;
    return e;
}

5.插入操作

        插入操作分为指定结点后插入和在第i个位置插入

        在第i个位置插入，首先用按位查找定位i-1个位置，然后插入到i-1指定结点后面

        时间复杂度：O（n）     

bool insertlist(LinkList& L, int i, int X) {
    LNode* s= (LNode*)malloc(sizeof(LNode));
    LNode* e = GetElem(L, i-1);
    s->data = X;
    s->next = e->next;
    e->next = s;
    return true;
}

      指定结点后插：

        时间复杂度O（1)

 LNode *s;
 s=(LNode *)malloc(sizeof(LNode));
 s->data=X;
 s->next=p->next;
 p->next=s;

 6.删除结点操作

        时间复杂度：O（n）用于寻找第i个结点

bool deletelist(LinkList& L, int i) {
    LNode* e = GetElem(L, i-1);
    LNode* p = e->next;
    e->next = p->next;
    free(p);
    return true;
}

        如为删除指定结点p，通过与后继结点交换数值，来删除后继结点，达到同样效果

   q=p->next;
   p->data=p->data;
   p->next=q->next;
   free(q);

7.求表长操作：

       从第一个数字结点开始用变量i=1来计数

int lengthlist(Linklist L){
    int i=0;
    while(L->next!=NULL){
        i=i++;
        L=L->next;
       
}
    return i;
}

 8.设计一个递归算法，删除不带头结点的单链表L中所有值为X的结点     

        思路：递归函数delx（L，x）    （画图理解）

                   1.递归出口 L=NULL；结点为空

                    2.递归： 若L.data[i]=X  删除结点 并继续递归delx（L->next,x）

                                   若L.data[i]!=X 递归delx(L->next,x);

bool delx(Linklist &L,x){
    if(L==NULL)
        return true;
    if(L->data==x){
        LNode *p;
        p=L;
        free(p);
        delx(L->next,x);
    }
    if(L->data!=x){
        delx(L->next,x);    
    }
    return true;
}

9.删除链表中X的值（带头结点）

思路一 删除X 利用一个前驱i结点删除值为x的结点（算个小断链）

            遍历链表若值为X，删除p，p后移，pre的后驱结点改为p，free掉原p结点；

            链表值若不为X，pre，p依次后移；

bool del_x_linklist(LinkList& L) {
    int val;
    cout << "请输入要删除的值" << endl;
    cin >> val;
    int k = 0;
    LNode* pre = L;
    LNode* q;
    LNode* p = pre->next;
    while (p != NULL) {
        if (p->data == val) {
            q = p;
            pre->next = p->next;
            p = pre->next;
            // p = p->next;
             //pre->next = p;
            free(q);
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
    return true;
}

思路二：记录值不为X的值用尾插法建立链表

如果值为X，不插入，跳过，值为X插入；

//尾插法建立
bool del_X2_LinkList(LinkList& L) {
    int val;
    cout << "请输入要删除的值" << endl;
    cin >> val;
    LNode* tail = L;
    LNode* s = L->next;
    LNode* q;
    while (s != NULL) {
        if (s->data != val)
        {

            tail->next = s;
            tail = s;
            s = s->next;
        }
        else {

            q = s;
            s = s->next;
            free(q);
        }
    }
    tail->next = NULL;
    return true;
}

 删除最小及节点（删除问题一般需要保留前驱结点，删除不断链）

思路：遍历整个链表找到最小值结点，设置结点有遍历的前驱pre，遍历结点p

           记录最小值结点min，最小值结点前驱

           然后删除此结点

bool delminlinklist(LinkList& L) {
    LNode* p = L->next;
    LNode* pre = L;
    LNode* minpre = L;
    LNode* min = L->next;
    while (p != NULL) {
        if (p->data < min->data) {
            min = p;
            minpre = pre;
        }

        pre = p;
        p = p->next;
    }
    minpre->next = min->next;
    free(min);
    return true;
}

类似删除最小值结点：

给定一个单链表，按次递增输出单链表各元素的值，并释放结点

思路：本题就是寻找最小结点并删除，然后遍历N次这个操作（删除需要前驱结点）

bool minupdel(LinkList &L){
    LNode *p=L->next;
    LNode *pre=L;
    LNode *minp=p;
    LNode *minpre=pre;
    while(L->next!=NULL)
    {    
        p=L->next;
        pre=L;
		while(p!=NULL){
           if(p->data<minp->data)
              {minp=p;
              minpre=pre;
            }
            pre=p;
            p=p->next;
                
    }
        minpre->next=minp->next;
		cout<<minp->data<<endl;
        free(minp);
    }
}

删除结点的值位于两个值之间的结点（删除问题，保留前驱结点）

思路：遍历链表，寻找满足条件的值,

        需要结点：前驱结点pre，遍历结点p

 //删除链表位于两值之间的值的节点
  bool dels_t(LinkList &L, int min, int max) {
            initlinklist(L);
            LNode* pre = L;
            LNode* p = L->next;
            while (p != NULL) {
                if (p->data > min && p->data < max) {
                    pre->next = p->next;
                    //free(p);
                    p = p->next;
                }
                else {
                    pre = p;
                    p = p->next;
                }
            }


            return true;
        }

10.链表逆置问题（断链）

       将结点p的后继结点指向前驱结点，并保证不断链设tail指针提前指向p的后继

        最后将头结点的指针指向p第一个结点（此时）

//逆置链表
//思路：断链操作
bool relinklist(LinkList& L) {
    LNode* pre, *p = L->next, *tail = p->next;
    p->next = NULL;  //第一个数据节点
    while (tail != NULL) {
        pre = p;
        p = tail;
        tail = p->next;
        p->next = pre;
    }
    L->next = p;
    return true;
}

11.反向输出每个节点的值（可以采用递归） 

void reprint(LinkList &L){
 
	if(L->next!=NULL)
		reprint(L->next);
	cout<<L->data<<endl;
  }

我的错误想法：

void reprint(LinkList &L){
    L=L->next;
    if(L!=NULL)
        reprint(L);
    if(L!=NULL)
        cout<<L->data<<endl;
}

 12.链表升序问题（其实也要断链，保留后继结点）

        思路：将链表一分为二，前部分初始只包括第一个数据结点，剩余链表属于另一部分

                    然后把后部分几点有序插入前部分 

bool sqlist(LinkList &L) {
    LNode *pre, *p = L->next;
    LNode *tail = p->next;  //tail设置来防止断链 
    p->next = NULL;
    p = tail;
    while (p!= NULL) {
        tail = p->next;  //tail设置来防止断链 
        pre = L;        //pre为已拍好序的链表头结点 
        while (pre->next!= NULL && pre->next->data < p->data) {
            pre = pre->next;
        }
        p->next = pre->next;
        pre->next = p;
        p = tail;
    }
    return true;
}

13.寻找两个链表的公共结点

     思路：两个链表的公共结点即某结点后两链表全部相同，这就要求链表同步遍历

                若链表不等长，需要先同步遍历处理，求表长，长链表优先遍历长度差

 LNode  *samelist(LinkList& A, LinkList& B) {
      int a = lengthlist(A);
      int b = lengthlist(B);
      int pos;
      LNode *longlist;
      LNode *shortlist;
      if (a > b) {
          longlist = A;
          shortlist = B;
          pos = a - b;
      }
      else {
          longlist = B;
          shortlist = A;
          pos = b - a;
      }
      longlist = longlist->next;
      shortlist = shortlist->next;
      while (pos--) {
          longlist = longlist->next;
      }
      while (longlist != NULL) {
          if (longlist->data == shortlist->data) {
              return longlist;
          }
          longlist = longlist->next;
          shortlist = shortlist->next;
      
      }
      return NULL;

  }
int lengthlist(LinkList &L) {
      int i = 0;
      LNode* p = L->next;
      while (p != NULL) {
          p = p->next;
          i++;
      }
      return i;
  }
int lengthlist(LinkList &L) {
      int i = 0;
      LNode* p = L->next;
      while (p != NULL) {
          p = p->next;
          i++;
      }
      return i;
  }

14.将带头结点的单链表分为两个单链表A和B，A含有原本单链表中奇数数据结点,B含有偶数结点，保持顺序不变

思路：用结点P来循环链表，奇数项保留在A，这就要求断链（P保证不断链）

                                                偶数项保留在B，新建链表都采用尾插法

LNode* dicreat_1(LinkList &A){
    int i=0; //判断奇数偶数
    LNode* B=(LNode*)malloc(sizeof(LNode));
    B->next=NULL;  //保留偶数
    LNode *p=A->next;
    A->next=NULL;  //保存奇数
    LNode *tailA=A;
    LNode *tailB=B;
    while(p!=NULL){
    i++;
    if(i%2==1){
       tailA->next=p;
       tailA=p; 
    }
    else
    {
        tailB->next=p;
        tailB=p;
    }
    p=p->next;
    }
    tailA->next=NULL;
    tailB->next=NULL;
    return B;
}

 类似上题将链表A(a1,b1,a2,b2.......an,bn)输出为两个链表(a1,....an)和（bn....b1）

 bn采用头插法 注意P前插法断链 保留结点后驱！

LNode* dicreat_2(LinkList &A){
    int i=0; //判断奇数偶数
    LNode* B=(LNode*)malloc(sizeof(LNode));
    B->next=NULL;  //保留偶数
    LNode *p=A->next;
    A->next=NULL;  //保存奇数
    LNode *tailA=A;
    while(p!=NULL){
    i++;
    if(i%2==1){
       tailA->next=p;
       tailA=p;
	   p=p->next; 
    }
    else
    {
        LNode *q=p->next;
        p->next=B->next;
		B->next=p; 
    	p=q;
	}
    
    }
    tailA->next=NULL;
    return B;
} 

#include <iostream>
using namespace std;
#include <stdio.h>
#include <malloc.h>

//#define _CRT_SECURE_NO_WARNINGS
//队列
//单链表
//节点的定义
typedef struct LNode {
    int data;
    struct LNode* next;
}  *LinkList;

bool initlinklist(LinkList& L) {
    L = (LNode*)malloc(sizeof(LNode));
    if (L == NULL)
        return false;
    L->next = NULL;
    return true;

}

//头插法
LinkList headinsert(LinkList& L) {
    LNode* s;
    int X;
    int i = 1;
    L = (LNode*)malloc(sizeof(LNode));
    L->next = NULL;
    cout << "请输入第" << i << "个数" << endl;
    cin >> X;
    while (X != 999999) {

        s = (LNode*)malloc(sizeof(LNode));
        s->data = X;
        s->next = L->next;
        L->next = s;
        i++;
        cout << "请输入第" << i << "个数" << endl;
        cin >> X;

    }
    return L;

}

//尾插法
LinkList tail(LinkList& L) {
    LNode* s=(LNode*)malloc(sizeof(LNode));
    int X;
    L = (LNode*)malloc(sizeof(LNode));
    LNode* tail = L;
    int i = 1;
    cout << "请输入第" << i << "个数" << endl;
    cin >> X;
    while (X != 999999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = X;
        tail->next = s;
        tail = s;
        i++;
        cout << "请输入第" << i << "个数" << endl;
        cin >> X;
        
    }
    tail->next = NULL;
    return L;
}

//按位查找
LNode* GetElem(LinkList& L, int i) {
    LNode* e = L->next;
    int j = 1;
    if (i == 0)
        return L;
    if (i < 1)
        return NULL;
    while (e != NULL && j < i) {
        e = e->next;
        j++;

    }
    return e;
}

LNode* locatElem(LinkList& L, int X) {
    LNode* e = L->next;
    while (e != NULL && e->data != X)
        e = e->next;
    return e;
}

bool insertlist(LinkList& L, int i, int X) {
    LNode* s= (LNode*)malloc(sizeof(LNode));
    LNode* e = GetElem(L, i-1);
    s->data = X;
    s->next = e->next;
    e->next = s;
    return true;
}

bool deletelist(LinkList& L, int i) {
    LNode* e = GetElem(L, i-1);
    LNode* p = e->next;
    e->next = p->next;
    free(p);
    return true;
}

bool printlinklist(LinkList& L) {
    LNode* p = L->next;
    while (p != NULL) {
        cout << p->data << endl;
        p =p ->next;

    }
    return true;
  }
//删除 链表中值为X的节点
bool del_x_linklist(LinkList& L) {
    int val;
    cout << "请输入要删除的值" << endl;
    cin >> val;
    int k = 0;
    LNode* pre = L;
    LNode* q;
    LNode* p = pre->next;
    while (p != NULL) {
        if (p->data == val) {
            q = p;
            pre->next = p->next;
            p = pre->next;
           // p = p->next;
            //pre->next = p;
            free(q);
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
    return true;
}

//尾插法建立
bool del_X2_LinkList(LinkList& L) {
    int val;
    cout << "请输入要删除的值" << endl;
    cin >> val;
    LNode* tail = L;
    LNode* s = L->next;
    LNode* q;
        while (s != NULL) {
            if (s->data != val)
            {

                tail->next = s;
                tail = s;
                s = s->next;
            }
            else {

                q = s;
                s = s->next;
                free(q);
            }
        }
    tail->next = NULL;
    return true;
    } 
//反向输出链表节点的值 
//思路：采用递归思想输出
void reprintlist(LinkList &L){
    LinkList p = L->next;
    if (p->next != NULL)
        reprintlist(p);
    if (p!= NULL)
            cout << p->data << endl;
    
}
//逆置链表
//思路：断链操作
bool relinklist(LinkList  &L) {
    LNode* pre, *p= L->next, *tail = p->next;
    p->next = NULL;  //第一个数据节点
    while (tail != NULL) {
        pre = p;
        p = tail;
        tail = p->next;
        p->next = pre;
    }
    L->next = p;
    return true;
}
//将一个带有头结点的单链表有序增加
bool sqlist(LinkList &L) {
    LNode *pre, *p = L->next;
    LNode *tail = p->next;
    p->next = NULL;
    p = tail;
    while (p!= NULL) {
        tail = p->next;
        pre = L;
        while (pre->next!= NULL && pre->next->data < p->data) {
            pre = pre->next;
        }
        p->next = pre->next;
        pre->next = p;
        p = tail;
    }
    return true;
}

//最小值删除
bool delminlinklist(LinkList& L) {
    LNode* p = L->next;
    LNode* pre = L;
    LNode* minpre = L;
    LNode* min = L->next;
    while (p != NULL) {
        if (p->data < min->data) {
            min = p;
            minpre = pre;
        }

        pre = p;
        p = p->next;
    }
    minpre->next = min->next;
    free(min);
    return true;
}
 //删除链表位于两值之间的值的节点
  bool dels_t(LinkList &L, int min, int max) {
            initlinklist(L);
            LNode* pre = L;
            LNode* p = L->next;
            while (p != NULL) {
                if (p->data > min && p->data < max) {
                    pre->next = p->next;
                    //free(p);
                    p = p->next;
                }
                else {
                    pre = p;
                    p = p->next;
                }
            }


            return true;
        }
  int lengthlist(LinkList &L) {
    
      int i = 0;
      LNode* p = L->next;
      while (p != NULL) {
          p = p->next;
          i++;
      }
      return i;
  }
  //寻找两个节点的公共节点
  LNode  *samelist(LinkList& A, LinkList& B) {
      int a = lengthlist(A);
      int b = lengthlist(B);
      int pos;
      LNode *longlist;
      LNode *shortlist;
      if (a > b) {
          longlist = A;
          shortlist = B;
          pos = a - b;
      }
      else {
          longlist = B;
          shortlist = A;
          pos = b - a;
      }
      longlist = longlist->next;
      shortlist = shortlist->next;
      while (pos--) {
          longlist = longlist->next;
      }
      while (longlist != NULL) {
          if (longlist->data == shortlist->data) {
              return longlist;
          }
          longlist = longlist->next;
          shortlist = shortlist->next;
      
      }
      return NULL;

  }

int main( ) {
    LinkList L;
    LinkList A, B;
   
    LNode *same;
    initlinklist(L);
    initlinklist(A);
    initlinklist(B);
    //initlinklist(Same);
    cout <<" 请输入A链表的值 "<< endl;
    tail(A);
    cout << "请输入B链表的数值 "<< endl;
    tail(B);
    //headinsert(L);
    //tail(L);
    //reprintlist(L);
    //insertlist(L, 1, 3);
    //printlinklist(L);
    //del_x_linklist(L);
    //relinklist(L);
    //sqlist(L);
    //delminlinklist(L);
    same=samelist(A, B);
    cout << same->data << endl;
    cout << "成功了" << endl;
    
    printlinklist(same);
    //dels_t(L, 10, 100);
    //printlinklist(L);
    //dels_t(L,10,100);
    //del_X2_LinkList(L);
    //printlinklist(L);
   //insertlist(L, 2, 4);
   //printlinklist(L);


        return 0;
}

weixin_45889436
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
断链在平曲线计算中的处理——短链篇
Sapphire521的博客
07-02 1146
第十二篇 断链在平曲线计算中的处理——短链篇1. 短链在平曲线编程数据库里的处理方法断链是在一些线路设计或施工中因某种情况下而产生的，具体原因在此不做讨论，短链就是断链的其中一种常见形式，另一种形式是长链，在施工测量时也会因这些断链给测量带来一些麻烦。一般手工计算比较常见的的处理方式是将线路在断链点处断开，分成两条线路单独计算。本篇就短链在不将线路拆分两条或多条线路的情况下，介绍一种新方法，来处理短链的数据问题。因短链就是在曲线内有一段桩号缺失，所以处理起来还算比较容易，如果只是一些坐标正算，可不必对数据
数据结构-单链表
qq_30939943的博客
07-01 1282
1.单链表的结点类型定义 typedef struct LNode { int data; struct LNode*next; }LNode,*LinkList; 2.单链表头插法 算法思想：1.创建头结点指向空结点；2.循环创建结点p，p->next指针指向L->next;L->next=p->next. LinkList ListInsertHead(LinkList &L) //LinkList:意味着最终返回LinkList链表； Linkli
数据结构——链表1
laoKdx的博客
07-20 758
数据结构——链表
【考研】数据结构———单链表
qq_31402749的博客
07-26 371
获取元素： Status GetElem(LinkList L,int i,ElemType *e) {         int j;     LinkList p;                //定义链表,p是个指向一个结点的指针      p=L-&gt;next;                // 让P指向链表L的第一个结点      j=1;              ...
数据结构---单链表的操作
gaoqiandr的博客
10-22 760
对于数据结构链表的详细讲解，简单易懂，非常详细
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构 单链表 约瑟夫问题
最新发布
08-27
数据结构 单链表 约瑟夫问题
数据结构单链表的详细介绍
09-03
单链表是计算机科学中数据结构的基础之一，它在存储和操作数据方面具有灵活的特点。在本资源中，我们将深入探讨单链表的概念、实现、操作以及其在C语言中的应用。 首先，单链表是一种线性数据结构，其中每个元素...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
单链表的增删改查
m0_63361206的博客
03-10 3083
具体代码如下： #include <iostream> using namespace std; #include <stdlib.h> #define OK 1 #define ERROR -1 typedef int Status; typedef int Elemtype; typedef struct LNode{//结点的两个属性 Elemtype data;//数据域 struct LNode *next; //指向下一个结点的指针(指针变量名叫next)
数据结构---------------线性表（下篇）之单链表
十七的博客
09-27 715
单链表 特点：储存空间不连续 结点（数据元素组成）：数据域（储存数据）和指针域（指针）A1 若用p来指向  则数据域为p-&gt;date   指针域为p-&gt;next 链式储存结构： 单链表、循环链表、双向链表根据链表结点所含指针个数、指针指向、指针连接方式可将链表分为单链表、循环链表、双向链表、二叉链表、十字链表、邻接表、邻接多重表等 非线性结构：二叉链表、十字链表、邻...
数据结构与算法(C语言版)-第二章-链表知识点-2
qq_64609438的博客
10-04 1241
根据B站学习进行的随行笔记
数据结构（05）——双向链表
09-03 359
双向链表概念 可以在单链表的基础上给每个元素附加两个指针域，一个存储前一个元素的地址，一个存储 下一个元素的地址。这种链表称为双向链表. 结构体定义 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //下一个节点的指针域 struct _LinkNode *prev; /...
学习c语言的第十八天
weixin_46007132的博客
03-17 1136
合并两个无序链表使其有序 输入：链表l1的各个结点的值，链表l2的各个结点的值。 输出：输入的第一个链表的值，输入的第二个链表的值，合并后的链表的值，两个链表合并后以由小至大的顺序输出的值。 优化目标：有两种方法，第一种是先合并为一个链表，再使用链表内部排序使其有序。第二种是先使得两个链表有序，再使其生成一个新的有序链表。 第一种： #include<stdio.h> #include<stdlib.h> typedef struct LNode * linklist;
数据结构之线性表(五)——单链表(4 单链表的建立)
daocaoren_的博客
07-19 2077
建立单链表的方法有两种：头插法和尾插法。 头插法建立单链表 头插法：元素插入到链表头部，也叫前插法。 算法步骤： 1.从一个空表开始，重复读入数据。 2.生成新结点，将读入数据存放到新结点的数据域中。 3.从最后一个结点开始，依次将各结点插入到链表的前端。 例子： 建立链表L (a,b,c,d,e) 从线性表中最后一个元素开始，依次插入到链表的前面。 具体做法： 1.建立头节点。L = n...
线性表
零碎@流年絮语 的博客
11-05 111
线性表 定义： 是零个或多个具有相同类型的数据元素的有限序列, 相邻元素具有前驱和后继关系。 线性表的顺序储存结构: --顺序表: 特点： 线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素. 作用： 线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素在物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 顺序存储的实现：一维数组存储顺序表中的数据 ...
c语言数据结构单链表长度
03-27
C语言数据结构单链表长度可以通过遍历单链表来计算。具体实现方法如下： 1. 定义一个变量count，用于记录单链表长度，初始值为0。 2. 从单链表的头节点开始，依次遍历单链表的每个节点，每遍历一个节点，count的值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值