线性表（List）
定义： 由同数据元素构成有序数列的线性结构。 1.线性表元素的个数称为线性表的长度 2.线性表中没有元素时，称为空表 3.表起始位置称表头，表结束位置称作表尾
线性表的顺序表示
指用一组地址连续的存储单元依次储线性表的数据元素。（利用数组的连续存储空间顺序存放线性表各元素）
###主要实现操作
先回忆一下C语言中的一个函数的用法--malloc
参考链接
初始化
建立空的顺序表 1.先申请一个结构，空间 2.将指针指向Last并赋值为-1 3.返回指针
查找
1.需要一个线性表，和线性表结构指针 2.用一个循环来一一遍历，比较值是否相等，找到以后返回储存位置，没有找到返回-1.
插入
注意：先移动，再插入 1.判断表有没有满还有插入位置的合法性（即申请空间最大值【数组大小】和表的长度范围内） 2.将i后面的的元素倒序向后移动，插入新元素
删除
将i之后的全部元素往前挪动 1.检查删除位置的合法性（有没有在表的长度范围内） 2.将i之后的数从左往右顺序向前移动
线性表的链式存储
不要求逻辑上相邻的两个元素物理上也相邻；通过“链”建立其数据元素之间的逻辑关系 即删除，插入不需要移动数据元素，只需要修改“链”
链表的每一个节点都是一个结构
class ListNode//链表节点类定义 class ListNode//链表节点类定义 { public: int data;//代表节点所对应的数据 ListNode* next;//下一个节点的位置next指针 ListNode() { next = NULL; } };
主要实现操作
求表长
链表由于不像顺序表一样类似于数组，我们不清楚表长为多少,我们只知道链表的头指针。 1.设一个临时指针P指向链表的头 2.然后用一个循环来遍历链表，每遍历一个表长加一。 3.返回长度
查找
在数组里面的查找指定位置的元素是很方便的，直接返回就可以了，但是在链表里面需要我们遍历。 1.设一个临时指针P指向链表的头 2.设i=1（P指向第一个元素）来表示P指向的是第几个元素。 3.使用循环（表不空，i<k(所要找的位置元素)）
插入
1.先构造一个新节点，用s指向； 2.再找到链表的第i-1个节点，用P指向； 3.然后修改指针，插入节点（将新节点插在P后面）
P->next=s; s->next=p->next;
删除
1.找到链表的第i-1个节点，用P指向； 2.再用S指针指向要被删除的节点（P的下一个节点） 3.然后修改指针删除S所指向的节点
s=p->next; p->next=s->next; delete s;
习题练习
DS顺序表--类实现（创建、插入、删除、查找）
//A. DS顺序表--类实现
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//顺序表类定义
class SeqList
{
private:
int* list;//元素数组
int maxsize;//顺序表最大长度
int size;//顺序表实际长度
public:
SeqList();//构造函数
~SeqList();//析构函数
int list_size(int a);//获取顺序表实际长度
int list_insert(int i, int item);//插入一个元素，参数是插入的数值和位置
int list_del(int i);//删除一个元素，参数是删除的位置
int list_get(int i);//获取一个元素，参数是获取的位置
void list_display();//输出
};
SeqList::SeqList()
{
maxsize = 1000;
size = 0;
list = new int[maxsize];
}
SeqList::~SeqList()
{
delete[]list; //回收空间
}
int SeqList::list_size(int a)
{
list[size]=a;
size++;
return size;
}
int SeqList::list_insert(int i,int item)
{
if (i<0 || i>size+1)
{
cout << "error" << endl;
return 0;
}
else
{
for (int j = size; j > i-1 ; j--)
{
list[j] = list[j - 1];
}
list[i - 1] = item;
size++;
list_display();
return 0;
}
}
int SeqList::list_del(int i)
{
if (i <= 0 || i > size)
{
cout << "error" << endl;
return 0;
}
else
{
for (int j = i - 1; j < size-1; j++)
{
list[j] = list[j + 1];
}
size--;
list_display();
}
return 0;
}
int SeqList::list_get(int i)
{
if (i > 0 && i <= size)
{
cout << list[i - 1] << endl;
return list[i - 1];
}
else
{
cout << "error" << endl;
return 0;
}
}
void SeqList::list_display()
{
cout << size << " ";
for (int i = 0; i < size; i++)
{
cout << list[i] << " ";
}
cout << endl;
}
int main()
{
int n,a;
cin >> n;
SeqList S;
for (int j = 0; j < n; j++)
{
cin >> a;
S.list_size(a);
}
S.list_display();
int i, item;
cin >> i >> item;
S.list_insert(i, item);
cin >> i >> item;
S.list_insert(i, item);
cin >> i;
S.list_del(i);
cin >> i;
S.list_del(i);
cin >> i;
S.list_get(i);
cin >> i;
S.list_get(i);
return 0;
}
DS顺序表--连续操作
// DS顺序表--连续操作
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//顺序表类定义
class SeqList
{
private:
int* list;//元素数组
int maxsize;//顺序表最大长度
int size;//顺序表实际长度
public:
SeqList();//构造函数
~SeqList();//析构函数
int list_size(int a);//获取顺序表实际长度
int list_insert(int i, int n,int item[]);//插入一个元素，参数是插入的数值和位置
int list_del(int i,int n);//删除一个元素，参数是删除的位置
void list_display();//输出
};
SeqList::SeqList()
{
maxsize = 1000;
size = 0;
list = new int[maxsize];
}
SeqList::~SeqList()
{
delete[]list; //回收空间
}
int SeqList::list_size(int a)
{
list[size] = a;
size++;
return size;
}
int SeqList::list_insert(int i, int n,int item[])
{
if (i<1 || i>size + 1||i+n>maxsize)
{
//cout << "error" << endl;
return 0;
}
else
{
for (int j = size -1; j >= i - 1; j--)
{
list[j+n] = list[j ];
}
for (int j = i - 1; j < i + n-1; j++)
{
list[j] = item[j - i + 1];
}
size+=n;
list_display();
return 0;
}
}
int SeqList::list_del(int i,int n)
{
if (i <1|| i+n-1 > size||i>size)
{
//cout << "error" << endl;
return 0;
}
else
{
for (int j = i - 1; j <size-n; j++)
{
list[j] = list[j +n];
}
size-=n;
list_display();
return 0;
}
}
void SeqList::list_display()
{
cout << size << " ";
for (int i = 0; i < size; i++)
{
cout << list[i] << " ";
}
cout << endl;
}
int main()
{
int n, a;
cin >> n;
SeqList S;
for (int j = 0; j < n; j++)
{
cin >> a;
S.list_size(a);
}
S.list_display();
int i, f;
cin >> i >> f;
int* item = new int[f];
for (int i = 0; i < f; i++)
{
cin>>item[i];
}
S.list_insert(i, f,item);
cin >> i >> f;
S.list_del(i,f);
return 0;
}
DS顺序表--合并操作
//DS顺序表--合并操作
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//顺序表类定义
class SeqList
{
private:
int* list;//元素数组
int maxsize;//顺序表最大长度
int size;//顺序表实际长度
public:
SeqList();//构造函数
~SeqList();//析构函数
int list_size(int a);//获取顺序表实际长度
void list_insert(SeqList &s1,SeqList &s2);//插入一个元素，参数是插入的数值和位置
void list_display();//输出
};
SeqList::SeqList()
{
maxsize = 1000;
size = 0;
list = new int[maxsize];
}
SeqList::~SeqList()
{
delete[]list; //回收空间
}
int SeqList::list_size(int a)
{
list[size] = a;
size++;
return size;
}
void SeqList::list_insert(SeqList& s1, SeqList& s2)
{
size = s1.size + s2.size;
int a = 0, b = 0,i=0;
while (a<s1.size && b<s2.size)
{
if (s1.list[a] < s2.list[b])
{
list[i] = s1.list[a];
a++;
i++;
}
else
{
list[i] = s2.list[b];
b++;
i++;
}
}
while (a < s1.size)
{
list[i] = s1.list[a];
a++;
i++;
}
while (b < s2.size)
{
list[i] = s2.list[b];
b++;
i++;
}
list_display();
}
void SeqList::list_display()
{
cout << size << " ";
for (int i = 0; i < size; i++)
{
cout << list[i] << " ";
}
cout << endl;
}
int main()
{
int n, m,a;
cin >> n;
SeqList s1;
for (int i= 0; i < n; i++)
{
cin >> a;
s1.list_size(a);
}
cin >> m;
SeqList s2;
for (int i = 0; i < m; i++)
{
cin >> a;
s2.list_size(a);
}
SeqList S;
S.list_insert(s1, s2);
return 0;
}
DS顺序表之循环移位
//DS顺序表之循环移位
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//顺序表类定义
class SeqList
{
private:
int* list;//元素数组
int maxsize;//顺序表最大长度
int size;//顺序表实际长度
public:
SeqList();//构造函数
~SeqList();//析构函数
int list_size(int a);//获取顺序表实际长度
void list_insert(int d,int t);//插入一个元素，参数是插入的数值和位置
void list_display();//输出
};
SeqList::SeqList()
{
maxsize = 1000;
size = 0;
list = new int[maxsize];
}
SeqList::~SeqList()
{
delete[]list; //回收空间
}
int SeqList::list_size(int a)
{
list[size] = a;
size++;
return size;
}
void SeqList::list_insert(int d,int t)
{
int* temp = new int[size];
for (int i = 0; i < size; i++)
{
temp[i] = list[i];
}
if (d == 0)
{
for (int j = 0; j < size - t; j++)
{
list[j] = temp[j + t];
}
for (int j = size - t; j < size; j++)
{
list[j] = temp[j - (size - t)];
}
list_display();
}
else
{
for (int j = t; j < size; j++)
{
list[j] = temp[j - t];
}
for (int j = 0; j < t; j++)
{
list[j] = temp[size - t + j];
}
list_display();
}
delete[]temp;
}
void SeqList::list_display()
{
for (int i = 0; i < size; i++)
{
cout << list[i] << " ";
}
cout << endl;
}
int main()
{
int n, m, a;
cin >> n;
SeqList s1;
for (int i = 0; i < n; i++)
{
cin >> a;
s1.list_size(a);
}
s1.list_display();
int d, t;
cin >> d >> t;
s1.list_insert(d, t);
cin >> d >> t;
s1.list_insert(d, t);
return 0;
}
DS单链表--类实现
//vDS单链表--类实现
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//链表节点类定义
class ListNode
{
public:
int data;
ListNode* next;
ListNode() { next = NULL; }
};
//带头结点的单链表类定义
class LinkList
{
public:
ListNode* head;
int len;
//操作定义
LinkList();
~LinkList();
ListNode* LL_index(int t)//返回第i个结点的指针，若不存在返回NULL
{
if (t<0 || t>len)return NULL;
ListNode* l = head;
for (int i = 0; i < t; i++)
{
l = l->next;
}
return l;
}
void init(int n)
{
ListNode* node = head;
len = n;
int num;
while (n--)
{
cin >> num;
ListNode* l = new ListNode;
l->data = num;
node->next = l;
node = node->next;
}
}
int LL_get(int i);//获取第i个元素的数据
int LL_insert(int i, int item);//把数值item插入第i个位置
int LL_del(int i);//删除第i个结点
void LL_display();//输出单链表的内容
};
LinkList::LinkList()
{
head = new ListNode();
len = 0;
}
LinkList::~LinkList()
{
ListNode* p, * q;
p = head;
while (p != NULL)
{
q = p;
p = p->next;
delete q;
}
len = 0;
head = NULL;
}
int LinkList::LL_get(int i)
{
if (i<1 || i>len)
{
cout << "error" << endl;
return NULL;
}
else
{
cout << LL_index(i)->data << endl;
return LL_index(i)->data;
}
}
int LinkList::LL_insert(int i, int item)
{
if (i<1 || i>len + 1)
{
cout << "error" << endl;
return -1;
}
else
{
ListNode* l = LL_index(i - 1);
ListNode* ll = new ListNode;
ll->data = item;
ll->next = l->next;
l->next = ll;
len++;
LL_display();
return 0;
}
}
int LinkList::LL_del(int i)
{
if (i<1 || i>len)
{
cout << "error" << endl;
return -1;
}
else
{
ListNode* l = LL_index(i - 1);
ListNode* ll = l->next;
l->next = ll->next;
l = NULL;
len--;
LL_display();
return 0;
}
}
void LinkList::LL_display()
{
ListNode* p;
p = head->next;
while (p)
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
}
int main()
{
int n;
cin >> n;
LinkList L;
L.init(n);
L.LL_display();
int i, item;
cin >> i >> item;
L.LL_insert(i, item);
cin >> i >> item;
L.LL_insert(i, item);
cin >> i;
L.LL_del(i);
cin >> i;
L.LL_del(i);
cin >> i;
L.LL_get(i);
cin >> i;
L.LL_get(i);
return 0;
}
DS单链表--结点交换
//DS单链表--结点交换
#include <iostream>
using namespace std;
#define ok 0;
#define error -1;
//链表节点类定义
class ListNode
{
public:
int data;
ListNode* next;
ListNode() { next = NULL; }
};
//带头结点的单链表类定义
class LinkList
{
public:
ListNode* head;
int len;
//操作定义
LinkList();
~LinkList();
ListNode* LL_index(int t)//返回第i个结点的指针，若不存在返回NULL
{
if (t<0 || t>len)return NULL;
ListNode* l = head;
for (int i = 0; i < t; i++)
{
l = l->next;
}
return l;
}
void init(int n)
{
ListNode* node = head;
len = n;
int num;
while (n--)
{
cin >> num;
ListNode* l = new ListNode;
l->data = num;
node->next = l;
node = node->next;
}
}
int swap(int pa, int pb); //pa和pb表示两个结点在单链表的位置序号
int swap1(ListNode* p, ListNode* q); //p和q表示指向两个结点的指针
void LL_display();//输出单链表的内容
};
LinkList::LinkList()
{
head = new ListNode();
len = 0;
}
LinkList::~LinkList()
{
ListNode* p, * q;
p = head;
while (p != NULL)
{
q = p;
p = p->next;
delete q;
}
len = 0;
head = NULL;
}
int LinkList::swap(int pa, int pb)
{
if ((pa<1 || pa>len) || (pb<1 || pb>len))
{
cout << "error" << endl;
return 0;
}
else
{
ListNode* p = LL_index(pa - 1);
ListNode* q = LL_index(pb - 1);
if (p->next == q)
{
p->next = q->next;
q->next = p->next->next;
p->next->next = q;
return true;
}
ListNode* t = p->next;
p->next = q->next;
q->next = t;
t = p->next->next;
p->next->next = q->next->next;
q->next->next = t;
LL_display();
return true;
}
return pa, pb;
}
void LinkList::LL_display()
{
ListNode* p;
p = head->next;
while (p)
{
cout << p->data << " ";
p = p->next;
}
cout << endl;
}
int main()
{
int n;
cin >> n;
LinkList L;
L.init(n);
L.LL_display();
int pa, pb;
cin >> pa >> pb;
L.swap(pa, pb);
cin >> pa >> pb;
L.swap(pa, pb);
return 0;
}
未完待续....
