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

数据结构——线性表

本文贴出顺序表、链表 的例子代码，以及实例通讯录的代码。
文中代码均已在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;
}

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

  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出 愚梦者 深度学习人工智能计算机视觉c++opencv
    返回：OpenCV系列文章目录（持续更新中......）上一篇：如何利用OpenCV4.9离散傅里叶变换下一篇:目标本文内容主要介绍：如何使用YAML或XML文件打印和读取文件和OpenCV的文本条目？如何对OpenCV数据结构做同样的事情？如何为您的数据结构执行此操作？使用OpenCV数据结构，例如cv::FileStorage,cv::FileNodeorcv::FileNodeIterato
  • 【数据结构】实验一 实现顺序表各种基本运算的算法 张鱼·小丸子 数据结构实验c++数据结构
    题目：实现顺序表各种基本运算的算法要求：1、建立一个顺序表，输入n个元素并输出；2、查找线性表中的最大元素并输出；3、在线性表的第i个元素前插入一个正整数x；4、删除线性表中的第j个元素；5、将线性表中的元素按升序排列；6、将线性表中的元素就地逆序（只允许用一个暂存单元）；#include#defineSIZE1000usingnamespacestd;typedefstruct{int*a;//
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • java中栈和队列的解释和使用 。。。。。96 java开发语言
    一、栈在Java中，栈（Stack）是一种基于后进先出（LIFO）原则的数据结构，用于存储和管理对象。栈通常用于方法调用、表达式求值、历史记录管理等场景。在Java中，栈的常用方法包括：push(Eitem)：将元素压入栈顶。pop()：移除并返回栈顶元素。peek()：查看栈顶元素，但不移除它。empty()：检查栈是否为空。search(Objecto)：查找特定元素在栈中的位置，返回相对于栈
  • 数据结构——单向链表（C语言版） GG Bond.ฺ 数据结构链表c语言
    在数据结构和算法中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C语言中，我们可以使用指针来实现单向链表。下面将详细介绍如何用C语言实现单向链表。目录1.定义节点结构体2.初始化链表3.插入节点4.删除节点5.遍历链表6.主函数1.定义节点结构体首先，我们需要定义表示链表节点的结构体。每个节点包含一个数据域和一个指向下一个节点的指针域。typedefst
  • 数据结构之有序表 普通的一个普通猿 数据结构数据结构
    目录一简介二抽象数据类型描述三有序表的存储结构三有序表的基本运算一简介有序表是一种线性数据结构，其中元素按照特定顺序排列，每个元素具有一个唯一的键值，并且该键值在表中的位置反映了其相对大小关系。在有序表中，可以根据键值快速查找、插入和删除元素，常见的有序表包括有序数组和平衡二叉搜索树等结构。通过维护元素间的有序性，有序表提供了高效的检索服务，例如可以在对数时间内完成查找、插入和删除操作。二抽象数据
  • 【数据结构】复杂度计算 一只小鹿lu 数据结构
    1、时间复杂度1.1概念时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。1.2大O的渐进表示法大O符号（BigOnotation）：是用于描述函数渐进行为的数学符号。推导大O阶方法：1、用常数1取代运行时间中的所有加法常数。2、在修改后的运行次数函数中，只保
  • 数据结构——双向链表（C语言版） GG Bond.ฺ 数据结构链表c语言
    上一章：数据结构——单向链表（C语言版）-CSDN博客目录什么是双向链表？双向链表的节点结构双向链表的基本操作完整的双向链表示例总结什么是双向链表？双向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两个指针：一个指向前一个节点，一个指向后一个节点。双向链表可以在任意位置高效地插入和删除节点，相比单向链表，双向链表可以双向遍历，但相应地需要更多的内存空间存储额外的指针。双向链表的节点结构
  • 数据结构面试常见问题 工作学习小贴士 java数据结构
    数据结构是面试中经常被问及的重要主题之一，以下是一些常见的数据结构面试问题：什么是数据结构？为什么需要数据结构？数组和链表有什么区别？各自的优缺点是什么？树的常见类型有哪些？请解释它们的特点。图的常见表示方法有哪些？有向图和无向图有什么区别？栈和队列是什么？它们在哪些场景中有用？常见的排序算法有哪些？请分别介绍它们的思想和时间复杂度。什么是哈希表（HashTable）？它的工作原理是什么？如何处理
  • java后端工程师八股文合集 吹林 springcloudeurekajavajava-eespringboot
    1、SQL调优的基本步骤如下：确认性能瓶颈：首先要确定数据库中哪些查询是慢的，哪些查询最需要优化。可以通过监控数据库的CPU、磁盘I/O、网络I/O、缓存等指标来确定性能瓶颈。优化查询语句：如果查询语句本身存在问题，例如使用了不必要的子查询、重复的连接操作等，就需要对查询语句进行优化。优化索引：索引是提高查询性能的关键因素之一。可以通过创建、修改、删除索引来优化查询性能。优化数据结构：如果数据库中
  • 突破编程_C++_面试（STL 编程 stack） breakthrough_01 突破编程_C++_面试c++面试
    1请简述std::stack在C++STL中的基本功能和使用场景std::stack在C++STL（标准模板库）中是一个容器适配器，专门用于实现后进先出（LIFO，Last-In-First-Out）的数据结构。其基本功能和使用场景如下：基本功能：push(element)：向栈顶添加元素。pop()：移除栈顶元素。如果栈为空，则此操作可能会导致未定义行为。top()：返回栈顶元素的引用，但不移除
  • 无锁队列（Lock-Free Queue） 笨死de猪 游戏服务器架构开发语言c++无锁队列
    一、什么是无锁队列无锁队列（Lock-FreeQueue）是一种不使用锁机制（如互斥锁或读写锁）来实现线程安全的数据结构，是lock-free中最基本的数据结构。它通过复杂的原子操作（如CAS操作，在C++中，可以使用std::atomic库提供的原子操作）来确保在多线程环境下的正确性和一致性。无锁队列的设计目标是在高并发场景下提供高性能的入队和出队操作，避免了锁机制带来的性能开销和潜在的死锁问题
  • Redis是如何避免“数组+链表”的过长问题 龙大. Redisredis散列表数据库
    目录一、扩展和收缩二、使用高质量的哈希函数三、使用跳跃表（skiplist）或其他数据结构四、哈希表分片一、扩展和收缩Redis通过动态调整哈希表的大小来解决“数组+链表”的长度问题，这涉及到两个过程：扩展(Expand)和收缩(Shrink)。扩展:当哈希表的负载因子(loadfactor)超过一个阈值时，Redis会进行扩展操作。负载因子是哈希表已存储的元素数量与哈希表大小的比值。扩展操作包括
  • 编程之美_目录 wangwangmoon_light 编程之美算法
    编程之美0）0_0_常用函数库0）0_1_测试函数总结1）1.1数据结构之数组2）1.2数据结构之字符串3）1.3数据结构之链表4）1.4数据结构之队列5）1.5数据结构之栈5）1.6数据结构之二叉树6）1.7数据结构之BFS7）1.8数据结构之DFS8）2.1算法之动态规划
  • 数据结构与算法中顺序栈中入栈和出栈 小范想进鹅厂 gitc++c语言java数据结构
    在数据结构中，顺序栈是一种基于数组实现的栈结构。它具有先进后出的特点，可以通过入栈和出栈操作对栈进行操作。顺序栈的入栈操作即将元素插入到栈顶，出栈操作即将栈顶元素删除并返回。以下是顺序栈的入栈和出栈的示例代码：```python#定义顺序栈类classSeqStack:def__init__(self,max_size):self.max_size=max_sizeself.data=[None]
  • 数据结构链表 小范想进鹅厂 链表数据结构
    链表是一种常见的线性数据结构，用于存储一组元素。与数组不同的是，链表的元素可以不连续地存储在内存中，而是通过指针相互连接起来。链表由一系列节点组成。每个节点包含两部分：数据部分和指针部分。数据部分用于存储元素的值，指针部分用于指向下一个节点。链表有两种常见的类型：单向链表和双向链表。-单向链表：每个节点只有一个指针，指向下一个节点。链表的头节点指向第一个节点，尾节点指向最后一个节点，尾节点的指针为
  • 还在使用 RESTful API ? 试一试 GraphQL zoe_ya restfulgraphql后端
    前言GraphQL和RESTfulAPI是两种不同的网络通信接口设计理念，它们都可以用于客户端和服务器之间的数据交换，但是有着不同的工作方式和特点。各自的特点以及优缺点GraphQL：特点：查询语言:GraphQL是一个查询语言，允许客户端精确地指定需要的数据结构。单一端点:与REST不同，GraphQL通常只使用一个端点来处理所有的数据请求。强类型系统:GraphQL服务定义了一套强类型的API
  • C语言经典面试题目（十五） Masami22 C语言面试题目c语言面试开发语言职场和发展
    1、如何在C语言中实现堆数据结构？在C语言中，可以通过动态内存分配来实现堆数据结构。一种常见的方式是使用数组来表示堆，并使用堆的性质来维护数组的结构。以下是一个简单的堆数据结构的示例：#include#include#defineMAX_HEAP_SIZE100typedefstruct{int*elements;intsize;intcapacity;}Heap;Heap*createHeap(
  • Redis 的数据类型及使用场景 程序员JavaWind redis数据库缓存
    String最常规的set/get操作，Value可以是String也可以是数字。一般做一些复杂的计数功能的缓存。Hash这里Value存放的是结构化的对象，比较方便的就是操作其中的某个字段。我在做单点登录的时候，就是用这种数据结构存储用户信息，以CookieId作为Key，设置30分钟为缓存过期时间，能很好的模拟出类似Session的效果。List使用List的数据结构，可以做简单的消息队列的功
  • C语言经典面试题目（十二） Masami22 C语言面试题目c语言面试开发语言职场和发展算法数据结构链表
    1、如何在C语言中实现栈和队列数据结构？栈（Stack）：栈是一种后进先出（LIFO）的数据结构，可以使用数组或链表来实现。以下是一个使用数组实现的简单栈的示例：#defineMAX_SIZE100typedefstruct{intdata[MAX_SIZE];inttop;}Stack;voidinitStack(Stack*s){s->top=-1;}intisEmpty(Stack*s){r
  • C++从零开始(day44)——二叉搜索树 云淡风轻kk c++开发语言
    这是关于一个普通双非本科大一学生的C++的学习记录贴在此前，我学了一点点C语言还有简单的数据结构，如果有小伙伴想和我一起学习的，可以私信我交流分享学习资料那么开启正题今天分享的是关于二叉搜索树的知识点1.二叉搜索树概念二叉搜索树又叫做二叉排序树，有以下性质（或为空树）1.左子树结点所有结点的值都小于根节点的值2.右子树结点所有结点的值都大于根节点的值3.它的左右子树也都是二叉搜索树2.二叉搜索树操
  • C语言从入门到熟悉------第五阶段 DaveVV C语言专栏c语言开发语言c++算法
    结构体结构体很重要，一定要掌握。但是在很多C语言书籍中结构体的内容讲得非常少，因为从结构体开始，后面介绍的内容已经超出C语言基础的范畴，属于C高级编程部分了。仅仅具备前面的知识是远远不够的，因为在实际编程中，真正核心的部分正是自本章开始的C高级部分。而且结构体会影响到对数据结构和面向对象语言的学习。首先数据结构里面都是链表，所以必须要学结构体。其次如果以后要学习C++或Java的话，那么就必须了解
  • 5.68 BCC工具之runqlat.py解读 高桐@BILL AndroideBPFBooklinuxebpfandroidbccpython
    一，工具简介runqlat工具用于分析和监视运行队列延迟。运行队列是操作系统内核中用于管理待运行进程的数据结构。当进程准备运行时，它们会被添加到运行队列中，然后由调度器选择并在CPU上执行。runqlat工具通过测量进程在运行队列中等待的时间，并以直方图的形式展示，它显示了任务等待在CPU上运行的时间。这帮助开发者了解系统调度行为的性能。使用该工具可以帮助我们识别和解决与调度延迟相关的问题。例如，
  • ZooKeeper 概述 龙大. Zookeeperzookeeper分布式云原生
    定义和功能ZooKeeper是一个开源的分布式协调服务，由Apache软件基金会托管。它主要用于解决分布式应用中遇到的一些复杂问题，如命名服务、状态同步服务、集群管理、分布式锁和队列管理等。核心特性一致性:ZooKeeper保证了客户端之间的数据一致性，即客户端无论连接到哪一个ZooKeeper服务器，看到的数据都是一致的。简单的数据模型:ZooKeeper维护了一个类似文件系统的数据结构，它的数
  • linux基础学习，java中间件、数据库与spring框架 疯狂Android讲义 Javajavalinux学习
    蚂蚁金服一面：先自我介绍，讲讲自己基础掌握情况，以及项目经历平时会用到哪些数据结构？链表和数组的优缺点？解决hash冲突的方法有哪些？讲讲自己对HashMap的理解，以及和Weakhashmap的区别？你刚才讲的是JDK1.7版本的实现，知道JDK1.8做了哪些改动么？你们在微服务中用RPC通信还是REST？RPC和HTTP的关系是什么？谈谈什么是HTTP的长连接和短连接？TCP的三次握手和四次挥
  • python推导式 电商人学python python基础及进阶python开发语言经验分享
    python推导式是一种简洁且强大的内建语法结构，它允许我们以一种极其紧凑和易于理解的方式创建新的列表、字典、集合或生成器对象，能够更高效地操作和转换数据结构。列表推导式基本语法如下图：其他推导式的语法也基本相似，看着有点lambda的感觉，上面图片遍历一个名为oldlist的列表，并将大于0的元素逐一进行双倍运算后，添加至新列表newlist中。接下来我们逐一分析各个推导式：目录一、列表推导式二
  • 数据结构.pta测试二 丰海洋 数据结构
    #includeusingnamespacestd;typedefstructnode{intdata;node*next;}*List;ListlistPoduce(){inta;ListL;node*r,*new0;//创建指针L=newnode();//分配空间r=L;cin>>a;while(a!=-1){new0=newnode();new0->data=a;r->next=new0;r
  • 《数据结构》复试问答题总结 CarmenHu 计算机复试问答题数据结构深度优先算法
    请简述深度优先遍历、广度优先遍历的基本思想？：深度遍历是在图中先选择一个顶点，随后的每次遍历中选择与顶点相邻并且还没有遍历过的结点进行遍历，类似于树的先序遍历广度遍历是先在图中选择一个顶点，并加入队列中，然后向该顶点的所有未访问过的邻接点进行扩散，加入到队列当中，类似于树的广度遍历简述二叉树，完全二叉树，二叉排序树，平衡二叉树的特性：二叉树（BinaryTree）：要求其任意节点的子节点数量不超过
  • 【Rust】——Vector集合 Y小夜 Rust（官方文档重点总结）rust开发语言后端
    个人专栏：算法设计与分析：算法设计与分析_IT闫的博客-CSDN博客Java基础：Java基础_IT闫的博客-CSDN博客c语言：c语言_IT闫的博客-CSDN博客MySQL：数据结构_IT闫的博客-CSDN博客数据结构：数据结构_IT闫的博客-CSDN博客C++：C++_IT闫的博客-CSDN博客C51单片机：C51单片机（STC89C516）_IT闫的博客-CSDN博客基于HTML5的网页设计
  • 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其他