Merge pull request wangzheng0822#6 from RichardWeiYang/master

Implement array in c

Author: wangzheng0822

c-cpp/05_array/array.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct array {
+int size;
+int used;
+int *arr;
+};
+
+void dump(struct array *array)
+{
+int idx;
+
+for (idx = 0; idx < array->used; idx++)
+printf("[%02d]: %08d\n", idx, array->arr[idx]);
+}
+
+void alloc(struct array *array)
+{
+array->arr = (int *)malloc(array->size * sizeof(int));
+}
+
+int insert(struct array *array, int elem)
+{
+int idx;
+if (array->used >= array->size)
+return -1;
+
+for (idx = 0; idx < array->used; idx++) {
+if (array->arr[idx] > elem)
+break;
+}
+
+if (idx < array->used)
+memmove(&array->arr[array->used], &array->arr[idx],
+(array->used - idx) * sizeof(int));
+
+array->arr[idx] = elem;
+array->used++;
+return idx;
+}
+
+int delete(struct array *array, int idx)
+{
+if (idx < 0 || idx >= array->used)
+return -1;
+
+memmove(&array->arr[idx], &array->arr[idx+1],
+(array->used - idx) * sizeof(int));
+array->used--;
+return 0;
+}
+
+int search(struct array *array, int elem)
+{
+int idx;
+
+for (idx = 0; idx < array->used; idx++) {
+if (array->arr[idx] == elem)
+return idx;
+if (array->arr[idx] > elem)
+return -1;
+}
+
+return -1;
+}
+
+int main()
+{
+int idx;
+struct array ten_int = {10, 0, NULL};
+
+alloc(&ten_int);
+if (!ten_int.arr)
+return -1;
+insert(&ten_int, 1);
+insert(&ten_int, 3);
+insert(&ten_int, 2);
+printf("=== insert 1, 3, 2\n");
+dump(&ten_int);
+
+idx = search(&ten_int, 2);
+printf("2 is at position %d\n", idx);
+idx = search(&ten_int, 9);
+printf("9 is at position %d\n", idx);
+
+printf("=== delete [6] element \n");
+delete(&ten_int, 6);
+dump(&ten_int);
+printf("=== delete [0] element \n");
+delete(&ten_int, 0);
+dump(&ten_int);
+return 0;
+}

c-cpp/06_linkedlist/single_list.c

@@ -0,0 +1,176 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+struct single_list {
+struct single_list *next;
+int val;
+};
+
+struct single_list_head {
+struct single_list *head;
+};
+
+bool is_empty(struct single_list_head *head)
+{
+return head->head == NULL;
+}
+
+void dump(struct single_list_head *head)
+{
+struct single_list *tmp = head->head;
+int idx = 0;
+
+while (tmp) {
+printf("[%02d]: %08d\n", idx++, tmp->val);
+tmp = tmp->next;
+}
+}
+
+void insert(struct single_list **prev, struct single_list *elem)
+{
+if (!prev)
+return;
+
+if (*prev)
+elem->next = *prev;
+*prev = elem;
+}
+
+void insert_head(struct single_list_head *head, struct single_list *elem)
+{
+insert(&head->head, elem);
+}
+
+struct single_list* delete(struct single_list **prev)
+{
+struct single_list *tmp;
+
+if (!prev)
+return NULL;
+
+tmp = *prev;
+*prev = (*prev)->next;
+tmp->next = NULL;
+
+return tmp;
+}
+
+struct single_list* delete_head(struct single_list_head* head)
+{
+return delete(&head->head);
+}
+
+struct single_list** search(struct single_list_head* head, int target)
+{
+struct single_list **prev, *tmp;
+
+for (prev = &head->head, tmp = *prev;
+ tmp && (tmp->val < target);
+ prev = &tmp->next, tmp = *prev)
+;
+
+return prev;
+}
+
+void reverse(struct single_list_head* head)
+{
+struct single_list_head tmp;
+struct single_list *elem;
+
+while (!is_empty(head)) {
+elem = delete_head(head);
+insert_head(&tmp, elem);
+}
+
+head->head = tmp.head;
+}
+
+bool is_cyclic(struct single_list_head* head)
+{
+struct single_list *s1, *s2;
+
+s1 = s2 = head->head;
+
+while(s1 && s2) {
+s1 = s1->next;
+s2 = s2->next ? s2->next->next:s2->next;
+
+if (s1 == s2)
+return true;
+}
+return false;
+}
+
+struct single_list* middle(struct single_list_head* head)
+{
+struct single_list *s1, *s2;
+struct single_list pseudo_head;
+
+pseudo_head.next = head->head;
+s1 = s2 = &pseudo_head;
+
+while (true) {
+if (!s2 || !s2->next)
+return s1;
+s1 = s1->next;
+s2 = s2->next->next;
+}
+
+return NULL;
+}
+
+int main()
+{
+struct single_list_head head = {NULL};
+struct single_list lists[10];
+struct single_list **prev;
+int idx;
+
+for (idx = 0; idx < 10; idx++) {
+lists[idx].val = idx;
+lists[idx].next = NULL;
+}
+
+insert_head(&head, &lists[6]);
+insert_head(&head, &lists[5]);
+insert_head(&head, &lists[4]);
+insert_head(&head, &lists[1]);
+insert_head(&head, &lists[0]);
+
+printf("=== insert 0, 1, 4, 5, 6\n");
+dump(&head);
+
+prev = search(&head, 2);
+insert(prev, &lists[2]);
+printf("=== insert 2\n");
+dump(&head);
+
+printf("middle elem is %d\n", middle(&head)->val);
+
+prev = search(&head, 2);
+if ((*prev) && ((*prev)->val == 2))
+printf("The list contains 2\n");
+else
+printf("The list not contains 2\n");
+
+delete(prev);
+prev = search(&head, 2);
+printf("After remove 2\n");
+if ((*prev) && ((*prev)->val == 2))
+printf("The list contains 2\n");
+else
+printf("The list not contains 2\n");
+dump(&head);
+
+printf("After reverse \n");
+reverse(&head);
+dump(&head);
+
+printf("middle elem is %d\n", middle(&head)->val);
+
+lists[0].next = &lists[6];
+printf("list is%s cyclic\n", is_cyclic(&head)?"":" not");
+
+return 0;
+}
+