静候那一米阳光
静候那一米阳光

数据结构——线性表

本文贴出顺序表、链表 的例子代码，以及实例通讯录的代码。
文中代码均已在VS2015上测试，空指针均为nullptr（C++11）。参考来源：慕课网

线性表

线性表是n个数据元素的有限序列。

  • 分类：顺序表（即数组）、链表（分为 静态链表、单链表、循环链表、双向链表）

  • 应用场景：通讯录、一元多项式

顺序表

前驱、后继

BOOL InitList(List **list);//创建线性表
void DestroyList(List *list);//销毁线性表
void CleanList(List *list);//清空线性表
BOOL ListEmpty(List *list);//判断线性表是否是空
int ListLength(List *list);//获取线性表长度
BOOL GetElem(List *list,int i,Elem *e);//获取指定元素
int LocateElem(List *list,Elem *e);//寻找第一个满足e的数据元素的位序
BOOL PriorElem(List *list,Elem *currentElem,Elem *preElem);//获取指定元素的前驱
BOOL NextElem(List *list,Elem *currentElem,Elem *nextElem);//获取指定元素的后继
BOOL ListInsert(List *list,int i,Elem *e);//在第i个位置上插入元素
BOOL ListDelete(List *list,int i,Elem *e);//删除第i个位置的元素
void ListTraverse(List *list);//遍历线性表

示例：

#ifndef MYLIST_H
#define MYLIST_H

/****************************/
/*顺序表C++类[MyList.h]    */
/****************************/
class MyList
{
public:
    MyList(int size);
    ~MyList();
    void CleanList();
    bool ListEmpty();
    int ListLength();
    bool GetElem(int i, int *e);
    int LocateElem(int *e);
    bool PriorElem(int *currentElem, int *preElem);
    bool NextElem(int *currentElem, int *nextElem);
    bool ListInsert(int i, int *e);
    bool ListDelete(int i, int *e);
    void ListTraverse();
private:
    int *m_pList;
    int m_iSize;
    int m_iLength;
};

#endif // !MYLIST_H

/******************************/
/*顺序表C++实现[MyList.cpp]   */
/******************************/
#include "MyList.h"
#include 
using namespace std;
MyList::MyList(int size)
{
    m_iSize = size;
    m_pList = new int[m_iSize];
    m_iLength = 0;
}

MyList::~MyList()
{
    delete []m_pList;
    m_pList = nullptr;
}

void MyList::CleanList()
{
    m_iLength = 0;
}

bool MyList::ListEmpty()
{
    //return m_iLength==0?true:false;
    if (m_iLength == 0)
    {
        return true;
    }
    return false;
}

int MyList::ListLength()
{
    return m_iLength;
}

bool MyList::GetElem(int i, int * e)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }
    else 
    {
        *e = m_pList[i];
        return true;
    }
}

int MyList::LocateElem(int * e)
{
    for (int i = 0;i < m_iLength;i++)
    {
        if (m_pList[i] == *e)
        {
            return i;
        }
    }
    return -1;
}

bool MyList::PriorElem(int * currentElem, int * preElem)
{
    int temp = LocateElem(currentElem);
    if (temp == -1)
    {
        return false;
    }
    else if (temp == 0)
    {
        return false;
    }
    else
    {
        *preElem = m_pList[temp - 1];
        return true;
    }
}

bool MyList::NextElem(int * currentElem, int * nextElem)
{
    int temp = LocateElem(currentElem);
    if (temp == -1)
    {
        return false;
    }
    else if (temp == m_iLength - 1)
    {
        return false;
    }
    else
    {
        *nextElem = m_pList[temp + 1];
        return true;
    }
}

bool MyList::ListInsert(int i, int * e)
{
    if (i<0 || i>m_iLength)
    {
        return false;
    }
    for (int k = m_iLength - 1;k >= i;k--)
    {
        m_pList[k + 1] = m_pList[k];
    }
    m_pList[i] = *e;
    m_iLength++;
    return true;
}

bool MyList::ListDelete(int i, int * e)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }
    *e = m_pList[i];
    for (int k = i;k < m_iLength - 1;k++)
    {
        m_pList[k] = m_pList[k + 1];
    }
    m_iLength--;
    return true;
}

void MyList::ListTraverse()
{
    for (int i = 0;i < m_iLength;i++)
    {
        cout << m_pList[i] << " ";
    }
    cout << endl;
}

/******************************/
/*顺序表使用实例[Main.cpp]    */
/******************************/
#include "MyList.h"
#include 
using namespace std;

int main(void)
{
    int e1 = 3;
    int e2 = 5;
    int e3 = 7;
    int e4 = 2;
    int e5 = 9;
    int e6 = 1;
    int e7 = 8;
    int e8 = 10;
    int temp = -1;
    MyList *list1 = new MyList(10);
    list1->ListInsert(0, &e1);
    list1->ListInsert(1, &e2);
    list1->ListInsert(2, &e3);
    list1->ListInsert(3, &e4);
    list1->ListInsert(4, &e5);
    list1->ListInsert(5, &e6);
    list1->ListInsert(6, &e7);
    cout << list1->ListLength() << endl;
    list1->ListTraverse();
    /*cout << list1->ListEmpty() << endl;
    list1->CleanList();
    cout << list1->ListEmpty() << endl;
    list1->ListInsert(0, &e8);
    list1->ListTraverse();
    list1->ListDelete(0, &temp);
    cout << temp << endl;
    cout << list1->ListLength() << endl;*/


    if (list1->GetElem(0, &temp))
    {
        cout << temp << endl;
    }
    temp = 8;

    int m = list1->LocateElem(&temp);
    if(m!=-1)
    cout << m << endl;

    list1->PriorElem(&e4, &temp);
    cout <NextElem(&e4, &temp);
    cout << temp << endl;

    delete list1;
    list1 = nullptr;
    return 0;
}

链表

结点：头结点、数据域、指针域。

分类：

数据结构——线性表_第1张图片
链表

示例：

#ifndef MYLIST_H
#define MYLIST_H
/****************************/
/*单链表C++类[MyList.h]     */
/****************************/
#include "MyNode.h"
class MyList
{
public:
    MyList();
    ~MyList();
    void ClearList();
    bool ListEmpty();
    int ListLength();
    bool GetElem(int i,MyNode *pNode);
    int LocateElem(MyNode *pNode);
    bool PriorElem(MyNode *pCurrentNode, MyNode *pPreNode);
    bool NextElem(MyNode *pCurrentNode, MyNode *pNextNode);
    void ListTraverse();
    bool ListInsert(int i, MyNode *pNode);
    bool ListDelete(int i, MyNode *pNode);
    bool ListInsertHead(MyNode *pNode);
    bool ListInsertTail(MyNode *pNode);
private:
    MyNode *m_pList;
    int m_iLength;
};
#endif

/******************************/
/*单链表C++实现[MyList.cpp]   */
/******************************/
#include "MyList.h"
#include
using namespace std;
MyList::MyList()
{
    m_pList = new MyNode;
    m_pList->data = 0;
    m_pList->next = nullptr;
    m_iLength = 0;
}

MyList::~MyList()
{
    ClearList();
    delete m_pList;
    m_pList = nullptr;
}

void MyList::ClearList()
{
    MyNode *currentNode = m_pList->next;
    while (currentNode != nullptr)
    {
        MyNode *temp = currentNode->next;
        delete currentNode;
        currentNode = temp;
    }
    m_pList->next = nullptr;
}

bool MyList::ListEmpty()
{
    if (m_iLength == 0)
    {
        return true;
    }
    return false;
}

int MyList::ListLength()
{
    return m_iLength;
}

bool MyList::GetElem(int i, MyNode * pNode)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    MyNode *currentNodeBefore = nullptr;
    for (int k = 0;k <= i;k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    pNode->data = currentNode->data;
    return true;
}

int MyList::LocateElem(MyNode * pNode)
{
    MyNode *currentNode = m_pList;
    int count = 0;
    while (currentNode->next != nullptr)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pNode->data)
        {
            return count;
        }
        count++;
    }
    return -1;
}

bool MyList::PriorElem(MyNode * pCurrentNode, MyNode * pPreNode)
{
    MyNode *currentNode = m_pList;
    MyNode *tempNode = nullptr;
    while (currentNode->next!=nullptr)
    {
        tempNode = currentNode;
        currentNode = currentNode->next;
        if (currentNode->data== pCurrentNode->data)
        {
            if (tempNode==m_pList)
            {
                return false;
            }
            pPreNode->data = tempNode->data;
            return true;
        }
    }
    return false;
}

bool MyList::NextElem(MyNode * pCurrentNode, MyNode * pNextNode)
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pCurrentNode->data)
        {
            if (currentNode->next == nullptr)
            {
                return false;
            }
            pNextNode->data = currentNode->next->data;
            return true;
        }
    }
    return false;
}

void MyList::ListTraverse()
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
        currentNode->printNode();
    }
    cout << endl;
}

bool MyList::ListInsert(int i, MyNode * pNode)
{
    if (i<0 || i>m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    for (int k=0;knext;
    }
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    newNode->next = currentNode->next;
    currentNode->next = newNode;
    m_iLength++;
    return true;
}

bool MyList::ListDelete(int i, MyNode * pNode)
{
    if (i<0||i>=m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    MyNode *currentNodeBefore = nullptr;
    for (int k = 0;k <= i;k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    currentNodeBefore->next = currentNode->next;
    pNode->data = currentNode->data;
    delete currentNode;
    currentNode = nullptr;
    m_iLength--;
    return true;
}

bool MyList::ListInsertHead(MyNode * pNode)
{
    MyNode *temp = m_pList->next;
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    m_pList->next = newNode;
    newNode->next = temp;
    m_iLength++;
    return true;
}

bool MyList::ListInsertTail(MyNode * pNode)
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
    }
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    newNode->next = nullptr;
    currentNode->next = newNode;
    m_iLength++;
    return true;
}


/******************************/
/*结点类C++头文件[MyNode.h]   */
/******************************/
#ifndef MYNODE_H
#define MYNODE_H
#include 
using namespace std;
class MyNode
{
public:
    int data;
    MyNode *next;
    void printNode();
};
#endif

/******************************/
/*结点类C++实现[MyNode.cpp]   */
/******************************/
#include "MyNode.h"
#include 
using namespace std;
void MyNode::printNode()
{
    cout << data << " ";
}

/******************************/
/*单链表使用实例[Main.cpp]    */
/******************************/
#include "MyList.h"
#include
using namespace std;
int main()
{
    MyNode node1;
    node1.data = 1;
    MyNode node2;
    node2.data = 2;
    MyNode node3;
    node3.data = 3;
    MyNode node4;
    node4.data = 4;
    MyNode node5;
    node5.data = 5;

    MyList *pList = new MyList();
    //插入头元素
    pList->ListInsertHead(&node1);
    pList->ListInsertHead(&node2);
    pList->ListInsertHead(&node3);
    pList->ListInsertHead(&node4);
    pList->ListInsertHead(&node5);
    //插入尾元素
    pList->ListInsertTail(&node1);
    pList->ListInsertTail(&node2);
    pList->ListInsertTail(&node3);
    pList->ListInsertTail(&node4);
    pList->ListInsertTail(&node5);
    pList->ListTraverse();
    //在某位置插入元素
    pList->ListInsert(1, &node5);
    pList->ListTraverse();

    MyNode temp;
    //删除某位置元素
    pList->ListDelete(1, &temp);
    pList->ListTraverse();
    cout <GetElem(1,&temp);
    cout << temp.data << endl;
    //取前驱
    pList->PriorElem(&node4, &temp);
    cout << temp.data << endl;
    //取后继
    pList->NextElem(&node4, &temp);
    cout << temp.data << endl;
    //元素位置
    cout<LocateElem(&node5)<

进阶（通讯录实现）

MyList.h

#ifndef MYLIST_H
#define MYLIST_H
#include "MyNode.h"
class MyList
{
public:
    MyList();
    ~MyList();
    void ClearList();
    bool ListEmpty();
    int ListLength();
    bool GetElem(int i,MyNode *pNode);
    int LocateElem(MyNode *pNode);
    bool PriorElem(MyNode *pCurrentNode, MyNode *pPreNode);
    bool NextElem(MyNode *pCurrentNode, MyNode *pNextNode);
    void ListTraverse();
    bool ListInsert(int i, MyNode *pNode);
    bool ListDelete(int i, MyNode *pNode);
    bool ListInsertHead(MyNode *pNode);
    bool ListInsertTail(MyNode *pNode);
private:
    MyNode *m_pList;
    int m_iLength;
};
#endif

MyList.cpp

#include "MyList.h"
#include "MyNode.cpp"//不加总是报错（VS2015中）
#include
using namespace std;
MyList::MyList()
{
    m_pList = new MyNode;
    //m_pList->data = 0;
    m_pList->next = nullptr;
    m_iLength = 0;
}

MyList::~MyList()
{
    ClearList();
    delete m_pList;
    m_pList = nullptr;
}

void MyList::ClearList()
{
    MyNode *currentNode = m_pList->next;
    while (currentNode != nullptr)
    {
        MyNode *temp = currentNode->next;
        delete currentNode;
        currentNode = temp;
    }
    m_pList->next = nullptr;
}

bool MyList::ListEmpty()
{
    if (m_iLength == 0)
    {
        return true;
    }
    return false;
}

int MyList::ListLength()
{
    return m_iLength;
}

bool MyList::GetElem(int i, MyNode * pNode)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    MyNode *currentNodeBefore = nullptr;
    for (int k = 0;k <= i;k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    pNode->data = currentNode->data;
    return true;
}

int MyList::LocateElem(MyNode * pNode)
{
    MyNode *currentNode = m_pList;
    int count = 0;
    while (currentNode->next != nullptr)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pNode->data)
        {
            return count;
        }
        count++;
    }
    return -1;
}

bool MyList::PriorElem(MyNode * pCurrentNode, MyNode * pPreNode)
{
    MyNode *currentNode = m_pList;
    MyNode *tempNode = nullptr;
    while (currentNode->next!=nullptr)
    {
        tempNode = currentNode;
        currentNode = currentNode->next;
        if (currentNode->data== pCurrentNode->data)
        {
            if (tempNode==m_pList)
            {
                return false;
            }
            pPreNode->data = tempNode->data;
            return true;
        }
    }
    return false;
}

bool MyList::NextElem(MyNode * pCurrentNode, MyNode * pNextNode)
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pCurrentNode->data)
        {
            if (currentNode->next == nullptr)
            {
                return false;
            }
            pNextNode->data = currentNode->next->data;
            return true;
        }
    }
    return false;
}

void MyList::ListTraverse()
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
        currentNode->printNode();
    }
    cout << endl;
}

bool MyList::ListInsert(int i, MyNode * pNode)
{
    if (i<0 || i>m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    for (int k=0;knext;
    }
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    newNode->next = currentNode->next;
    currentNode->next = newNode;
    m_iLength++;
    return true;
}

bool MyList::ListDelete(int i, MyNode * pNode)
{
    if (i<0||i>=m_iLength)
    {
        return false;
    }
    MyNode *currentNode = m_pList;
    MyNode *currentNodeBefore = nullptr;
    for (int k = 0;k <= i;k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    currentNodeBefore->next = currentNode->next;
    pNode->data = currentNode->data;
    delete currentNode;
    currentNode = nullptr;
    m_iLength--;
    return true;
}

bool MyList::ListInsertHead(MyNode * pNode)
{
    MyNode *temp = m_pList->next;
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    m_pList->next = newNode;
    newNode->next = temp;
    m_iLength++;
    return true;
}

bool MyList::ListInsertTail(MyNode * pNode)
{
    MyNode *currentNode = m_pList;
    while (currentNode->next!=nullptr)
    {
        currentNode = currentNode->next;
    }
    MyNode *newNode = new MyNode;
    if (newNode==nullptr)
    {
        return false;
    }
    newNode->data = pNode->data;
    newNode->next = nullptr;
    currentNode->next = newNode;
    m_iLength++;
    return true;
}

MyNode.h

#ifndef MYNODE_H
#define MYNODE_H
#include "Person.h"
#include 
using namespace std;
class MyNode
{
public:
    Person data;
    MyNode *next;
    void printNode();
};
#endif

MyNode.cpp

#include "MyNode.h"
#include 
using namespace std;

void MyNode::printNode()
{
    cout << data << " ";
}

Person.h

#ifndef PERSON_H
#define PERSON_H

#include 
#include 
using namespace std;
class Person
{
    friend ostream &operator<<(ostream &out, Person &person);
public:
    string name;
    string phone;
    Person &operator=(Person &person);
    bool operator==(Person &person);
};
#endif // !PERSON_H

Person.cpp

#include "Person.h"

Person & Person::operator=(Person & person)
{
    this->name = person.name;
    this->phone = person.phone;
    return *this;
}

bool Person::operator==(Person &person)
{
    if (this->name == person.name&&this->phone == person.phone)
    {
        return true;
    }
    return false;
}

ostream & operator<<(ostream & out, Person & person)
{
    out << person.name << ":" << person.phone << " ";
    return out;
}

Main.cpp

#include "MyList.h"
#include
using namespace std;
int menu()
{
    cout << "功能菜单" << endl;
    cout << "1.新建联系人" << endl;
    //cout << "2.删除联系人" << endl;
    cout << "3.浏览通讯录" << endl;
    cout << "4.退出通讯录" << endl;
    int order;
    cout << "请输入:" << ends;
    cin >> order;
    return order;
}
void createPerson(MyList *pList)
{
    MyNode node;
    Person person;
    cout << "请输入姓名：" << ends;
    cin >> person.name;
    cout << "请输入电话：" << ends;
    cin >> person.phone;
    node.data = person;
    pList->ListInsertTail(&node);
}
int main()
{

    int userOrder=0;
    MyList *pList = new MyList();
    while (userOrder != 4)
    {
        userOrder = menu();
        switch (userOrder)
        {
        case 1:
            createPerson(pList);
            break;
        case 2:
            break;
        case 3:
            cout << "liulan" << endl;
            pList->ListTraverse();
            break;
        case 4:
            exit(0);
        default:
            break;
        }
    }

    delete pList;
    pList = nullptr;
    return 0;
}

你可能感兴趣的:(数据结构——线性表)

  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redisbootstrap数据库
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【树一线性代数】005入门 Owlet_woodBird 算法
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 【数据结构-一维差分】力扣2848. 与车相交的点 hlc@ 数据结构数据结构leetcode算法
    给你一个下标从0开始的二维整数数组nums表示汽车停放在数轴上的坐标。对于任意下标i，nums[i]=[starti,endi]，其中starti是第i辆车的起点，endi是第i辆车的终点。返回数轴上被车任意部分覆盖的整数点的数目。示例1：输入：nums=[[3,6],[1,5],[4,7]]输出：7解释：从1到7的所有点都至少与一辆车相交，因此答案为7。示例2：输入：nums=[[1,3],[5
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • ⭐算法入门⭐《归并排序》简单01 —— LeetCode 21. 合并两个有序链表 英雄哪里出来 《LeetCode算法全集》算法数据结构链表c++归并排序
    饭不食，水不饮，题必须刷C语言免费动漫教程，和我一起打卡！《光天化日学C语言》LeetCode太难？先看简单题！《C语言入门100例》数据结构难？不存在的！《数据结构入门》LeetCode太简单？算法学起来！《夜深人静写算法》文章目录一、题目1、题目描述2、基础框架3、原题链接二、解题报告1、思路分析2、时间复杂度3、代码详解三、本题小知识一、题目1、题目描述  将两个不降序链表合并为一个新的不降
  • 数据结构 1 五花肉村长 数据结构算法开发语言c语言visualstudio
    1.什么是数据结构数据结构（DataStructure）是计算机存储和组织数据的方式，是指相互之间存在的一种或多种特定关系的数据元的集合。2.什么是算法算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《
  • 【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】 NeVeRMoRE_2024 数据结构与算法实践数据结构算法leetcodeb树
    数据结构和算法实践-树-LeetCode113-路径总和Ⅱ题目MyThought代码示例JAVA-8题目给你二叉树的根节点root和一个整数目标和targetSum，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点输入：root=[5,4,8,11,null,13,4,7,2,null,null,5,1],targetSum=22输出：[[5,4,11,2],[
  • 【Python】数据结构,链表,算法详解 AIAdvocate python数据结构链表排序算法广度优先深度优先
    今日内容大纲介绍自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树1.自定义代码-模拟链表完整版"""案例:自定义代码,模拟链表.​背景: 顺序表在存储数据的时候,需要使用到连续的空间,如果空间不够,就会导致扩容失败,针对于这种情况,我们可以通过链表实现
  • AI教你学Python 第4天：函数和模块 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第四天：数据结构一、什么是数据结构？数据结构是计算机科学中用于组织和存储数据的特定方式。良好的数据结构能够提高数据的访问效率、修改频率和管理能力。Python提供了多种内置数据结构，如列表、元组、字典和集合，便于开发者更有效地处理数据。二、Python中的基本数据结构1.列表（List）定义：列表是一个有序的可变集合，允许重复元素。使用方括号[]表示。#示例：定义一个列表fruits=['appl
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • Rust中的所有权和借用规则详解 代码云1 rust开发语言后端
    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
  • 二叉树--python 电子海鸥 Python数据结构与算法python开发语言数据结构
    二叉树一、概述1、介绍是一种非线性数据结构，将数据一分为二，代表根与叶的派生关系，和链表的结构类似，二叉树的基本单元是结点，每个节点包括值和左右子节点引用。每个节点都有两个引用（类似于双向链表），分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的结点时，我们将在该节点的左子节点以及其以下结点所形成的树称为左子树，同理，右子节点的部分被称为右子树。在二叉树中，除了叶节点
  • 使用WAF防御网络上的隐蔽威胁之反序列化攻击 baiolkdnhjaio 网络安全
    什么是反序列化反序列化是将数据结构或对象状态从某种格式转换回对象的过程。这种格式通常是二进制流或者字符串（如JSON、XML），它是对象序列化（即对象转换为可存储或可传输格式）的逆过程。反序列化的安全风险反序列化的安全风险主要来自于处理不受信任的数据源时的不当反序列化。如果应用程序反序列化了恶意构造的数据，攻击者可能能够执行代码、访问敏感数据、进行拒绝服务攻击等。这是因为反序列化过程中可能会自动触
  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池） 爱打怪的小魔女 java线程池队列封装
    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
  • java线程Thread和Runnable区别和联系 zx_code javajvmthread多线程Runnable
    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。 模拟窗口买票，第一例子继承thread，代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(
  • 【转】JSON与XML的区别比较 丁_新 jsonxml
    1.定义介绍 (1).XML定义 扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 XML是标
  • c++ 实现五种基础的排序算法 CrazyMizzz C++c算法
    #include<iostream> using namespace std; //辅助函数，交换两数之值 template<class T> void mySwap(T &x, T &y){ T temp = x; x = y; y = temp; } const int size = 10; //一、用直接插入排
  • 我的软件 麦田的设计者 我的软件音乐类娱乐放松
         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
  • linux awk命令详解 被触发 linux awk
    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 awk处理过程: 依次对每一行进行处理，然后输出 awk命令形式: awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
  • 各种语言比较 _wy_ 编程语言
                        Java Ruby PHP 擅长领域                  
  • oracle 中数据类型为clob的编辑 知了ing oracle clob
    public void updateKpiStatus(String kpiStatus,String taskId){ Connection dbc=null; Statement stmt=null; PreparedStatement ps=null; try { dbc = new DBConn().getNewConnection(); //stmt = db
  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据 矮蛋蛋 zookeeper
    原文地址： http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 安装和配置详解 本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
  • tomcat数据源 alafqq tomcat
    数据库 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。 没有使用JNDI时我用要这样连接数据库： 03.  Class.forName("com.mysql.jdbc.Driver");  04.  conn
  • 遍历的方法 百合不是茶 遍历
                                                          遍历 在java的泛
  • linux查看硬件信息的命令 bijian1013 linux
    linux查看硬件信息的命令 一.查看CPU： cat /proc/cpuinfo   二.查看内存： free   三.查看硬盘： df   linux下查看硬件信息 1、lspci 列出所有PCI 设备； lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
  • java常见的ClassNotFoundException bijian1013 java
    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
  • 【Gson五】日期对象的序列化和反序列化 bit1129 反序列化
    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：   1. 序列化时，Date对象序列化的字符串日期格式如何 2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 3. Date A -> str -> Date B,A和B对象是否equals   默认序列化和反序列化     import com
  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream bit1129 Stream
      1. DStream的类说明文档：   /** * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous * sequence of RDDs (of the same type) representing a continuous st
  • 通过nginx获取header信息 ronin47 nginx header
    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， if ( $http_cookie ~* "(.*)$") {         set $all_cookie $1; }     变量$all_cookie就获得了cookie的值，可以用于运算了
  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 bylijinnan java
    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 写了个java版的： public class Print_1_To_NDigit { /** * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 * 1.使用字符串
  • Netty源码学习-ReplayingDecoder bylijinnan javanetty
    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 http://bylijinnan.iteye.com/blog/1982618 API说，ReplayingDecoder简化了操作，比如： FrameDecoder在decode时，需要判断数据是否接收完全： public class IntegerH
  • js特殊字符过滤 cngolon js特殊字符js特殊字符过滤
    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
  • hibernate使用sql查询 ctrain Hibernate
    import java.util.Iterator; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transa
  • linux shell脚本中切换用户执行命令方法 daizj linuxshell命令切换用户
    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：   1、执行单个命令：su - user -c "command" 如：下面命令是以test用户在/data目录下创建test123目录 [root@slave19 /data]# su - test -c "mkdir /data/test123" 
  • 好的代码里只要一个 return 语句 dcj3sjt126com return
    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
  • Android动画效果学习 dcj3sjt126com android
    1、透明动画效果 方法一：代码实现 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_main, container, fals
  • linux复习笔记之bash shell (4)管道命令 eksliang linux管道命令汇总linux管道命令linux常用管道命令
    转载请出自出处： http://eksliang.iteye.com/blog/2105461     bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。     上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？     答：非常的经典的一句话，记住了，何为管
  • Android系统中自定义按键的短按、双击、长按事件 gqdy365 android
    在项目中碰到这样的问题： 由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 1、单击事件：就是普通key的单击； 2、双击事件：500ms内同一按键单击两次； 3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 4、组合按键：两个以上按键同时按住；
  • asp.net获取站点根目录下子目录的名称 hvt .netC#asp.nethovertreeWeb Forms
    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： <asp:ListBox runat="server" ID="lbKeleyiFolder" />   那么在页面上显示根目录子文件夹的代码如下： string[] m_sub
  • Eclipse程序员要掌握的常用快捷键 justjavac javaeclipse快捷键ide
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
  • c++编程随记 lx.asymmetric C++笔记
     为了字体更好看，改变了格式……   &&运算符：   #include<iostream> using namespace std; int main(){      int a=-1,b=4,k;      k=(++a<0)&&!(b--
  • linux标准IO缓冲机制研究 音频数据 linux
    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
  • 随想 生活 暗黑小菠萝 生活
    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。   毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
  • 我认为POJO是一个错误的概念 windshome javaPOJO编程J2EE设计
                  这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。    &
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他