提示:该文章仅为完成作业,大佬请绕路
前言
提示:这里可以添加本文要记录的大概内容:
例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。
我的代码
#include <stdio.h>
#define maxSize 6
typedef struct {
int data;
int cur;
}component;
void InitArr(component *array) {
int i = 0;
for (i = 0; i < maxSize; i++) {
array[i].cur = i + 1;//将每个数组分量链接到一起
array[i].data = 0;
}
array[maxSize - 1].cur = 0;//链表最后一个结点的游标值为0
}
int mallocArr(component * array) {
//若备用链表非空,则返回分配的结点下标,否则返回 0(当分配最后一个结点时,
//该结点的游标值为 0)
int i = array[0].cur;
if (array[0].cur) {
array[0].cur = array[i].cur;
}
return i;
}
//初始化几个元素
void add(component * array)
{
printf("请输入你想添加的数据成员的数量:");
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
printf("请输入第%d个数据成员:",i);
scanf("%d",&array[i].data);
}
array[0].cur=n+1;
array[n].cur=0;
array[maxSize-1].cur=1;
}
//向链表中插入数据,add表示插入元素的位置,num表示要插入的数据
void insertArr(component * array, int add, int num) {
int tempBody = maxSize-1;//tempBody做遍历结构体数组使用
int i = 0, insert = 0;
//找到要插入位置的上一个结点在数组中的位置
for (i = 1; i < add; i++) {
tempBody = array[tempBody].cur;
}
insert = mallocArr(array);//申请空间,准备插入
array[insert].data = num;
array[insert].cur = array[tempBody].cur;//新插入结点的游标等于其直接前驱结点的游标
array[tempBody].cur = insert;//直接前驱结点的游标等于新插入结点所在数组中的下标
}
void displayArr(component * array) {
int tempBody = maxSize-1;//tempBody准备做遍历使用
tempBody=array[tempBody].cur;
while (array[tempBody].cur) {
printf("%d,%d ", array[tempBody].data, array[tempBody].cur);
tempBody = array[tempBody].cur;
}
printf("%d,%d\n", array[tempBody].data, array[tempBody].cur);
}
//查找数据域为elem的结点在数组中的位置
int selectNum(component * array, int num) {
//当游标值为0时,表示链表结束
int tempBody = maxSize-1;
while (array[tempBody].cur != 0) {
if (array[tempBody].data == num) {
return tempBody;
}
tempBody = array[tempBody].cur;
}
//判断最后一个结点是否符合要求
if (array[tempBody].data == num) {
return tempBody;
}
return -1;//返回-1,表示在链表中没有找到该元素
}
//在以body作为头结点的链表中将数据域为oldElem的结点,数据域改为newElem
void amendElem(component * array, int oldElem, int newElem) {
int add = selectNum(array,oldElem);
if (add == -1) {
printf("无更改元素");
return;
}
array[add].data = newElem;
}
void freeArr(component * array, int k) {
array[k].cur = array[0].cur;
array[0].cur = k;
}
//删除结点函数,num表示被删除结点中数据域存放的数据,函数返回新数据链表的表头位置
int deletArr(component * array, int num) {
int tempBody =maxSize-1;
int del = 0;
int newbody = 0;
//找到被删除结点的位置
while (array[tempBody].data != num) {
tempBody = array[tempBody].cur;
//当tempBody为0时,表示链表遍历结束,说明链表中没有存储该数据的结点
if (tempBody == 0) {
printf("链表中没有此数据");
return 0;
}
}
//运行到此,证明有该结点
del = tempBody;
tempBody = maxSize-1;
//删除首元结点,需要特殊考虑
if (del == array[maxSize-1].cur) {
newbody = array[del].cur;
array[maxSize-1].cur=newbody;
freeArr(array, del);
}
else
{
//找到该结点的上一个结点,做删除操作
while (array[tempBody].cur != del) {
tempBody = array[tempBody].cur;
}
//将被删除结点的游标直接给被删除结点的上一个结点
array[tempBody].cur = array[del].cur;
//回收被摘除节点的空间
freeArr(array, del);
}
}
int main()
{
component array[maxSize];
InitArr(array);
add(array);
int selectAdd;
printf("静态链表为:\n");
displayArr(array);
printf("在第3的位置上插入元素4:\n");
insertArr(array, 3, 4);
displayArr(array);
printf("删除数据域为1的结点:\n");
deletArr(array, 1);
displayArr(array);
printf("查找数据域为4的结点的位置:\n");
selectAdd = selectNum(array, 4);
printf("%d\n", selectAdd);
printf("将结点数据域为4改为5:\n");
amendElem(array, 4, 5);
displayArr(array);
return 0;
}
老师的代码
#include <stdio.h>
#include <malloc.h>
#define DEFAULT_SIZE 5
typedef struct StaticLinkedNode{
char data;
int next;
} *NodePtr;
typedef struct StaticLinkedList{
NodePtr nodes;
int* used;
} *ListPtr;
/**
* Initialize the list with a header.
* @return The pointer to the header.
*/
ListPtr initLinkedList(){
// The pointer to the whole list space.
ListPtr tempPtr = (ListPtr)malloc(sizeof(StaticLinkedList));
// Allocate total space.
tempPtr->nodes = (NodePtr)malloc(sizeof(struct StaticLinkedNode) * DEFAULT_SIZE);
tempPtr->used = (int*)malloc(sizeof(int) * DEFAULT_SIZE);
// The first node is the header.
tempPtr->nodes[0].data = '\0';
tempPtr->nodes[0].next = -1;
// Only the first node is used.
tempPtr->used[0] = 1;
for (int i = 1; i < DEFAULT_SIZE; i ++){
tempPtr->used[i] = 0;
}// Of for i
return tempPtr;
}// Of initLinkedList
/**
* Print the list.
* @param paraListPtr The pointer to the list.
*/
void printList(ListPtr paraListPtr){
int p = 0;
while (p != -1) {
printf("%c", paraListPtr->nodes[p].data);
p = paraListPtr->nodes[p].next;
}// Of while
printf("\r\n");
}// Of printList
/**
* Insert an element to the given position.
* @param paraListPtr The position of the list.
* @param paraChar The given char.
* @param paraPosition The given position.
*/
void insertElement(ListPtr paraListPtr, char paraChar, int paraPosition){
int p, q, i;
// Step 1. Search to the position.
p = 0;
for (i = 0; i < paraPosition; i ++) {
p = paraListPtr->nodes[p].next;
if (p == -1) {
printf("The position %d is beyond the scope of the list.\r\n", paraPosition);
return;
}// Of if
} // Of for i
// Step 2. Construct a new node.
for (i = 1; i < DEFAULT_SIZE; i ++){
if (paraListPtr->used[i] == 0){
// This is identical to malloc.
printf("Space at %d allocated.\r\n", i);
paraListPtr->used[i] = 1;
q = i;
break;
}// Of if
}// Of for i
if (i == DEFAULT_SIZE){
printf("No space.\r\n");
return;
}// Of if
paraListPtr->nodes[q].data = paraChar;
// Step 3. Now link.
printf("linking\r\n");
paraListPtr->nodes[q].next = paraListPtr->nodes[p].next;
paraListPtr->nodes[p].next = q;
}// Of insertElement
/**
* Delete an element from the list.
* @param paraHeader The header of the list.
* @param paraChar The given char.
*/
void deleteElement(ListPtr paraListPtr, char paraChar){
int p, q;
p = 0;
while ((paraListPtr->nodes[p].next != -1) && (paraListPtr->nodes[paraListPtr->nodes[p].next].data != paraChar)){
p = paraListPtr->nodes[p].next;
}// Of while
if (paraListPtr->nodes[p].next == -1) {
printf("Cannot delete %c\r\n", paraChar);
return;
}// Of if
q = paraListPtr->nodes[p].next;
paraListPtr->nodes[p].next = paraListPtr->nodes[paraListPtr->nodes[p].next].next;
// This statement is identical to free(q)
paraListPtr->used[q] = 0;
}// Of deleteElement
/**
* Unit test.
*/
void appendInsertDeleteTest(){
// Step 1. Initialize an empty list.
ListPtr tempList = initLinkedList();
printList(tempList);
// Step 2. Add some characters.
insertElement(tempList, 'H', 0);
insertElement(tempList, 'e', 1);
insertElement(tempList, 'l', 2);
insertElement(tempList, 'l', 3);
insertElement(tempList, 'o', 4);
printList(tempList);
// Step 3. Delete some characters (the first occurrence).
printf("Deleting 'e'.\r\n");
deleteElement(tempList, 'e');
printf("Deleting 'a'.\r\n");
deleteElement(tempList, 'a');
printf("Deleting 'o'.\r\n");
deleteElement(tempList, 'o');
printList(tempList);
insertElement(tempList, 'x', 1);
printList(tempList);
}// Of appendInsertDeleteTest
/**
* The entrance.
*/
void main(){
appendInsertDeleteTest();
}// Of main