C++顺序表、链表的*插删查等*操作

最新推荐文章于 2022-03-19 21:15:51 发布
最新推荐文章于 2022-03-19 21:15:51 发布
阅读量232 收藏
点赞数
分类专栏： C语言 文章标签： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/one_chow_chow/article/details/108497266
版权

V2！！

顺序表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//顺序表三要素
typedef struct Vector{
	int *data;
	int size, length;
}Vec;

Vec *init(int n){
	Vec *v = (Vec *)malloc(sizeof(Vec));
	v->data = (int *) malloc (sizeof(int) * n);
	v->size = n;
	v->length = 0;
	return v;
}

void clear(Vec *v){
	if (v == NULL) return;
	free(v->data);//malloc与free成对出现
	free(v);//先销毁data再销毁v
	return;
}

//malloc在堆区上动态开辟空间，不一定清零，calloc可以清空为固定值，
//realloc可以在已开辟空间上再一次开辟，realloc先在原来空间上看能不能扩，可以则返回原地址，不能则返回新地址，并主动拷贝原来数据，并释放原来空间，失败返回0
int expand(Vec *v){
	int ex_size = v->size;
	int *q;
	while(ex_size){
		q = (int *)realloc(v->data, sizeof(int) * (v->size +ex_size));
		if (q) break;
		ex_size /= 2;
	}
	if (ex_size == 0) return 0;
	v->data = q;
	v->size += ex_size;
	return 1;

}

//0失败1成功
int insert(Vec *v, int val, int ind){
	//3种意外情况
	if (v == NULL) return 0;
	if (ind < 0 || ind > v->length) return 0;
	if (v->length >= v->size) {
		if (!expand) return 0;
		printf("success to expand!\n");
	}
		//return 0;

	for (int i = v->length; i>ind; i++){
		v->data[i] = v->data[i - 1];
	}
	v->data[ind] = val;
	v->length++;
	return 1;
}

int erase(Vec *v, int ind){
	if (v == NULL) return 0;
	if (ind < 0 || ind >= v->length) return 0;
	for (int i = ind + 1; i < v->length; i++){
		v->data[i - 1] = v->data[i];
	}
	v->length--;
	return 1;
}

void output(Vec *v){
	if (v == NULL) return;
		return ;
	printf("VECTOR: [");
	for (int i = 0; i < v->length; i++){
		i && printf(", ");
		printf("%d", v->data[i]);
	}
	printf(" ]\n");
	return ;
}


int main(){
	srand(time(0));
#define max_op 20
	Vec *v = init(max_op);
	for (int i = 0; i <= max_op; i++){
		int val = rand() % 100;
		int op = 0;//0insert 1erase
		if (insert(v, val, i)){
			printf("insert %d success!\n", val);
		}
	}
#undef max_op

	return 0;
}

单链表

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct ListNode{
	int data;
	struct ListNode *next;
}ListNode;

typedef struct List{
	ListNode head;
	int length;
}List;

ListNode *init_node(int val){
	ListNode *p = (ListNode *)malloc(sizeof(ListNode));
	p->data = val;
	p->next = NULL;
	return p;
}

//head为虚拟头结点，数据字段无意义，只代表链表头
List *init_list(){
	List *l = (List *)malloc(sizeof(List));
	l->head.next = NULL;
	l->length = 0;
	return l;
}

void clear_node(ListNode *node){
	if (node == NULL) return;
	free(node);
	return;
}

//不断地用q标识p下一个节点，然后销毁p
void clear(List *l){
	if (l == NULL) return;
	ListNode *p = l->head.next, *q;
	while(p){
		q = p->next;
		clear_node(p);
		p = q;
	}
}

//2种特殊情况，p始终标识待插入的前一个位置，如果ind=0，p就是头结点（第1个元素前）
int insert(List *l, int ind, int val){
	if (l == NULL) return 0;
	if (ind < 0 || ind > l->length) return 0;
	ListNode *p = &(l->head), *node = init_node(val);
	while(ind --) p = p->next;
	node->next = p->next;
	p->next = node;
	l->length++;
	return 1;
}

//同理，q标识待删除节点，p标识待删除的前一节点
int erase(List *l, int ind){
	if (l == NULL) return 0;
	if (ind < 0 || ind >= l->length) return 0;
	ListNode *p = &(l->head), *q;
	while(ind --) p = p->next;
	q = p->next;
	p->next = q->next;
	free(q);
	l->length--;
	return 1;
}

void output(List *l){
	if (l == NULL) return ;
	printf("List(%d) is [", l->length);
	for (ListNode *p = l->head.next; p; p = p->next){
		printf("%d->", p->data);
	}
	printf("NULL]\n");
	return ;
}

int main(){
	srand(time(0));
#define max_op 20
	List *l = init_list();
	for (int i = 0; i < max_op;i++){
		int val = rand() % 100;
		if(insert(l, i, val)) printf("insert %d success!\n", val);
	}
}

顺序表

#include <iostream>
#include <cstring>
using std::cout;
using std::endl;
//定义顺序表模板类
template <typename Type> class Vector {
private:
    int size, length;
    Type *data;
public:
    Vector(int input_size) {
        size = input_size;
        length = 0;
        data = new Type[size];
    }
    ~Vector() {
        delete[] data;
    }
    //插入
    bool insert(int loc, Type value) {
        if (loc < 0 || loc > length) {
            return false;
        }
        if (length >= size) {
            expand();
        }
        for (int i = length; i > loc; --i) {
            data[i] = data[i - 1];
        }
        data[loc] = value;
        length++;
        return true;
    }
    //扩容
    void expand() {
        Type *old_data = data;
        size = size * 2;
        data = new Type[size];
        for (int i = 0; i < length; ++i) {
            data[i] = old_data[i];
        }
        delete[] old_data;
    }
    //查找
    int search(const Type &value) {
        for (int i = 0; i < length; i++){
            if (data[i] == value){
                return i;
            }
        }
        return -1;
    }
    bool remove(int index) {
        if (index < 0 || index >= length) {
            return false;
        }
        for (int i = index + 1; i < length; ++i) {
            data[i - 1] = data[i];
        }
        length = length - 1;
        return true;
    }
    void print() {
        for (int i = 0; i < length; i++){
            if (i > 0){
                cout << " ";
            }
            cout << data[i];
        }
        cout << endl;
    }
};
int main() {
    Vector<int> a(100);
    cout << a.insert(1, 0) << endl;
    cout << a.insert(0, 1) << endl;
    cout << a.insert(2, 1) << endl;
    cout << a.insert(1, 2) << endl;
    cout << a.insert(0, 3) << endl;
    cout << a.search(1) << endl;
    cout << a.search(4) << endl;
    return 0;
}

链表

#include <iostream>
#include<iostream>
using namespace std;
//结点模板类
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
//链表模板类
template <typename Type> class LinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        Node<Type> *current_node = head;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    //插入
    bool insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return false;
            }
            head = node;
            return true;
        }
        if (index == 0) {
            node->next = head;
            head = node;
            return true;
        }
        Node<Type> *current_node = head;
        int count = 0;
        while (current_node->next != NULL && count < index - 1) {
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1) {
            node->next = current_node->next;
            current_node->next = node;
            return true;
        }
        return false;
    }
    //遍历
    void output() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head;
        while (current_node != NULL) {
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << endl;
    }
    //删除
    int delete_node(int index) {
        if (head == NULL){
            return 0;
        }
        Node<Type> *current_node = head;
        int count = 0;
        if (index == 0){
            head = head->next;
            delete current_node;
            return 1;
        }
        while(current_node->next != NULL && count < index - 1){
            count ++;
            current_node = current_node->next;
        }
        if (current_node->next == NULL || count > index - 1){
            return 0;
        }else if(count == index - 1){
            Node<Type> *delete_node = current_node->next;
            current_node->next = delete_node->next;
            delete delete_node;
            return 1;
        }
    }
    //翻转
    void reverse() {
        if (head == NULL){
            return;
        }
        Node<Type> *current_node;
        Node<Type> *next_node;
        current_node = head->next;
        head->next = NULL;
        while(current_node != NULL){
            next_node = current_node->next;
            current_node->next = head;
            head = current_node;
            current_node = next_node;
        }
        return;
    }
};
int main() {
    LinkedList<int> linkedlist;
    int num;
    while(scanf("%d", &num) != EOF){
       if(num == 1){
           int loc, data;
                scanf("%d%d", &loc, &data);
                Node<int> *node = new Node<int>(data);
                if(linkedlist.insert(node, loc)){
                    cout << "success\n";
                }else{
                    cout << "failed\n";
                }
                
       }else if(num == 2){
           linkedlist.output();
       }else if(num == 3){
           int loc;
                scanf("%d", &loc);
                if(linkedlist.delete_node(loc)){
                    cout << "success\n";
                }else{
                    cout << "failed\n";
                }
       }else if(num == 4){
           linkedlist.reverse();
       }
    }
    return 0;
}

单向循环链表

#include<iostream>
using std::cin;
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
template <typename Type> class LinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        if (head == NULL){
            return;
        }
        Node<Type> *current_node = head->next;
        head->next = NULL;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    void insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return;
            }
            head = node;
            head->next = head;
            return;
        }
        if (index == 0) {
            node->next = head->next;
            head->next = node;
            return;
        }
        Node<Type> *current_node = head->next;
        int count = 0;
        while (current_node != head && count < index - 1) {
            current_node = current_node->next;
            count++;
        }
        
        if (count == index - 1) {
            node->next = current_node->next;
            current_node->next = node;
        }
        if (node == head->next){
            head = node;
        }
    }
};
int main() {
    LinkedList<int> linkedlist;
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++){
        Node<int> *node = new Node<int>(i);
        linkedlist.insert(node, i - 1);
    }
    return 0;
}

双向循环链表凭序号翻转

#include<iostream>
using std::cin;
using std::cout;
using std::endl;
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node<Type> *prior;
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
template <typename Type> class LinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        if (head == NULL){
            return;
        }
        Node<Type> *current_node = head->next;
        head->next = NULL;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    void insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return;
            }
            head = node;
            head->next = head;
            head->prior = head;
            return;
        }
        // if (index == 0) {
        //     node->next = head->next;
        //     head->next = node;
        //     return;
        // }
        Node<Type> *current_node = head->next;
        int count = 0;
        while (current_node != head && count < index - 1) {
            current_node = current_node->next;
            count++;
        }
        
        if (count == index - 1) {
            node->next = current_node->next;
            current_node->next->prior = node;
            current_node->next = node;
            node->prior = current_node;
        }
        if (node == head->next){
            head = node;
        }
    }
    void output() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head->next;
        while (current_node->next != head) {
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << head->data;
        cout << endl;
    }
    //反向输出方法
    void reverse_out(int index){
        int count = 0;
        Node<Type> *current_node = head->next;
        while (current_node != head && count < index - 1) {
            current_node = current_node->next;
            count++;
        }
        Node<Type> *start_node = current_node->next;//正确起始节点的前一节点
        //current_node = current_node->next;
        if (count == index - 1){
            while(current_node != start_node){
                cout << current_node->data << " ";
                current_node = current_node->prior;
            }
            cout << start_node->data;
            cout << endl;
        }
    }
};

int main(){
    LinkedList<int> linkedlist;
    int num, data;
    scanf("%d", &num);
    for (int i = 0; i < num; i++){
        scanf("%d", &data);
        Node<int> *node = new Node<int>(data);
        linkedlist.insert(node, i);
    }
    int start_num;
    scanf("%d", &start_num);
    linkedlist.reverse_out(start_num);
    //linkedlist.output();
}
Nemoxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表
likanghua666的博客
10-14 258
#include <iostream> using namespace std; #define amount 5 //#define OVERFLOW -2 #define OK 1 #define ERROR 0 #define MAXSIZE 100 typedef int Status; typedef int ElemType; typedef struct{ ElemType *elem; int length; }SqList; Status InitList (SqList
【c++】链表的插入
ruirui118的博客
01-23 1632
链表的插入 时间限制：1秒 内存限制：128M 题目描述 给定一个链表 对链表进行插入操作，最后顺序输出链表 输入描述 第一行一个整数n（2<=n<=1000000)，代表初始链表中的元素。 第二行含n个整数t（int范围），表示链表的每一个结点的值，链表前面指向后面。 第三行一个数m（1<=m< n ），代表要插入的结点的数量。 第4~m+3行，每行两个整数x和y（2<=x<n,y是int范围），代表从第x个输入的数后面插入一个结点，结点的值是y。 输出描
c/c++有序单链表的插入
weixin_62428212的博客
03-19 3416
c/++实现有序单链表的插入操作
数据结构之顺序表和单链表的C++实现及优化算法：初始化，三种插入与三种删除，逆置
lyz0817的博客
10-06 906
目录 一、需求分析 二、具体代码 三、课程设计报告 一、需求分析 （1）创建一个顺序表(或链表) （2）在表尾增加一个元素 （3）在指定位置插入一个元素 （4）在指定元素后插入一个元素，若有多个指定元素，则在第一个后插入 （5）在指定元素后插入一个元素，若有多个指定元素，则在每一个元素后都插入 （6）删除指定位置的元素 （7）删除一个指定值的元素，若存在多个则删除第一个 （8）删除指定值的元素，若有多个指定元素，则在删除每一个指定元素 （9）逆置顺序表(或链表) 二
自己写的顺序表的基本操作，插入、删除、修改，给出完整代码，其中运用到goto语句
桔子
09-09 6058
#include using namespace std; #define MAXSIZE 100 typedef int DataType; typedef struct { DataType data[MAXSIZE]; //通常用一位数组来描述顺序表的数据存储 int SeqLength; /*线性表长度*/ } SeqList; SeqList *Init_Seq
C++实现顺序表的常用操作(插入删出查找输出)
09-01
本文将详细介绍如何使用C++实现顺序表的插入、删除、查找和输出操作。 首先，顺序表的基本结构是通过一个结构体定义的，其中包含一个整型数组`data`用于存储元素，以及一个整型变量`SeqLength`记录当前顺序表的长度...
使用C++实现顺序链表
08-26
"使用C++实现顺序链表" 在计算机科学中，链表是一种常用的数据结构，它可以存储大量的数据。今天，我们将讨论如何使用C++语言实现顺序链表。 首先，我们需要创建一个头文件List.h，用于定义链表的结构和成员函数。...
线性表和链表的存储和增删改查c++
01-28
线性表的增删改查操作 - **插入**：在线性表的指定位置插入一个新元素，需要找到插入点并更新指针。对于链表，这涉及修改前后两个节点的指针。 - **删除**：根据给定的元素或位置删除一个元素，需要找到要删除的...
c c++ 顺序表 链表 队 栈 树类模板实现 以及例子
01-27
在本主题中，我们将深入探讨几种重要的数据结构及其在C/C++中的实现：顺序表、链表、队列、栈和树。这些数据结构不仅在算法设计中扮演着关键角色，而且在实际应用如操作系统、数据库、网络编程等领域也有广泛的应用...
C++中remove()函数总结
热门推荐
清风皓月长歌
07-23 3万+
对于remove函数，首先要明白remove函数的实现原理。首先remove函数在STL中的源代码如下: [cpp] view plain copy template class InputIterator, class OutputIterator, class T>    OutputIterator remove_copy ( Input
c++ 链表操作：添加、遍历、删除、查找
yes1cpp的专栏
02-09 1万+
链表是一种动态数据结构，因为在创建链表的时候，无需知道链表的长度。链表的每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 struct node { int value; node* next; }; 当插入一个结点的时候，我们只需要为新结点分配内存，然后调节结点的指针指向，新结点就被（逻辑上）链接到链表里。 /* 链表尾加入新元素*/
【数据结构】用C++实现顺序表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等）
韩豆豆的博客
05-18 3343
//顺序表的各种操作（包括头删，尾删，插入，逆序，摧毁，清空等等） //头文件 #pragma once #include using namespace std; template class SeqList { public: SeqList(size_t sz = INIT_SIZE); ~SeqList(); public: bool isfull() const {retur
数据结构——顺序表的创建、插入、删除等操作
执念
09-15 8680
顺序表实现  #include &lt;bits/stdc++.h&gt; const int maxn=1e3+10; using namespace std; struct List { int num; int id; }; typedef struct { List *place; int len; }Node; // 初始化 bool init(Node &amp;a) {...
顺序查找（基于无序链表）
能能
09-01 2747
基于无序链表的顺序查找 1、基本思想 采用链表数据结构，每个节点存储一个键值对 get()：顺序遍历链表，用equals()方法比较键，如果匹配成功就返回相应的值，否则返回null put()：顺序遍历链表，用equals()方法比较键，如果匹配成功就用第二个参数更新该键相关联的值，否则就创建一个新的节点并将该键值对插入到链表的开头。 2、算法实现 /** 算法3.1 顺序查找...
顺序表的简单操作代码（c++实现）
qq_45918426的博客
01-28 1040
#include<iostream> using namespace std; #define ERROR 0 #define OK 1 #define MAXSIZE 100 typedef int Status; typedef int ElemType; typedef struct{ ElemType *elem; int length; }SqList; ...
顺序表上进行增，删，查，改操作，C++实现
天空的博客
10-18 3838
顺序表上进行增，删，查，改操作，C++实现
顺序表的初始化，取值，查找，插入，删除操作
m0_55083785的博客
05-05 2000
#include<iostream> #include<string> using namespace std; #define MAXSIZE 100 typedef struct { int *elem; int length; }sqlist; //初始化 int InitList(sqlist &L) { L.elem = new int[MAXSIZE]; if (!L.elem) { exit(OVERFLOW); } L.length =
java宽度优先搜索之八数码,宽度优先搜索解决八数码问题
weixin_42526353的博客
03-12 475
解八数码问题：任意输入两个九宫格作为初始状态和目标状态，用宽度优先搜索求解。#include#include#include#include#includeusing namespace std;class NineNode{public:int nine[3][3];//九宫格int parent;//父节点，根节点的父节点为-1int i;//空白所在行int j;//空白所在列string ...
单链表上查找算法的实现
石焱的博客
01-02 4194
建立一个长度为n的带头结点的单链表，在该表中寻找第i个结点，若找到，则输出ok，否则输出error。处理数据类型为整型。Description第一行为链表的长度n； 第二行为链表中的数据元素； 第三行为要找的结点i。Input找到就输出ok，没找到就输出error。Output1234101 2 3 4 5 6 7 8 9 105Sample Input1ok#include using nam

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值