数据结构实验—线性表（人机交互友好，纯c语言）

数据结构实验—线性表（人机交互友好，纯C语言）

数组

#include<stdio.h>
#include<stdlib.h>
#define LIST_INIT_SIZE 100 //顺序表的存储空间的大小
#define OVERFLOW -2
#define OK 1
#define ERROR 0
int e, i, j, n, q, x;     
typedef struct {
	int* elem; 
	int listsize; 
	int length; //当前线性表的长度
}SqList;

int InitList_Sq(SqList& L) {//构造一个空的线性表
	L.elem = (int*)malloc(LIST_INIT_SIZE * sizeof(int));//动态分配数组的空间：开辟100*4字节的空间并分为100个4字节的小空间给数组elem。
	if (!L.elem) {
		exit(OVERFLOW);  //存储空间分配失败
	}
	L.length = 0;
	L.listsize = LIST_INIT_SIZE;
	return OK;
}
int CreateList_Sq(SqList& L, int n) {
	printf("\n请输入数组的长度：");
	scanf("%d", &n);
	printf("\n请输入数组的元素：");
	for (i = 0; i < n; i++) {
		scanf("%d", &q);
		L.elem[i] = q;
		++L.length;
	}
	printf("\n数组为：");
	for (i = 0; i < n; i++) {
		printf("%d  ", L.elem[i]);
	}
	return OK;
}
//顺序表的插入函数（插入新元素）
//在第i个元素之前插入新元素e
//i的合法值为1<=i<=L.length+1
int ListInsert_Sq(SqList& L, int i, int e) {
	//在第i个元素之前插入新元素e，表的长度加1
	printf("\n请输入要插入的元素：");
	scanf("%d", &e);
	printf("\n请输入要插入的位置：");
	scanf("%d", &i);
	if (i <1 || i > L.length + 1) {//i的取值不合法
		printf("输入的i的数值不合法");
		return ERROR;
	}
	if (L.length == L.listsize) {//线性表的长度等于线性表的存储容量，说明存储空间已满，所以不合法
		return ERROR;
	}
	for (int j = L.length; j >= i - 1; j--) {
		L.elem[j] = L.elem[j - 1];//把插入位置和之后的元素位置后移
	}
	L.elem[i - 1] = e;//将新元素e插入
	L.length++;//表长加一
	printf("\n插入新元素%d", e);
	printf("以后的数组为:");
	for (i = 0; i < L.length; i++) {
		printf("%d\t", L.elem[i]);
	}
	return OK;
}
//顺序表的删除函数
int ListDelete_Sq(SqList& L, int i) {
	//删除第i个元素，并用e返回其值，表的长度减1
	printf("\n请输入要删除的位置：");
	scanf("%d", &i);
	if (i<1 || i>L.length) {
		printf("输入的i的数值不合法");
		return ERROR;
	}
	for (j = i; j < L.length; j++) {
		L.elem[j - 1] = L.elem[j];
	}
	L.length--;
	printf("\n删除第%d个元素以后的数组为:", i);
	for (i = 0; i < L.length; i++) {
		printf("%d\t", L.elem[i]);
	}
	return OK;
}
//顺序表的查找函数
int GetElem(SqList& L, int x) {
	printf("\n请输入要查找的元素：");
	scanf("%d", &x);
	for (i = 0; i < L.length; i++) {
		if (L.elem[i] == x) {
			printf("\n%d在线性表里面，位置是%d", x, i + 1);
			return OK; //找到了就直接退出函数
		}
	}
	printf("\n%d不在线性表里面.", x);
	return OK;
}
int main() {
	SqList L;
	InitList_Sq(L);
	CreateList_Sq(L, n);
	GetElem(L, x);
	ListDelete_Sq(L, i);
	ListInsert_Sq(L, i, e);
	return 0;
}

链表

#include<iostream>
#include<stdio.h>
using namespace std;
#define Boolean int
#define OK 1
#define ERROR 0
typedef struct LNode {
	LNode* next;
	int data;
}LNode, * LinkList;
void showList(LinkList& List) {//等价于LNode *&List
	LNode* p = List;
	LNode* s = List;
	int index = 0;
	cout << "当前链表信息:" << endl;//此处输出下标所用，没有实际意义 
	while (s != NULL) {
		cout << index++ << " ";
		//		cout<<s->data<<" ";
		s = s->next;
	}
	cout << "<-下标" << endl;
	while (p != NULL) {
		cout << p->data << " ";
		p = p->next;
	}
	cout << "<-节点值" << endl;
}

void initial(LNode*& List) {
	List = new LNode;
	List->data = 0;
	List->next = NULL;
	cout << "无头结点单向链表初始化完毕!初始节点data为0" << endl;
}

void addNode(LinkList& List, int data) {//增加一个节点 
	LNode* p = List;
	while (p->next != NULL) {
		p = p->next;
	}
	LNode* node = new LNode;
	node->next = NULL;
	node->data = data;
	p->next = node;
}

void add(LinkList& List) {
	int c;
	while (1) {
		cout << "请输入新增节点的data(输入-1停止新增):";
		cin >> c;
		if (c == -1) {
			break;
		}
		addNode(List, c);
	}
	cout << "节点新增完成!";
	showList(List);
}



void insertNode(LinkList& List, int index) {
	int i = 1;
	//如果data插入到第index个元素前,i设为1。 
	//如果插入到第index个后，i设为0。 
	LNode* p = List;
	while (p != NULL && i < index) {
		i++;
		p = p->next;
	}
	if (i < index || !p) {
		cout << "插入位置超出链表长度!";
	}
	else {
		LNode* node = new LNode;
		node->next = p->next;
		int data;
		cout << "请输入新节点的data:";
		cin >> data;
		node->data = data;
		p->next = node;
	}
}

void insert(LinkList& List) {
	cout << "请输入插入数据的位置(从1开始算):";
	int index;
	cin >> index;
	insertNode(List, index);
	cout << "节点插入完成!";
	showList(List);
}

Boolean delNode(LNode*& List, int index) {
	int i = 0;
	LNode* p = List;
	while (p->next != NULL && i + 1 < index) {
		i++;
		//		cout<<p->data<<" ";
		p = p->next;
	}
	if (i + 1 < index || !p) {
		return ERROR;
	}
	else {
		LNode* t = new LNode;
		t = p->next;

		p->next = t->next;//p指向下一个地址（被删除地址）的下一个地址 
		//	t = t->next;
		//	p->next = t;
		//	t = NULL
		//如果是把t->next和p->next分开写一定要记得先把当前t对应的地址去除
		//否则delete t 就是把该地址清空
		//也就是把链表对应的位置一并清除了，导致野指针程序出错 
		delete t;
		return OK;
	}
}

void del(LinkList& List) {
	int index;
	cout << "请输入删除节点的下标（从1开始算起,最开始的那个0不算做节点）:";
	cin >> index;
	if (delNode(List, index)) {
		cout << "第" << index << "个节点删除完成!";
		showList(List);
	}
	else {
		cout << "节点删除失败!" << endl;
	}
}

Boolean searchNode(LinkList& List, int data) {
	LinkList p = List;
	int index = 0;
	Boolean flag = ERROR;
	while (p != NULL) {
		if (p->data == data) {
			cout << "查找成功!第" << index << "个节点数据为" << data << endl;
			flag = OK;
			//此处不设置跳出是为了查询相同元素的全部下标位置
			//如果只需要查询第一次出现的位置，在此处设置跳出循环即可 
		}
		p = p->next;
		index++;
	}
	return flag;
}

void search(LinkList& List) {
	int data;
	cout << "请输入要查找的data:";
	cin >> data;
	if (!searchNode(List, data)) {//取非 
		cout << "No this data!" << endl;
	}
}

void menu(LinkList& List) {
	int c = 0;
	while (1) {
		cout << "请选择操作:" << endl;
		cout << "1:新增节点" << endl;
		cout << "2:插入节点" << endl;
		cout << "3:删除节点" << endl;
		cout << "4:展示节点" << endl;
		cout << "5:搜索节点" << endl;
		cout << "6:退出系统" << endl;
		cin >> c;
		switch (c) {
		case 1:add(List); break;
		case 2:insert(List); break;
		case 3:del(List); break;
		case 4:showList(List); break;
		case 5:search(List); break;
		case 6:return;
		default:;
		}
	}
}

int main() {
	LNode* List;
	initial(List);
	menu(List);
	return 0;
}

双链表

#include <stdio.h>
#include <stdlib.h>
typedef int ListData;
typedef struct dnode
{
    ListData data;
    struct dnode* llink, * rlink;
}DblNode;
typedef DblNode* DblList;
DblList CreatList(DblList& first)//创建双向链表
{
    first = (DblList)malloc(sizeof(DblNode));
    ListData x;
    if (first == NULL)
    {
        printf("存储分配错!\n");
        exit(1);
    }
    first->llink = first->rlink = NULL;
    DblNode* p, * q = first;
    printf("请输入链表元素:\n");
    do
    {
        scanf("%d", &x);
        p = (DblNode*)malloc(sizeof(DblNode));
        p->data = x;
        p->llink = q;
        q->rlink = p;
        q = p;
    } while (getchar() != '\n');
    q->rlink = NULL;
    return first;
}
DblList Insert(DblList& first, int i, ListData x)//向链表中插入某个节点
{
    DblNode* p = first, * q;
    for (int k = 0; k < i - 1; k++)//找到第i-1个结点,即要插入位置的前驱
    {
        if (p == NULL) break;
        else
            p = p->rlink;
    }
    if (p == NULL || i <= 0)printf("无效的插入位置!\n");
    else
    {
        q = (DblNode*)malloc(sizeof(DblNode));
        q->data = x;
        q->llink = p;
        q->rlink = p->rlink;
        if (p->rlink != NULL)
            p->rlink->llink = q;
        p->rlink = q;
    }
    return first;
}

DblList Delete(DblList& first, ListData x)//删除链表中某个节点
{
    DblNode* p = first->rlink;
    while (p != NULL && p->data != x)
    {
        p = p->rlink;
    }
    if (p == NULL)printf("无效的删除!\n");
    else
    {
        if (p->rlink != NULL)
            p->rlink->llink = p->llink;
        p->llink->rlink = p->rlink;
        free(p);
    }
    return first;
}

int Findv(DblList first, ListData x)//按值查找
{
    DblNode* p = first->rlink;
    int i = 1;
    while (p != NULL && p->data != x)
    {
        p = p->rlink;
        i++;
    }
    if (p == NULL) { printf("查找失败!\n"); return 0; }
    else return i;
}

ListData Finds(DblList first, int s)//按序号查找
{
    DblNode* p = first;
    for (int k = 0; k < s; k++)
    {
        if (p == NULL) break;
        else
            p = p->rlink;
    }
    if (s <= 0 || p == NULL) { printf("查找失败!\n"); return-1; }
    return p->data;
}
void OutPut(DblList first)//输出链表中元素
{
    printf("Output the elements of the List:\n");
    DblNode* p = first->rlink;
    while (p != NULL)
    {
        printf("%d\t", p->data);
        p = p->rlink;
    }
    printf("\n");
}
int main()
{
    DblList first = NULL;
    int s; ListData x;
    first = CreatList(first);
    OutPut(first);
    printf("要插入的值和位置分别为:\t");
    scanf("%d%d", &x, &s);
    first = Insert(first, s, x);
    OutPut(first);
    printf("按值查找要查找的值为:\t");
    scanf("%d", &x);
    s = Findv(first, x);
    if (s != 0)
        printf("按值查找该值所在位置为:\t%d\n", s);
    printf("按序号查找要查找的位置为:\t");
    scanf("%d", &s);
    x = Finds(first, s);
    if (x != -1)
        printf("按序号查找该位置的值为:\t%d\n", x);
    printf("要删除的结点值为:\t");
    scanf("%d", &x);
    first = Delete(first, x);
    OutPut(first);
    return 0;
}

间接寻址

#include<iostream>
#include<iomanip>   //使用了setw()
using namespace std;
const int MaxSize = 100;
struct Node
{
	int data;     //存放的数据
};
class LinkList
{
public:
	LinkList()   /*无参构造函数*/
	{
		length = 0;
	}
	LinkList(int a[], int n);  /*建立有n个元素的链表*/
	~LinkList() {}
	void Insert(int i, int x);   /*在第i个位置中插入元素值为X的结点*/
	int Length()  /*求链表的长度*/
	{
		return length;
	}
	int Get(int i);   /*按位查找，在链表中查找第i个结点的元素值*/
	int Locate(int x);    /*按值查找*/
	int Delete(int i);   /*删除链表中第i个结点*/
	void PrintList();   /*按序号依次输出各元素*/

private:
	Node* ads[MaxSize];
	int length;
};
//构造函数
LinkList::LinkList(int a[], int n)
{
	for (int i = 0; i < n; i++)
	{
		ads[i] = new Node;    //数据指向每一个结点
		ads[i]->data = a[i];    //将数据填入每个数组指向的结点
	}
	length = n;
}

//插入算法
void LinkList::Insert(int i, int x)
{
	if (i <= length && i >= 0)
	{
		for (int j = length; j >= i; j--)
		{
			ads[j] = ads[j - 1];
		}
		ads[i - 1]->data = x;
		length++;
	}
	else {
		throw "位置非法";
	}
}

//遍历链表的数据
void LinkList::PrintList()
{
	for (int i = 0; i < length; i++)
	{
		cout << ads[i]->data << endl;
	}
}

//按位查找数据
int LinkList::Get(int i)
{
	if (i <= length && i > 0)
	{
		i = i - 1;
		return ads[i]->data;
	}
	else {
		throw "位置非法";
	}

}
//按值查找数据
int LinkList::Locate(int x)
{
	int count = 0;

	for (count; count < length; count++)
	{
		if (ads[count]->data == x)
		{
			return count + 1;
		}
	}
	return 0;
}

//删除链表中第i个结点
int LinkList::Delete(int i)
{
	if (i <= length && i >= 0)
	{
		int x = ads[i - 1]->data;
		for (int j = i; j < length; j++)
		{
			ads[j - 1] = ads[j];
		}
		length--;
		return x;

	}
	else {
		throw "位置非法";
	}
}
int main()
{
	int n, i;
	int a[100];
	cout << "请输入数组的大小" << endl;
	cin >> n;
	cout << '\n' << endl;
	cout << "请输入数组元素" << endl;
	for (i = 0; i < n; i++)
	{
		cin >> a[i];
	}
	LinkList one(a, n);
	cout << '\n' << endl;
	cout << "线性表的长" << one.Length() << endl;
	cout << '\n' << "线性表中的内容：" << endl;
	one.PrintList();  //输出线性表的数据

	//按位查找
	int s;
	cout << "请输入要查找数据的序号：" << endl;
	cin >> s;
	cout  << "您所查询的数据为"<<endl;
	cout << one.Get(s) << endl;
	//按值查找
	int x;
	cin >> x;
	cout << "请输入你所要查询的值:" << endl;
	cout << "你所查找的值所在的位置为：" << one.Locate(x) << endl;
	//按序号删除数据
	int k;
	cout << "请输入需要删除的数据序号:"<<endl;
	cin >> k;
	cout<< "删除成功！你所删除的数据为：" << one.Delete(k) << endl;
	cout  << "线性表的内容为:" << endl;
	one.PrintList();  //输出线性表的数据
	return 0;
}