数据结构第一次作业（顺序表）

#include<iostream>

using namespace std;

#define LIST_MAX_LENGTH 10

typedef struct SequentialLIST
{
	int actuallength;
	int data[LIST_MAX_LENGTH];
}*SequentialListPtr;

void outputList(SequentialListPtr paraList)
{
	for (int i = 0; i < paraList->actuallength; i++)
		cout << paraList->data[i]<<" ";
	puts("");
}

void outputMemory(SequentialListPtr paraListPtr)
{
	printf("The address of the structure: %lld\r\n", paraListPtr);
	printf("The address of actualLength: %lld\r\n", &paraListPtr->actuallength);
	printf("The address of data: %lld\r\n", &paraListPtr->data);
	printf("The address of actual data: %lld\r\n", &paraListPtr->data[0]);
	printf("The address of second data: %lld\r\n", &paraListPtr->data[1]);
}

SequentialListPtr sequentialListInit(int paraData[], int paraLength) {
	SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(struct SequentialLIST));
	for (int i = 0; i < paraLength; i++)
	     resultPtr->data[i] = paraData[i];
	resultPtr->actuallength = paraLength;
	return resultPtr;
}

void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) 
{
    if (paraListPtr->actuallength >= LIST_MAX_LENGTH) {
        printf("Cannot insert element: list full.\r\n");
        return;
    }
    if (paraPosition < 0) {
        printf("Cannot insert element: negative position unsupported.");
        return;
    }
    if (paraPosition > paraListPtr->actuallength) {
        printf("Cannot insert element: the position %d is bigger than the list length %d.\r\n", paraPosition, paraListPtr->actuallength);
        return;
    }
    for (int i = paraListPtr->actuallength; i > paraPosition; i--) {
        paraListPtr->data[i] = paraListPtr->data[i - 1];
    }
    paraListPtr->data[paraPosition] = paraValue;
    paraListPtr->actuallength++;
}

void sequentialInsertTest() {
	int i;
	int tempArray[5] = { 3, 5, 2, 7, 4 };
	printf("---- sequentialInsertTest begins. ----\r\n");
	SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	printf("After initialization, the list is: ");
	outputList(tempList);
	printf("Now insert to the first, the list is: ");
	sequentialListInsert(tempList, 0, 8);
	outputList(tempList);
	printf("Now insert to the last, the list is: ");
	sequentialListInsert(tempList, 6, 9);
	outputList(tempList);
	printf("Now insert beyond the tail. \r\n");
	sequentialListInsert(tempList, 8, 9);
	printf("The list is:");
	outputList(tempList);
	for (i = 0; i < 11; i++) {
		printf("Inserting %d.\r\n", (i + 10));
		sequentialListInsert(tempList, 0, (i + 10));
		outputList(tempList);
	}
	printf("---- sequentialInsertTest ends. ----\n");
}

int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition) {
	if (paraPosition < 0) {
		printf("Invalid position: %d.\r\n", paraPosition);
		return -1;
	}

	if (paraPosition >= paraListPtr->actuallength) {
		printf("Cannot delete element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actuallength);
		return -1;
	}

	int resultValue = paraListPtr->data[paraPosition];
	for (int i = paraPosition; i < paraListPtr->actuallength; i++) {
		paraListPtr->data[i] = paraListPtr->data[i + 1];
	}

	paraListPtr->actuallength--;

	return resultValue;
}

void sequentialDeleteTest() {
	int tempArray[5] = { 3, 5, 2, 7, 4 };

	printf("---- sequentialDeleteTest begins. ----\n");

	SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	printf("After initialization, the list is: ");
	outputList(tempList);

	printf("Now delete the first, the list is: ");
	sequentialListDelete(tempList, 0);
	outputList(tempList);

	printf("Now delete the last, the list is: ");
	sequentialListDelete(tempList, 3);
	outputList(tempList);

	printf("Now delete the second, the list is: ");
	sequentialListDelete(tempList, 1);
	outputList(tempList);

	printf("Now delete the 5th, the list is: ");
	sequentialListDelete(tempList, 5);
	outputList(tempList);

	printf("Now delete the (-6)th, the list is: ");
	sequentialListDelete(tempList, -6);
	outputList(tempList);

	printf("---- sequentialDeleteTest ends. ----\r\n");

	outputMemory(tempList);
}

int locateElement(SequentialListPtr paraListPtr, int paraValue) {
	for (int i = 0; i < paraListPtr->actuallength; i++) {
		if (paraListPtr->data[i] == paraValue) {
			return i;
		}
	}
	return -1;
}

int getElement(SequentialListPtr paraListPtr, int paraPosition) {
	if (paraPosition < 0) {
		printf("Invalid position: %d.\r\n", paraPosition);
		return -1;
	}

	if (paraPosition >= paraListPtr->actuallength) {
		printf("Cannot get element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actuallength);
		return -1;
	}

	return paraListPtr->data[paraPosition];
}

void clearList(SequentialListPtr paraListPtr) {
	paraListPtr->actuallength = 0;
}
void main() {
	sequentialInsertTest();
	sequentialDeleteTest();
}

总结：

顺序表空间复杂度为O(n),插入和删除元素的时间复杂度为O(n)，其在内存堆区以连续储存空间存储，其本质是一个数组。
代码存在不足：查找元素时不能查找到该元素数量返回查找数量：

改进：

int locateElement(SequentialListPtr paraListPtr, int paraValue) {
    int count=0;
    for (int i = 0; i < paraListPtr->actuallength; i++) {
         if (paraListPtr->data[i] == paraValue) {
             count++;
            }	
    }
	return count;
}

 画图分析：

end