2-线性表 链式存储

想起大二笨笨的,很仔细地扣每个代码每个函数的细节,精确到用‘&’还是用‘*’

把所有自己不明白的函数都搜了一遍

硬着头皮去看,自己也没有学多好。

链表刚学的时候弄了自己两三天

明明是很简单的内容

我大概太笨,理解能力不好,学习方法也不好

但昨晚居然一个小时内哼哧哼哧写出来了

也许是很微小的事情,很微小的细节

也许第二次重新做的时候比第一次快了只有几分钟 至少真的进步了

加油,硬着头皮干,大家都是这么过来的

1、单链表基本功能的实现

  1 #include<iostream>
  2 #include<cstdlib>
  3 using namespace std;
  4 #define ture 1
  5 #define false 0
  6 #define maxsize 50
  7 #define listincreament 10
  8 #define ok 1
  9 #define error -3
 10 #define overflow -2
 11 typedef int Status;
 12 typedef int ElemType;
 13 typedef struct LNode
 14 {
 15     ElemType data;
 16     struct LNode *next;
 17 } LNode,*LinkList;
 18 //头插法建单链表
 19 void CreatList_head(LinkList &L,int length)//头插法
 20 {
 21     LNode *s;
 22     int x;
 23     L=(LinkList)malloc(sizeof(LNode));
 24     L->next=NULL;//创建头结点
 25     while(length--)
 26     {
 27         cin>>x;
 28         s=(LNode *)malloc(sizeof(LNode));
 29         s->data=x;
 30         s->next=L->next;
 31         L->next=s;
 32     }
 33
 34 }
 35 void CreatList_tail(LinkList &L,int length)//尾插法
 36 {
 37     LNode *p,*s;
 38     int x;
 39     L=(LinkList)malloc(sizeof(LNode));
 40     L->next=NULL;
 41     p=L;
 42     while(length--)
 43     {
 44         cin>>x;
 45         s=(LNode *)malloc(sizeof(LNode));
 46         s->data=x;
 47         p->next=s;
 48         s->next=NULL;
 49         p=p->next;
 50     }
 51 }
 52
 53 LNode* GetElem_order(LinkList &L,int n)//按序号查找节点
 54 {
 55     LNode *p=L;
 56     while(p!=NULL&&n>0)
 57     {
 58         p=p->next;
 59         n--;
 60     }
 61     return p;
 62 }
 63 LNode* GetElem_data(LinkList &L,ElemType e)//按值查找节点
 64 {
 65     LNode *p=L;
 66     while(p!=NULL&&p->data!=e)
 67         p=p->next;
 68     return p;
 69 }
 70 void InsertLNode(LinkList &L,ElemType elem,int pos)
 71 {
 72     LNode *p=L,*s;
 73     pos--;
 74     while(pos>0)
 75     {
 76         p=p->next;
 77         pos--;
 78     }
 79     s=(LNode *)malloc(sizeof(LNode));
 80     s->data=elem;
 81     s->next=p->next;
 82     p->next=s;
 83 }
 84 void InsertLNode2(LinkList &L,ElemType elem,int pos)
 85 {
 86     LNode *p=L,*s;
 87     while(pos>0)
 88     {
 89         p=p->next;
 90         pos--;
 91     }
 92     s=(LNode *)malloc(sizeof(LNode));
 93     s->data=elem;
 94     s->next=p->next;
 95     p->next=s;
 96     swap(p->data,s->data);
 97 }
 98 //书上介绍的一种方法,将s直接插入到第pos个节点的后面,再交换两个值。。
 99 void DeleteList_order(LinkList &L,int pos)//删除指定序号的节点
100 {
101     LNode *p=GetElem_order(L,pos-1);
102     LNode *q=p->next;
103     p->next=q->next;
104     free(q);
105 }
106 void DeleteList_data(LinkList &L,ElemType elem)//删除指定值的节点
107 {
108     LNode *p=GetElem_data(L,elem);
109     if(p->next!=NULL)//如果p不是最后一个节点,交换p和p下一个节点的值,删除p的下一个节点(逻辑上等同于删除p
110     {
111         LNode *q=p->next;
112         swap(q->data,p->data);
113         p->next=q->next;
114         free(q);
115     }
116     else free(p);//如果p是最后一个节点,那么可以直接删除p。
117 }
118 int showlength(LinkList L)//求表长。
119 {
120     int length=0;
121     while(L->next!=NULL)
122     {
123         length++;
124         L=L->next;
125     }
126     return length;
127 }
128 void showList(LinkList &L)
129 {
130     LNode *p=L->next;
131     while(p!=NULL)
132     {
133         cout<<p->data;
134         if(!(p->next==NULL))
135         {
136             cout<<‘ ‘;
137         }
138         p=p->next;
139     }
140     cout<<endl;
141 }
142 void showpoint(LNode *p)//展示特定节点的信息
143 {
144     if(p!=NULL)
145         cout<<p->data<<endl;
146     else cout<<"not found."<<endl;
147 }
148
149 //注意:因为生成链表的时候第一个节点是跟在L的后面,即L本身是不存储信息的。
150 //故在按照链表的顺序输出元素值的时候,工作指针p一开始应该指向第一个节点(即L->next)
151 int main()
152 {
153     LNode *L1,*L2,*pos;
154     CreatList_head(L1,10);
155     CreatList_tail(L2,7);
156     showList(L1);
157     showList(L2);
158     pos=GetElem_order(L2,4);
159     showpoint(pos);
160     pos=GetElem_data(L2,99);
161     showpoint(pos);
162     InsertLNode(L1,10,6);
163     InsertLNode2(L2,100,5);
164     showList(L1);
165     showList(L2);
166
167     DeleteList_order(L1,2);
168     DeleteList_data(L2,100);
169     cout<<"After delete some elem:"<<endl;
170     showList(L1);
171     showList(L2);
172     cout<<"Show the length of linklist:L1 is "<<showlength(L1)<<",while L2 is "<<showlength(L2)<<"."<<endl;
173 }
时间: 2024-09-15 16:28:57

2-线性表 链式存储的相关文章

线性表—链式存储结构

链式存储结构就是一环扣一环的线性结构,好像链条中的每一个人都只知道下一个人的地址,只有从前往后顺序查找才能找到第 j 个人. 链式结构的好处是在插入和删除时不需要移动插入位置后面的元素,但要找到要插入和删除的元素的位置还是得像顺序存储结构一样查找,但这个查找还有所不同,顺序存储结构支持我们使用二分查找之类的方法进行查找插入以及删除的位置,至于链式结构感觉似乎没法使用二分法类似的方法(充分利用有序这一条件进行查找) 链式存储结构适合于插入删除操作比较多的场合,比如飞机航班的乘客信息,至于学校的学生

数据结构-线性表-链式存储

由于顺序表的插入.删除操作需要移动大量的元素,影响了运行效率,由此引入了线性表的链式存储. 链式存储线性表时,不需要使用地址连续的存储单元,即它不要求逻辑上相邻的两个元素在物理位置上也相邻,它是通过“链”建立起数据元素之间的逻辑关系. 因此,对线性表的插入.删除不需要移动元素,而只需要修改指针. 线性表的链式存储又称为单链表,它是指通过一组任意的存储单元来存储线性表中的数据元素.为了建立起数据元素之间的线性关系,对每个链表结点,除了存放元素自身的信息之外,还需要存放一个指向其后继的指针.单链表结

数据结构之线性表-链式存储之单链表(一)

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述 1.1 单链表简介 线性表的最大的缺点就是插入和删除操作需要移动大量的元素,这是它在内存中的连续存储结构造成的.为了弥补这2个缺点,就出现了链表,即线性表的链式存储. 链表是由一系列的几点组成,这些节点不必在内存中相连.这就意味着元素可以存在内存未被占用的任意位置.如图 这个存储可以想象成元素在内存中成三维空间存储,他们之间可没有像数组那样的下标标

线性表-&gt;链式存储-&gt;循环链表

文字描述 循环链表是另一种形式的链式存储结构.它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环.由此,从表中任一结点出发均可找到表中其他结点. 示意图 算法分析 插入.删除.查找等同单链表. 代码实现 1 // 2 // Created by lady on 19-1-27. 3 // 4 5 #include <stdio.h> 6 #include <stdlib.h> 7 8 //线性表的单向循环链表存储结构 9 typedef struct ElemType

数据结构之线性表-链式存储之静态链表(二)

本人文笔较差,语文从来不及格,基础不好,写此类文章仅供自己学习,理解队列及其他知识,高手大神请略过.参考书籍 <数据结构与算法分析-Java语言描述>.<大话数据结构> 1.1 静态链表简介 用数组描述的链表叫静态链表.官方是这么给的定义.另一种描述方法叫游标实现法.先不管这些无聊的定义.先按我个人理解描述,再来个Java版的实现比较符合我的风格.另有一些树上说早期存在其他的高级语言没有对象,引用或者指针这样的东西,但是需要对于快插快删等批量操作的这种链式存储,这时候静态链表就起了

线性表 链式存储实现

基本操作 Node* applyNode();   //分配节点Node* addNodeH(Node* Head,Node* InsertNode);       //在头部添加节点Node* addNodeT(Node* Head,Node* InsertNode);       //在尾部添加节点Node* addNodeSort(Node* Head, Node* InsertNode);   //以升序方式添加节点 Node* createList(int n,int choose);

大话数据结构——线性表-链式存储之头插法创建链表

1 #include<iostream> 2 3 #include<time.h> 4 #include <stdlib.h> 5 6 using namespace std; 7 8 #define OK 1 9 #define TRUE 1 10 #define FALSE 0 11 #define ERROR 0 12 13 typedef int status;//返回的状态值 14 typedef int elemtype;//节点里数据的类型 15 16 /

(源代码见大话数据结构)线性表—链式存储结构-&gt;单链表的删除ListDelet(*L,i,*e)

Status ListDelet(LinkList *L,int i,ElemType *e) { int j=1; LinkList p,s; p=*L; while(p&&j<i) { p=p->next; j++; } if(!p||j>i) return ERROR; s=p->next; *e=s->data; p->next=s->next; free(s); return OK; } 个人理解:建立一个新结点可以作为(i-1)个结点的

线性表—链式存储结构—单链表的创建CreasteListHead(*L,int n)-&gt;头插法

void CreasteListHead(LinkList *L,int n) { int i; LinkList p; srand(time(0)); *L=(LinkList)malloc(sizeof(Node)); (*L)->next=NULL;//优先级->大于* !!!!!!!!!!!!! for(i=0;i<n;i++) { p=(Node *)malloc(sizeof(Node)); p->data=rand()%100+1;//1~100之间的数包括一百所以+

数据结构之线性表——链式存储结构之单链表(php代码实现)

<?php /**  *  * 1. 类LNode用作创建单链表时,生成新的节点.  * 2. 类SingleLinkList用于创建单链表以及对单链表的一些操作方法(实例化此类就相当于创建了一个空链表)  * 3. CreateListHead: 具有$num个数据元素的单链表的创建--头插法  * 4. CreateListTail: 具有$num个数据元素的单链表的创建--尾插法  * 5. DestroyList: 销毁单链表  * 6. ClearList:清空单链表  * 7. Li