《数据结构高分笔记》线性表

最新推荐文章于 2022-05-06 11:00:26 发布
最新推荐文章于 2022-05-06 11:00:26 发布
阅读量187 收藏
点赞数 1
分类专栏： # 数据结构高分笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43705697/article/details/107263255
版权

目录

例题2-1 有序顺序表的插入，删除元素

思路：先找到插入位置，然后将后面的元素依次向后移动一位，最后将目标元素赋值，注意长度的加一；

#include <iostream>
#include <algorithm>
using namespace std;

const int maxn = 1000;

//顺序表的结构体定义
typedef struct {
     int data[maxn];
     int length;
}Sqlist;
//使用typedef定义结构体，最后这个Sqlist是类型名，而不是变量名；
//如果只使用struct则是变量名

Sqlist sqlist;

//指定位置插入元素，1插入成功，0插入失败
int insertElem(Sqlist &L, int p, int e){
     //判断插入位置是否合法
     if(p < 0 || p > L.length || L.length == maxn)
          return 0;
     //移动后边元素
     for(int i = L.length - 1; i >= p; i --){
          L.data[i + 1] = L.data[i];
     }
     L.data[p] = e;
     L.length ++;//长度加1
     return 1;
}

//指定位置删除元素，1删除成功，0删除失败
int deleteElem(Sqlist &L, int p){
     //判断删除位置是否合法
     if(p < 0 || p >= L.length)
          return 0;
     //后边元素向前移动一位，相当于删除
     for(int i = p + 1; i < L.length; i ++){
          L.data[i - 1] = L.data[i];
     }
     L.length --;//长度减1
     return 1;
}

//向有序顺序表中插入一个元素，仍保证有序
void insertElement(Sqlist &L, int x){
     //找到插入位置
     int i = 0;
     while(x > L.data[i] && i < L.length) i ++;//注意不要越界，考虑在末尾插入的情况
     //将后边元素移动一位
     for(int j = L.length - 1; j >= i; j --){
          L.data[j + 1] = L.data[j];
     }
     //赋值
     L.data[i] = x;
     L.length ++;//长度加一
}

void show(){
     for(int i = 0; i < sqlist.length; i ++){
          printf("%d ", sqlist.data[i]);
     }
     printf("\n");
}

int main()
{
    int n, t, e;
    scanf("%d", &n);
    sqlist.length = 0;//初始化
    for(int i = 0; i < n; i ++){
          scanf("%d%d", &t, &e);
          insertElem(sqlist, t, e);//插入元素
    }
    show();
    //从小到大排序
    sort(sqlist.data, sqlist.data + n);
    show();
    scanf("%d", &t);
    //有序表插入一个元素
    insertElement(sqlist, t);
    show();
    //删除一个元素
    deleteElem(sqlist, 2);
    show();
    return 0;
}
例2-3 有序链表的合并，头插法，尾插法

有序链表的合并核心需要记录两个链待处理元素的位置，以及最终链尾结点的位置；
如果需要从大到小排列，则用头插法合并，但是最后多余链的元素必须一个个插入；
如果需要从小到大排列，则用尾插法合并，最后多余链的元素一次操作就可以；
头插法需要记录每次插入元素的指针，不需要记录链尾结点的指针；
尾插法除了需要记录每次插入元素的指针，还需要记录链尾结点的指针，用于插入；
查完所有元素要赋空；

#include <iostream>
#include <algorithm>
#include <memory>
using namespace std;

const int maxn = 1000;

//单链表结点定义
typedef struct LNode{
     int data;
     struct LNode *next;
}LNode;
LNode *ans1, *ans2, *res;//notice signal *
//有序链表的合并，重点是需要记录每个链待处理元素的位置和最终链末尾结点的位置
void mergeList(LNode *A, LNode *B, LNode *&C){
     LNode *p = A->next, *q = B->next;//分别用来记录两个链的待处理元素的位置
     LNode *r ; //指向C链中末尾结点
     C = A;//利用A的头结点
     C->next = NULL;//带头结点的初始化为空
     r = C;//r初始化到末尾节点
     free(B);//把B头结点释放掉，唯一释放的一个节点
     //迭代结束条件两个链有一个为空
     while(p != NULL && q != NULL){
          if(p->data <= q->data){
               r->next = p;//把p所指的值接在后面
               r = r->next;
               p = p->next;
          }
          else{
               r->next = q;
               r = r->next;
               q = q->next;
          }
     }
     r->next = NULL;//可以去掉，下边两句肯定有一个会执行
     if(p != NULL) r->next = p;
     else r->next = q;
}
//tail insert of link list
void insertListR(LNode *&A, int a[], int n){
     LNode *r, *s; //r refer to tail, s refer to element which will be inserted
     A = (LNode *)malloc(sizeof(LNode));//allocate head element memory for A
     A->next = NULL;//initialize to NULL
     r = A;
     for(int i = 0; i < n; i ++){
          s = (LNode *)malloc(sizeof(LNode));
          s->data = a[i];//initialize data of s
          r->next = s;//insert s to the end of A
          r = r->next;//move r to next position
     }
     r->next = NULL;//mark to NULL after insert
}
//head insert of link list
void insertListF(LNode *&A, int a[], int n){
     LNode *s;//just need point of insert element
     A = (LNode *)malloc(sizeof(LNode));
     A->next = NULL;
     for(int i = 0; i < n; i ++){
          s = (LNode *)malloc(sizeof(LNode));
          s->data = a[i];
          s->next = A->next;
          A->next = s;
     }
     //no more need initialize NULL
}
void show(LNode *p){
     p = p->next;
     while(p != NULL) {
          printf("%d ", p->data);
          p = p->next;
     }
     printf("\n");
}
int main()
{
     int a[5] = {1, 3, 5, 7};
     int b[5] = {8, 6, 4, 2};
     insertListR(ans1, a, 4);
     show(ans1);
     insertListF(ans2, b, 4);
     show(ans2);
     mergeList(ans1, ans2, res);
     show(res);
     return 0;
}
例2-4 查找某一元素是否存在，若存在删除，返回1，不存在返回0

删除元素时需要记录前驱，所以在前一个结点就判断其后一个结点是不是目标值，当指针指向最后一个元素后就停止，不用检查其值，因为在前一个元素已经检查过了；

//record precursor when delete
int findAndDelete(LNode *C, int x){
     LNode *p, *q;
     p = C;
     //loop until p point last elem
     while(p->next != NULL){
          //judge before elem
          if(p->next->data == x) break;
          p = p->next;
     }
     if(p->next == NULL) return 0;
     else{
          q = p->next;
          p->next = p->next->next;//assignment
          free(q);
     }
     return 1;
}
真题仿照1 一个数组分段有序，进行排序，类似于插入排序

依次处理下标从 m 到 n + m - 1的元素，处理每个元素时向前找到合适的插入位置；

//sort two order sub array, likely insert sort
void insertElem(int A[], int m, int n){
     int temp;
     for(int i = m; i < m + n; i ++){
          temp = A[i];//record element of this loop handle
          int j = i - 1;
          //elem move backward a position
          while(j >= 0 && A[j] > temp) {
               A[j+1] = A[j];
               j --;
          }
          A[j + 1] = temp;
     }
}
顺序表逆置
//reverse all elem in Sq-list
void reverseElem(int a[], int n){
     int temp;
     for(int i = 0, j = n - 1; i < j; i ++, j --){
          temp = a[i];
          a[i] = a[j];
          a[j] = temp;
     }
}
int main()
{
     int a[10] = {1, 3, 5, 7, 2, 4, 6, 8};
     int b[5] = {8, 6, 4, 2};
     reverseElem(a, 8);
     showArray(a, 8);
     return 0;
}
删除链表中的重复元素

定义两个指针p, q; p指向已知的不重复链表元素的末尾，q依次指向待处理元素；用一个额外变量former存储上一次不重复的值，如果q所指元素等于former，说明q所指元素重复，应该删除；如果q所指元素不等于former，说明元素不重复，q和p都向后移一位，同时修改former的值；

void deleteLoopElem(LNode *A){
     LNode *p, *q, *t;//p point former elem, q point elem which be handled
     int former = -1;
     p = A, q = A->next;
     while(q != NULL){
          //if not same with former,change former value, continue move to next
          if(q->data != former){
               former = q->data;
               p = q;//p move backward
               q = q->next;
          }
          //if same with former,delete current elem,continue move to next
          else{
              t = q;
              p->next = q->next;//modify p->next, but p is no change
              q = q->next;
              free(t);
          }
     }
}
爱幻想-hjyp
关注
专栏目录
数据结构高分笔记
08-08
### 数据结构高分笔记知识点详解 #### 一、引言 数据结构作为计算机科学的核心课程之一，在计算机专业研究生入学考试中占据着极其重要的位置。然而，由于数据结构本身概念繁多、逻辑性强等特点，很多考生在备考...
NOIP2014、2015普及组初赛难点整理
I_danzi_I的博客
08-19 403
#include <iostream> using namespace std; const int SIZE = 100; int matrix[SIZE + 1][SIZE + 1]; int rowsum[SIZE + 1][SIZE + 1]; //rowsum[i][j]记录第 i 行前 j 个数的和 int m, n, i, j, first, last, area, ans; int main() { cin >> m >> n; for(i
高斯消元c++（非常暴力）
baituo6615的专栏
04-27 181
暴力方法（已更新）： #include<iostream> using namespace std; const int maxn = 1000; int n; double a[maxn][maxn]; double b[maxn]; void gaussin() { int Flg = -1,i,j,k; ...
王道机试指南第11章---图论---11.2并查集
weixin_44411458的博客
03-01 147
王道机试指南第11章—图论—11.2并查集 并查集基础 #include<iostream> #include<cstdio> using namespace std; const int MAXN=1000; int father[MAXN];//用于表示每个结点的父节点 void Initial(int n){ //初始只有结点本身，父节点就是它自己 for(int i=0;i<n;i++){ father[i]=i; } return; } in
数塔问题的递归解法
Brienz
05-06 513
#include<iostream> #include<algorithm> using namespace std; const int maxn = 1000; int f[maxn][maxn],dp[maxn][maxn]; const int n = 5;//默认为5层数塔 //递归函数 int recur(int x,int y){ if(x==n) return dp[n][y]; //递归边界、即数塔最后一层的值 if(dp[x][y]!=0) retu.
查找算法1——顺序查找
凌空的桨
12-02 1724
查找也称为检索，是指从一批记录中找到指定记录的过程。查找算法是程序设计处理非数值问题非常重要的操作。查找算法包括：基于线性表的查找，基于树的查找，哈希表查找。 基于线性表的查找包括顺序查找、折半查找，和分块查找。 【顺序查找】 顺序查找是指从表的一端开始，逐个将待查找元素与表中的每个元素进行比较，如果某个元素与待查找元素相等，则查找成功，函数返回该元素所在顺序表的位置。否则查找失败，返回0。...
数据结构 高分笔记1
10-30
1 ．1 针对考研数据结构的代码书写规范以及 C&C++ 语言基础. . . . . . . . ... .1 1． ． 1． ． 1 考研综合应用题中算法设计部分的代码书写规范. . . . . . . . . . .. .1 1． ． 1． ． 2 考研中的 C&C++ 语言...
数据结构笔记.pdf
09-16
但是，根据标题“数据结构笔记.pdf”，我可以提供有关数据结构的基础知识点。 数据结构是计算机存储、组织数据的方式。它旨在以某种方式将数据存储在计算机中，以便于可以进行有效的访问和修改。更确切地说，数据...
6-1 顺序表的查找操作
Qieerty的博客
05-06 2220
6-1 顺序表的查找操作 本题要求实现一个函数，要求从顺序表中查找指定元素，并返回第一个查找成功的元素在表中的位置序号，若查找失败，则返回0； 函数接口定义： int LocateElem(SqList L,ElemType e); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int length; }SqList; ### 裁判测试程序样例： #include <stdio.h> #include <stdlib
PTA题目：顺序表的查找操作
Tajang的大千世界
10-21 5320
本题要求实现一个函数，要求从顺序表中查找指定元素，并返回第一个查找成功的元素在表中的位置序号，若查找失败，则返回0； 函数接口定义： int LocateElem(SqList L,ElemType e); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int length; }SqList; 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 5
《算法笔记上机实验指南》第4章 入门篇（2）第11章 动态规划
wsfhdhjs的博客
10-20 105
A1007 #include<iostream> using namespace std; const int maxn=10004; int dp[maxn],s[maxn]={0},fac[maxn]; //搞她娘的数组s[i]，表示以dp[i]结尾的最大连续子列初始的那个值的下标 int n; int main() { bool flag=true; cin >> n; for(int i=0; i<n; i++) {
高斯消元 浮点数解
dianxue5904的博客
01-28 121
#include<iostream> using namespace std; const int maxn = 1000; int n; double a[maxn][maxn]; double b[maxn]; void gaussin() { int Flg = -1,i,j,k; //判断方程组是...
C++奥赛一本通递推题解
小哈里的博客
01-14 1789
C++奥赛一本通刷题记录(递推) 2017.11.8 By gwj1139177410 斐波那契数列 openjudge1760 #include using namespace std; const int maxn=1000010, mod=1000; int f[maxn]; int main(){ f[1] = f[2] = 1; for(int i =
最短路径（迪杰斯特拉算法）
qq_37866617的博客
08-09 228
#include <iostream> #include <algorithm> using namespace std; const int maxn = 1000; const int INF = 1000000000; int Map[maxn][maxn]; int n, m, s; int d[maxn]; bool visited[maxn] = {fal...
CCF-201509-1 数列分段
许少y
04-09 1145
题解水题。#include <iostream> using namespace std;const int maxn = 1000 + 10; int a[maxn];int main() { int n; cin >> n; for(int i = 0; i < n; ++i) cin >> a[i]; int ans = 1; int cnt = 1;
顺序表实验——顺序表的基本操作
hsrnb123的博客
12-25 4284
顺序表，线性表i的基本操作
在数组中查找指定元素，如果存在就返回它的位置，如果不存在，就返回-1(顺序查找+二分法查找+迭代)
qq_43085979的博客
03-09 2837
具体代码如下： public class Chazhao { public static void main(String[] args) { //二分法查找 注：要求数组必须是有序的 int [] arr= {12,18,18,19,34}; int index =halfSearch(arr,18); System.out.println("索引值是（二...
数据结构学习之顺序表（二）
li33293884的博客
01-22 1110
顺 序 表  1.判断顺序表是否为空  int IsEmptySeqList(SeqList *list);  功能:   判断顺序表是否为空  参数:   list:顺序表的地址  返回值:   如果为空返回1   不为空返回0  int IsEmptySeqList(SeqList *list)  {   1.判断顺序表元素是否为空   2.为空返回1   
数据结构解析：线性表与单链表
"本文主要介绍了数据结构中的线性表，特别是单链表的结构定义以及线性表的一些基本概念和操作。线性表是一个有限序列，由相同类型的数据元素组成，每个元素要么没有直接前驱要么只有一个直接前驱，要么没有直接后继...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值